swiper-bundle.js

js araratnews.am collected 2026-10-02 09:55:32 UTC 419,313 bytes, 9,821 lines download raw bytes

vendor: 4,271 bytes, lines 1-160

1/**
2 * Swiper 11.2.6
3 * Most modern mobile touch slider and framework with hardware accelerated transitions
4 * https://swiperjs.com
5 *
6 * Copyright 2014-2025 Vladimir Kharlampidi
7 *
8 * Released under the MIT License
9 *
10 * Released on: March 19, 2025
11 */
12
13var Swiper = (function () {
14    'use strict';
15
16    /**
17     * SSR Window 5.0.0
18     * Better handling for window object in SSR environment
19     * https://github.com/nolimits4web/ssr-window
20     *
21     * Copyright 2025, Vladimir Kharlampidi
22     *
23     * Licensed under MIT
24     *
25     * Released on: February 12, 2025
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        const noExtend = ['__proto__', 'constructor', 'prototype'];
39        Object.keys(src).filter(key => noExtend.indexOf(key) < 0).forEach(key => {
40            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) {
41                extend$1(target[key], src[key]);
42            }
43        });
44    }
45    const ssrDocument = {
46        body: {},
47        addEventListener() {},
48        removeEventListener() {},
49        activeElement: {
50            blur() {},
51            nodeName: ''
52        },
53        querySelector() {
54            return null;
55        },
56        querySelectorAll() {
57            return [];
58        },
59        getElementById() {
60            return null;
61        },
62        createEvent() {
63            return {
64                initEvent() {}
65            };
66        },
67        createElement() {
68            return {
69                children: [],
70                childNodes: [],
71                style: {},
72                setAttribute() {},
73                getElementsByTagName() {
74                    return [];
75                }
76            };
77        },
78        createElementNS() {
79            return {};
80        },
81        importNode() {
82            return null;
83        },
84        location: {
85            hash: '',
86            host: '',
87            hostname: '',
88            href: '',
89            origin: '',
90            pathname: '',
91            protocol: '',
92            search: ''
93        }
94    };
95    function getDocument() {
96        const doc = typeof document !== 'undefined' ? document : {};
97        extend$1(doc, ssrDocument);
98        return doc;
99    }
100    const ssrWindow = {
101        document: ssrDocument,
102        navigator: {
103            userAgent: ''
104        },
105        location: {
106            hash: '',
107            host: '',
108            hostname: '',
109            href: '',
110            origin: '',
111            pathname: '',
112            protocol: '',
113            search: ''
114        },
115        history: {
116            replaceState() {},
117            pushState() {},
118            go() {},
119            back() {}
120        },
121        CustomEvent: function CustomEvent() {
122            return this;
123        },
124        addEventListener() {},
125        removeEventListener() {},
126        getComputedStyle() {
127            return {
128                getPropertyValue() {
129                    return '';
130                }
131            };
132        },
133        Image() {},
134        Date() {},
135        screen: {},
136        setTimeout() {},
137        clearTimeout() {},
138        matchMedia() {
139            return {};
140        },
141        requestAnimationFrame(callback) {
142            if (typeof setTimeout === 'undefined') {
143                callback();
144                return null;
145            }
146            return setTimeout(callback, 0);
147        },
148        cancelAnimationFrame(id) {
149            if (typeof setTimeout === 'undefined') {
150                return;
151            }
152            clearTimeout(id);
153        }
154    };
155    function getWindow() {
156        const win = typeof window !== 'undefined' ? window : {};
157        extend$1(win, ssrWindow);
158        return win;
159    }
160

vendor: 9,595 bytes, lines 161-390

161    function classesToTokens(classes) {
162        if (classes === void 0) {
163            classes = '';
164        }
165        return classes.trim().split(' ').filter(c => !!c.trim());
166    }
167
168    function deleteProps(obj) {
169        const object = obj;
170        Object.keys(object).forEach(key => {
171            try {
172                object[key] = null;
173            } catch (e) {
174                // no getter for object
175            }
176            try {
177                delete object[key];
178            } catch (e) {
179                // something got wrong
180            }
181        });
182    }
183    function nextTick(callback, delay) {
184        if (delay === void 0) {
185            delay = 0;
186        }
187        return setTimeout(callback, delay);
188    }
189    function now() {
190        return Date.now();
191    }
192    function getComputedStyle$1(el) {
193        const window = getWindow();
194        let style;
195        if (window.getComputedStyle) {
196            style = window.getComputedStyle(el, null);
197        }
198        if (!style && el.currentStyle) {
199            style = el.currentStyle;
200        }
201        if (!style) {
202            style = el.style;
203        }
204        return style;
205    }
206    function getTranslate(el, axis) {
207        if (axis === void 0) {
208            axis = 'x';
209        }
210        const window = getWindow();
211        let matrix;
212        let curTransform;
213        let transformMatrix;
214        const curStyle = getComputedStyle$1(el);
215        if (window.WebKitCSSMatrix) {
216            curTransform = curStyle.transform || curStyle.webkitTransform;
217            if (curTransform.split(',').length > 6) {
218                curTransform = curTransform.split(', ').map(a => a.replace(',', '.')).join(', ');
219            }
220            // Some old versions of Webkit choke when 'none' is passed; pass
221            // empty string instead in this case
222            transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
223        } else {
224            transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
225            matrix = transformMatrix.toString().split(',');
226        }
227        if (axis === 'x') {
228            // Latest Chrome and webkits Fix
229            if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41;
230            // Crazy IE10 Matrix
231            else if (matrix.length === 16) curTransform = parseFloat(matrix[12]);
232            // Normal Browsers
233            else curTransform = parseFloat(matrix[4]);
234        }
235        if (axis === 'y') {
236            // Latest Chrome and webkits Fix
237            if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42;
238            // Crazy IE10 Matrix
239            else if (matrix.length === 16) curTransform = parseFloat(matrix[13]);
240            // Normal Browsers
241            else curTransform = parseFloat(matrix[5]);
242        }
243        return curTransform || 0;
244    }
245    function isObject(o) {
246        return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';
247    }
248    function isNode(node) {
249        // eslint-disable-next-line
250        if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
251            return node instanceof HTMLElement;
252        }
253        return node && (node.nodeType === 1 || node.nodeType === 11);
254    }
255    function extend() {
256        const to = Object(arguments.length <= 0 ? undefined : arguments[0]);
257        const noExtend = ['__proto__', 'constructor', 'prototype'];
258        for (let i = 1; i < arguments.length; i += 1) {
259            const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
260            if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
261                const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);
262                for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
263                    const nextKey = keysArray[nextIndex];
264                    const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
265                    if (desc !== undefined && desc.enumerable) {
266                        if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
267                            if (nextSource[nextKey].__swiper__) {
268                                to[nextKey] = nextSource[nextKey];
269                            } else {
270                                extend(to[nextKey], nextSource[nextKey]);
271                            }
272                        } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
273                            to[nextKey] = {};
274                            if (nextSource[nextKey].__swiper__) {
275                                to[nextKey] = nextSource[nextKey];
276                            } else {
277                                extend(to[nextKey], nextSource[nextKey]);
278                            }
279                        } else {
280                            to[nextKey] = nextSource[nextKey];
281                        }
282                    }
283                }
284            }
285        }
286        return to;
287    }
288    function setCSSProperty(el, varName, varValue) {
289        el.style.setProperty(varName, varValue);
290    }
291    function animateCSSModeScroll(_ref) {
292        let {
293            swiper,
294            targetPosition,
295            side
296        } = _ref;
297        const window = getWindow();
298        const startPosition = -swiper.translate;
299        let startTime = null;
300        let time;
301        const duration = swiper.params.speed;
302        swiper.wrapperEl.style.scrollSnapType = 'none';
303        window.cancelAnimationFrame(swiper.cssModeFrameID);
304        const dir = targetPosition > startPosition ? 'next' : 'prev';
305        const isOutOfBound = (current, target) => {
306            return dir === 'next' && current >= target || dir === 'prev' && current <= target;
307        };
308        const animate = () => {
309            time = new Date().getTime();
310            if (startTime === null) {
311                startTime = time;
312            }
313            const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
314            const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;
315            let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
316            if (isOutOfBound(currentPosition, targetPosition)) {
317                currentPosition = targetPosition;
318            }
319            swiper.wrapperEl.scrollTo({
320                [side]: currentPosition
321            });
322            if (isOutOfBound(currentPosition, targetPosition)) {
323                swiper.wrapperEl.style.overflow = 'hidden';
324                swiper.wrapperEl.style.scrollSnapType = '';
325                setTimeout(() => {
326                    swiper.wrapperEl.style.overflow = '';
327                    swiper.wrapperEl.scrollTo({
328                        [side]: currentPosition
329                    });
330                });
331                window.cancelAnimationFrame(swiper.cssModeFrameID);
332                return;
333            }
334            swiper.cssModeFrameID = window.requestAnimationFrame(animate);
335        };
336        animate();
337    }
338    function getSlideTransformEl(slideEl) {
339        return slideEl.querySelector('.swiper-slide-transform') || slideEl.shadowRoot && slideEl.shadowRoot.querySelector('.swiper-slide-transform') || slideEl;
340    }
341    function elementChildren(element, selector) {
342        if (selector === void 0) {
343            selector = '';
344        }
345        const window = getWindow();
346        const children = [...element.children];
347        if (window.HTMLSlotElement && element instanceof HTMLSlotElement) {
348            children.push(...element.assignedElements());
349        }
350        if (!selector) {
351            return children;
352        }
353        return children.filter(el => el.matches(selector));
354    }
355    function elementIsChildOfSlot(el, slot) {
356        // Breadth-first search through all parent's children and assigned elements
357        const elementsQueue = [slot];
358        while (elementsQueue.length > 0) {
359            const elementToCheck = elementsQueue.shift();
360            if (el === elementToCheck) {
361                return true;
362            }
363            elementsQueue.push(...elementToCheck.children, ...(elementToCheck.shadowRoot ? elementToCheck.shadowRoot.children : []), ...(elementToCheck.assignedElements ? elementToCheck.assignedElements() : []));
364        }
365    }
366    function elementIsChildOf(el, parent) {
367        const window = getWindow();
368        let isChild = parent.contains(el);
369        if (!isChild && window.HTMLSlotElement && parent instanceof HTMLSlotElement) {
370            const children = [...parent.assignedElements()];
371            isChild = children.includes(el);
372            if (!isChild) {
373                isChild = elementIsChildOfSlot(el, parent);
374            }
375        }
376        return isChild;
377    }
378    function showWarning(text) {
379        try {
380            console.warn(text);
381            return;
382        } catch (err) {
383            // err
384        }
385    }
386    function createElement(tag, classes) {
387        if (classes === void 0) {
388            classes = [];
389        }
390        const el = document.createElement(tag);

vendor: 4,113 bytes, lines 391-497

391        el.classList.add(...(Array.isArray(classes) ? classes : classesToTokens(classes)));
392        return el;
393    }
394    function elementOffset(el) {
395        const window = getWindow();
396        const document = getDocument();
397        const box = el.getBoundingClientRect();
398        const body = document.body;
399        const clientTop = el.clientTop || body.clientTop || 0;
400        const clientLeft = el.clientLeft || body.clientLeft || 0;
401        const scrollTop = el === window ? window.scrollY : el.scrollTop;
402        const scrollLeft = el === window ? window.scrollX : el.scrollLeft;
403        return {
404            top: box.top + scrollTop - clientTop,
405            left: box.left + scrollLeft - clientLeft
406        };
407    }
408    function elementPrevAll(el, selector) {
409        const prevEls = [];
410        while (el.previousElementSibling) {
411            const prev = el.previousElementSibling; // eslint-disable-line
412            if (selector) {
413                if (prev.matches(selector)) prevEls.push(prev);
414            } else prevEls.push(prev);
415            el = prev;
416        }
417        return prevEls;
418    }
419    function elementNextAll(el, selector) {
420        const nextEls = [];
421        while (el.nextElementSibling) {
422            const next = el.nextElementSibling; // eslint-disable-line
423            if (selector) {
424                if (next.matches(selector)) nextEls.push(next);
425            } else nextEls.push(next);
426            el = next;
427        }
428        return nextEls;
429    }
430    function elementStyle(el, prop) {
431        const window = getWindow();
432        return window.getComputedStyle(el, null).getPropertyValue(prop);
433    }
434    function elementIndex(el) {
435        let child = el;
436        let i;
437        if (child) {
438            i = 0;
439            // eslint-disable-next-line
440            while ((child = child.previousSibling) !== null) {
441                if (child.nodeType === 1) i += 1;
442            }
443            return i;
444        }
445        return undefined;
446    }
447    function elementParents(el, selector) {
448        const parents = []; // eslint-disable-line
449        let parent = el.parentElement; // eslint-disable-line
450        while (parent) {
451            if (selector) {
452                if (parent.matches(selector)) parents.push(parent);
453            } else {
454                parents.push(parent);
455            }
456            parent = parent.parentElement;
457        }
458        return parents;
459    }
460    function elementTransitionEnd(el, callback) {
461        function fireCallBack(e) {
462            if (e.target !== el) return;
463            callback.call(el, e);
464            el.removeEventListener('transitionend', fireCallBack);
465        }
466        if (callback) {
467            el.addEventListener('transitionend', fireCallBack);
468        }
469    }
470    function elementOuterSize(el, size, includeMargins) {
471        const window = getWindow();
472        if (includeMargins) {
473            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'));
474        }
475        return el.offsetWidth;
476    }
477    function makeElementsArray(el) {
478        return (Array.isArray(el) ? el : [el]).filter(e => !!e);
479    }
480    function getRotateFix(swiper) {
481        return v => {
482            if (Math.abs(v) > 0 && swiper.browser && swiper.browser.need3dFix && Math.abs(v) % 90 === 0) {
483                return v + 0.001;
484            }
485            return v;
486        };
487    }
488
489    let support;
490    function calcSupport() {
491        const window = getWindow();
492        const document = getDocument();
493        return {
494            smoothScroll: document.documentElement && document.documentElement.style && 'scrollBehavior' in document.documentElement.style,
495            touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch)
496        };
497    }

vendor: 22,072 bytes, lines 498-1016

498    function getSupport() {
499        if (!support) {
500            support = calcSupport();
501        }
502        return support;
503    }
504
505    let deviceCached;
506    function calcDevice(_temp) {
507        let {
508            userAgent
509        } = _temp === void 0 ? {} : _temp;
510        const support = getSupport();
511        const window = getWindow();
512        const platform = window.navigator.platform;
513        const ua = userAgent || window.navigator.userAgent;
514        const device = {
515            ios: false,
516            android: false
517        };
518        const screenWidth = window.screen.width;
519        const screenHeight = window.screen.height;
520        const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
521        let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
522        const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
523        const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
524        const windows = platform === 'Win32';
525        let macos = platform === 'MacIntel';
526
527        // iPadOs 13 fix
528        const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
529        if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
530            ipad = ua.match(/(Version)\/([\d.]+)/);
531            if (!ipad) ipad = [0, 1, '13_0_0'];
532            macos = false;
533        }
534
535        // Android
536        if (android && !windows) {
537            device.os = 'android';
538            device.android = true;
539        }
540        if (ipad || iphone || ipod) {
541            device.os = 'ios';
542            device.ios = true;
543        }
544
545        // Export object
546        return device;
547    }
548    function getDevice(overrides) {
549        if (overrides === void 0) {
550            overrides = {};
551        }
552        if (!deviceCached) {
553            deviceCached = calcDevice(overrides);
554        }
555        return deviceCached;
556    }
557
558    let browser;
559    function calcBrowser() {
560        const window = getWindow();
561        const device = getDevice();
562        let needPerspectiveFix = false;
563        function isSafari() {
564            const ua = window.navigator.userAgent.toLowerCase();
565            return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
566        }
567        if (isSafari()) {
568            const ua = String(window.navigator.userAgent);
569            if (ua.includes('Version/')) {
570                const [major, minor] = ua.split('Version/')[1].split(' ')[0].split('.').map(num => Number(num));
571                needPerspectiveFix = major < 16 || major === 16 && minor < 2;
572            }
573        }
574        const isWebView = /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent);
575        const isSafariBrowser = isSafari();
576        const need3dFix = isSafariBrowser || isWebView && device.ios;
577        return {
578            isSafari: needPerspectiveFix || isSafariBrowser,
579            needPerspectiveFix,
580            need3dFix,
581            isWebView
582        };
583    }
584    function getBrowser() {
585        if (!browser) {
586            browser = calcBrowser();
587        }
588        return browser;
589    }
590
591    function Resize(_ref) {
592        let {
593            swiper,
594            on,
595            emit
596        } = _ref;
597        const window = getWindow();
598        let observer = null;
599        let animationFrame = null;
600        const resizeHandler = () => {
601            if (!swiper || swiper.destroyed || !swiper.initialized) return;
602            emit('beforeResize');
603            emit('resize');
604        };
605        const createObserver = () => {
606            if (!swiper || swiper.destroyed || !swiper.initialized) return;
607            observer = new ResizeObserver(entries => {
608                animationFrame = window.requestAnimationFrame(() => {
609                    const {
610                        width,
611                        height
612                    } = swiper;
613                    let newWidth = width;
614                    let newHeight = height;
615                    entries.forEach(_ref2 => {
616                        let {
617                            contentBoxSize,
618                            contentRect,
619                            target
620                        } = _ref2;
621                        if (target && target !== swiper.el) return;
622                        newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
623                        newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
624                    });
625                    if (newWidth !== width || newHeight !== height) {
626                        resizeHandler();
627                    }
628                });
629            });
630            observer.observe(swiper.el);
631        };
632        const removeObserver = () => {
633            if (animationFrame) {
634                window.cancelAnimationFrame(animationFrame);
635            }
636            if (observer && observer.unobserve && swiper.el) {
637                observer.unobserve(swiper.el);
638                observer = null;
639            }
640        };
641        const orientationChangeHandler = () => {
642            if (!swiper || swiper.destroyed || !swiper.initialized) return;
643            emit('orientationchange');
644        };
645        on('init', () => {
646            if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
647                createObserver();
648                return;
649            }
650            window.addEventListener('resize', resizeHandler);
651            window.addEventListener('orientationchange', orientationChangeHandler);
652        });
653        on('destroy', () => {
654            removeObserver();
655            window.removeEventListener('resize', resizeHandler);
656            window.removeEventListener('orientationchange', orientationChangeHandler);
657        });
658    }
659
660    function Observer(_ref) {
661        let {
662            swiper,
663            extendParams,
664            on,
665            emit
666        } = _ref;
667        const observers = [];
668        const window = getWindow();
669        const attach = function (target, options) {
670            if (options === void 0) {
671                options = {};
672            }
673            const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
674            const observer = new ObserverFunc(mutations => {
675                // The observerUpdate event should only be triggered
676                // once despite the number of mutations.  Additional
677                // triggers are redundant and are very costly
678                if (swiper.__preventObserver__) return;
679                if (mutations.length === 1) {
680                    emit('observerUpdate', mutations[0]);
681                    return;
682                }
683                const observerUpdate = function observerUpdate() {
684                    emit('observerUpdate', mutations[0]);
685                };
686                if (window.requestAnimationFrame) {
687                    window.requestAnimationFrame(observerUpdate);
688                } else {
689                    window.setTimeout(observerUpdate, 0);
690                }
691            });
692            observer.observe(target, {
693                attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
694                childList: swiper.isElement || (typeof options.childList === 'undefined' ? true : options).childList,
695                characterData: typeof options.characterData === 'undefined' ? true : options.characterData
696            });
697            observers.push(observer);
698        };
699        const init = () => {
700            if (!swiper.params.observer) return;
701            if (swiper.params.observeParents) {
702                const containerParents = elementParents(swiper.hostEl);
703                for (let i = 0; i < containerParents.length; i += 1) {
704                    attach(containerParents[i]);
705                }
706            }
707            // Observe container
708            attach(swiper.hostEl, {
709                childList: swiper.params.observeSlideChildren
710            });
711
712            // Observe wrapper
713            attach(swiper.wrapperEl, {
714                attributes: false
715            });
716        };
717        const destroy = () => {
718            observers.forEach(observer => {
719                observer.disconnect();
720            });
721            observers.splice(0, observers.length);
722        };
723        extendParams({
724            observer: false,
725            observeParents: false,
726            observeSlideChildren: false
727        });
728        on('init', init);
729        on('destroy', destroy);
730    }
731
732    /* eslint-disable no-underscore-dangle */
733
734    var eventsEmitter = {
735        on(events, handler, priority) {
736            const self = this;
737            if (!self.eventsListeners || self.destroyed) return self;
738            if (typeof handler !== 'function') return self;
739            const method = priority ? 'unshift' : 'push';
740            events.split(' ').forEach(event => {
741                if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
742                self.eventsListeners[event][method](handler);
743            });
744            return self;
745        },
746        once(events, handler, priority) {
747            const self = this;
748            if (!self.eventsListeners || self.destroyed) return self;
749            if (typeof handler !== 'function') return self;
750            function onceHandler() {
751                self.off(events, onceHandler);
752                if (onceHandler.__emitterProxy) {
753                    delete onceHandler.__emitterProxy;
754                }
755                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
756                    args[_key] = arguments[_key];
757                }
758                handler.apply(self, args);
759            }
760            onceHandler.__emitterProxy = handler;
761            return self.on(events, onceHandler, priority);
762        },
763        onAny(handler, priority) {
764            const self = this;
765            if (!self.eventsListeners || self.destroyed) return self;
766            if (typeof handler !== 'function') return self;
767            const method = priority ? 'unshift' : 'push';
768            if (self.eventsAnyListeners.indexOf(handler) < 0) {
769                self.eventsAnyListeners[method](handler);
770            }
771            return self;
772        },
773        offAny(handler) {
774            const self = this;
775            if (!self.eventsListeners || self.destroyed) return self;
776            if (!self.eventsAnyListeners) return self;
777            const index = self.eventsAnyListeners.indexOf(handler);
778            if (index >= 0) {
779                self.eventsAnyListeners.splice(index, 1);
780            }
781            return self;
782        },
783        off(events, handler) {
784            const self = this;
785            if (!self.eventsListeners || self.destroyed) return self;
786            if (!self.eventsListeners) return self;
787            events.split(' ').forEach(event => {
788                if (typeof handler === 'undefined') {
789                    self.eventsListeners[event] = [];
790                } else if (self.eventsListeners[event]) {
791                    self.eventsListeners[event].forEach((eventHandler, index) => {
792                        if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
793                            self.eventsListeners[event].splice(index, 1);
794                        }
795                    });
796                }
797            });
798            return self;
799        },
800        emit() {
801            const self = this;
802            if (!self.eventsListeners || self.destroyed) return self;
803            if (!self.eventsListeners) return self;
804            let events;
805            let data;
806            let context;
807            for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
808                args[_key2] = arguments[_key2];
809            }
810            if (typeof args[0] === 'string' || Array.isArray(args[0])) {
811                events = args[0];
812                data = args.slice(1, args.length);
813                context = self;
814            } else {
815                events = args[0].events;
816                data = args[0].data;
817                context = args[0].context || self;
818            }
819            data.unshift(context);
820            const eventsArray = Array.isArray(events) ? events : events.split(' ');
821            eventsArray.forEach(event => {
822                if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
823                    self.eventsAnyListeners.forEach(eventHandler => {
824                        eventHandler.apply(context, [event, ...data]);
825                    });
826                }
827                if (self.eventsListeners && self.eventsListeners[event]) {
828                    self.eventsListeners[event].forEach(eventHandler => {
829                        eventHandler.apply(context, data);
830                    });
831                }
832            });
833            return self;
834        }
835    };
836
837    function updateSize() {
838        const swiper = this;
839        let width;
840        let height;
841        const el = swiper.el;
842        if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
843            width = swiper.params.width;
844        } else {
845            width = el.clientWidth;
846        }
847        if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
848            height = swiper.params.height;
849        } else {
850            height = el.clientHeight;
851        }
852        if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
853            return;
854        }
855
856        // Subtract paddings
857        width = width - parseInt(elementStyle(el, 'padding-left') || 0, 10) - parseInt(elementStyle(el, 'padding-right') || 0, 10);
858        height = height - parseInt(elementStyle(el, 'padding-top') || 0, 10) - parseInt(elementStyle(el, 'padding-bottom') || 0, 10);
859        if (Number.isNaN(width)) width = 0;
860        if (Number.isNaN(height)) height = 0;
861        Object.assign(swiper, {
862            width,
863            height,
864            size: swiper.isHorizontal() ? width : height
865        });
866    }
867
868    function updateSlides() {
869        const swiper = this;
870        function getDirectionPropertyValue(node, label) {
871            return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
872        }
873        const params = swiper.params;
874        const {
875            wrapperEl,
876            slidesEl,
877            size: swiperSize,
878            rtlTranslate: rtl,
879            wrongRTL
880        } = swiper;
881        const isVirtual = swiper.virtual && params.virtual.enabled;
882        const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
883        const slides = elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
884        const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
885        let snapGrid = [];
886        const slidesGrid = [];
887        const slidesSizesGrid = [];
888        let offsetBefore = params.slidesOffsetBefore;
889        if (typeof offsetBefore === 'function') {
890            offsetBefore = params.slidesOffsetBefore.call(swiper);
891        }
892        let offsetAfter = params.slidesOffsetAfter;
893        if (typeof offsetAfter === 'function') {
894            offsetAfter = params.slidesOffsetAfter.call(swiper);
895        }
896        const previousSnapGridLength = swiper.snapGrid.length;
897        const previousSlidesGridLength = swiper.slidesGrid.length;
898        let spaceBetween = params.spaceBetween;
899        let slidePosition = -offsetBefore;
900        let prevSlideSize = 0;
901        let index = 0;
902        if (typeof swiperSize === 'undefined') {
903            return;
904        }
905        if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
906            spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
907        } else if (typeof spaceBetween === 'string') {
908            spaceBetween = parseFloat(spaceBetween);
909        }
910        swiper.virtualSize = -spaceBetween;
911
912        // reset margins
913        slides.forEach(slideEl => {
914            if (rtl) {
915                slideEl.style.marginLeft = '';
916            } else {
917                slideEl.style.marginRight = '';
918            }
919            slideEl.style.marginBottom = '';
920            slideEl.style.marginTop = '';
921        });
922
923        // reset cssMode offsets
924        if (params.centeredSlides && params.cssMode) {
925            setCSSProperty(wrapperEl, '--swiper-centered-offset-before', '');
926            setCSSProperty(wrapperEl, '--swiper-centered-offset-after', '');
927        }
928        const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
929        if (gridEnabled) {
930            swiper.grid.initSlides(slides);
931        } else if (swiper.grid) {
932            swiper.grid.unsetSlides();
933        }
934
935        // Calc slides
936        let slideSize;
937        const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
938            return typeof params.breakpoints[key].slidesPerView !== 'undefined';
939        }).length > 0;
940        for (let i = 0; i < slidesLength; i += 1) {
941            slideSize = 0;
942            let slide;
943            if (slides[i]) slide = slides[i];
944            if (gridEnabled) {
945                swiper.grid.updateSlide(i, slide, slides);
946            }
947            if (slides[i] && elementStyle(slide, 'display') === 'none') continue; // eslint-disable-line
948
949            if (params.slidesPerView === 'auto') {
950                if (shouldResetSlideSize) {
951                    slides[i].style[swiper.getDirectionLabel('width')] = ``;
952                }
953                const slideStyles = getComputedStyle(slide);
954                const currentTransform = slide.style.transform;
955                const currentWebKitTransform = slide.style.webkitTransform;
956                if (currentTransform) {
957                    slide.style.transform = 'none';
958                }
959                if (currentWebKitTransform) {
960                    slide.style.webkitTransform = 'none';
961                }
962                if (params.roundLengths) {
963                    slideSize = swiper.isHorizontal() ? elementOuterSize(slide, 'width', true) : elementOuterSize(slide, 'height', true);
964                } else {
965                    // eslint-disable-next-line
966                    const width = getDirectionPropertyValue(slideStyles, 'width');
967                    const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
968                    const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
969                    const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
970                    const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
971                    const boxSizing = slideStyles.getPropertyValue('box-sizing');
972                    if (boxSizing && boxSizing === 'border-box') {
973                        slideSize = width + marginLeft + marginRight;
974                    } else {
975                        const {
976                            clientWidth,
977                            offsetWidth
978                        } = slide;
979                        slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
980                    }
981                }
982                if (currentTransform) {
983                    slide.style.transform = currentTransform;
984                }
985                if (currentWebKitTransform) {
986                    slide.style.webkitTransform = currentWebKitTransform;
987                }
988                if (params.roundLengths) slideSize = Math.floor(slideSize);
989            } else {
990                slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
991                if (params.roundLengths) slideSize = Math.floor(slideSize);
992                if (slides[i]) {
993                    slides[i].style[swiper.getDirectionLabel('width')] = `${slideSize}px`;
994                }
995            }
996            if (slides[i]) {
997                slides[i].swiperSlideSize = slideSize;
998            }
999            slidesSizesGrid.push(slideSize);
1000            if (params.centeredSlides) {
1001                slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1002                if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1003                if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1004                if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
1005                if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1006                if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1007                slidesGrid.push(slidePosition);
1008            } else {
1009                if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1010                if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1011                slidesGrid.push(slidePosition);
1012                slidePosition = slidePosition + slideSize + spaceBetween;
1013            }
1014            swiper.virtualSize += slideSize + spaceBetween;
1015            prevSlideSize = slideSize;
1016            index += 1;

vendor: 2,651 bytes, lines 1017-1070

1017        }
1018        swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1019        if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1020            wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
1021        }
1022        if (params.setWrapperSize) {
1023            wrapperEl.style[swiper.getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;
1024        }
1025        if (gridEnabled) {
1026            swiper.grid.updateWrapperSize(slideSize, snapGrid);
1027        }
1028
1029        // Remove last grid elements depending on width
1030        if (!params.centeredSlides) {
1031            const newSlidesGrid = [];
1032            for (let i = 0; i < snapGrid.length; i += 1) {
1033                let slidesGridItem = snapGrid[i];
1034                if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1035                if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1036                    newSlidesGrid.push(slidesGridItem);
1037                }
1038            }
1039            snapGrid = newSlidesGrid;
1040            if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1041                snapGrid.push(swiper.virtualSize - swiperSize);
1042            }
1043        }
1044        if (isVirtual && params.loop) {
1045            const size = slidesSizesGrid[0] + spaceBetween;
1046            if (params.slidesPerGroup > 1) {
1047                const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
1048                const groupSize = size * params.slidesPerGroup;
1049                for (let i = 0; i < groups; i += 1) {
1050                    snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1051                }
1052            }
1053            for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1054                if (params.slidesPerGroup === 1) {
1055                    snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1056                }
1057                slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1058                swiper.virtualSize += size;
1059            }
1060        }
1061        if (snapGrid.length === 0) snapGrid = [0];
1062        if (spaceBetween !== 0) {
1063            const key = swiper.isHorizontal() && rtl ? 'marginLeft' : swiper.getDirectionLabel('marginRight');
1064            slides.filter((_, slideIndex) => {
1065                if (!params.cssMode || params.loop) return true;
1066                if (slideIndex === slides.length - 1) {
1067                    return false;
1068                }
1069                return true;
1070            }

vendor: 8,362 bytes, lines 1070-1244

1070).forEach(slideEl => {
1071                slideEl.style[key] = `${spaceBetween}px`;
1072            });
1073        }
1074        if (params.centeredSlides && params.centeredSlidesBounds) {
1075            let allSlidesSize = 0;
1076            slidesSizesGrid.forEach(slideSizeValue => {
1077                allSlidesSize += slideSizeValue + (spaceBetween || 0);
1078            });
1079            allSlidesSize -= spaceBetween;
1080            const maxSnap = allSlidesSize > swiperSize ? allSlidesSize - swiperSize : 0;
1081            snapGrid = snapGrid.map(snap => {
1082                if (snap <= 0) return -offsetBefore;
1083                if (snap > maxSnap) return maxSnap + offsetAfter;
1084                return snap;
1085            });
1086        }
1087        if (params.centerInsufficientSlides) {
1088            let allSlidesSize = 0;
1089            slidesSizesGrid.forEach(slideSizeValue => {
1090                allSlidesSize += slideSizeValue + (spaceBetween || 0);
1091            });
1092            allSlidesSize -= spaceBetween;
1093            const offsetSize = (params.slidesOffsetBefore || 0) + (params.slidesOffsetAfter || 0);
1094            if (allSlidesSize + offsetSize < swiperSize) {
1095                const allSlidesOffset = (swiperSize - allSlidesSize - offsetSize) / 2;
1096                snapGrid.forEach((snap, snapIndex) => {
1097                    snapGrid[snapIndex] = snap - allSlidesOffset;
1098                });
1099                slidesGrid.forEach((snap, snapIndex) => {
1100                    slidesGrid[snapIndex] = snap + allSlidesOffset;
1101                });
1102            }
1103        }
1104        Object.assign(swiper, {
1105            slides,
1106            snapGrid,
1107            slidesGrid,
1108            slidesSizesGrid
1109        });
1110        if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1111            setCSSProperty(wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
1112            setCSSProperty(wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1113            const addToSnapGrid = -swiper.snapGrid[0];
1114            const addToSlidesGrid = -swiper.slidesGrid[0];
1115            swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1116            swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1117        }
1118        if (slidesLength !== previousSlidesLength) {
1119            swiper.emit('slidesLengthChange');
1120        }
1121        if (snapGrid.length !== previousSnapGridLength) {
1122            if (swiper.params.watchOverflow) swiper.checkOverflow();
1123            swiper.emit('snapGridLengthChange');
1124        }
1125        if (slidesGrid.length !== previousSlidesGridLength) {
1126            swiper.emit('slidesGridLengthChange');
1127        }
1128        if (params.watchSlidesProgress) {
1129            swiper.updateSlidesOffset();
1130        }
1131        swiper.emit('slidesUpdated');
1132        if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1133            const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1134            const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1135            if (slidesLength <= params.maxBackfaceHiddenSlides) {
1136                if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1137            } else if (hasClassBackfaceClassAdded) {
1138                swiper.el.classList.remove(backFaceHiddenClass);
1139            }
1140        }
1141    }
1142
1143    function updateAutoHeight(speed) {
1144        const swiper = this;
1145        const activeSlides = [];
1146        const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1147        let newHeight = 0;
1148        let i;
1149        if (typeof speed === 'number') {
1150            swiper.setTransition(speed);
1151        } else if (speed === true) {
1152            swiper.setTransition(swiper.params.speed);
1153        }
1154        const getSlideByIndex = index => {
1155            if (isVirtual) {
1156                return swiper.slides[swiper.getSlideIndexByData(index)];
1157            }
1158            return swiper.slides[index];
1159        };
1160        // Find slides currently in view
1161        if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1162            if (swiper.params.centeredSlides) {
1163                (swiper.visibleSlides || []).forEach(slide => {
1164                    activeSlides.push(slide);
1165                });
1166            } else {
1167                for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1168                    const index = swiper.activeIndex + i;
1169                    if (index > swiper.slides.length && !isVirtual) break;
1170                    activeSlides.push(getSlideByIndex(index));
1171                }
1172            }
1173        } else {
1174            activeSlides.push(getSlideByIndex(swiper.activeIndex));
1175        }
1176
1177        // Find new height from highest slide in view
1178        for (i = 0; i < activeSlides.length; i += 1) {
1179            if (typeof activeSlides[i] !== 'undefined') {
1180                const height = activeSlides[i].offsetHeight;
1181                newHeight = height > newHeight ? height : newHeight;
1182            }
1183        }
1184
1185        // Update Height
1186        if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;
1187    }
1188
1189    function updateSlidesOffset() {
1190        const swiper = this;
1191        const slides = swiper.slides;
1192        // eslint-disable-next-line
1193        const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;
1194        for (let i = 0; i < slides.length; i += 1) {
1195            slides[i].swiperSlideOffset = (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) - minusOffset - swiper.cssOverflowAdjustment();
1196        }
1197    }
1198
1199    const toggleSlideClasses$1 = (slideEl, condition, className) => {
1200        if (condition && !slideEl.classList.contains(className)) {
1201            slideEl.classList.add(className);
1202        } else if (!condition && slideEl.classList.contains(className)) {
1203            slideEl.classList.remove(className);
1204        }
1205    };
1206    function updateSlidesProgress(translate) {
1207        if (translate === void 0) {
1208            translate = this && this.translate || 0;
1209        }
1210        const swiper = this;
1211        const params = swiper.params;
1212        const {
1213            slides,
1214            rtlTranslate: rtl,
1215            snapGrid
1216        } = swiper;
1217        if (slides.length === 0) return;
1218        if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
1219        let offsetCenter = -translate;
1220        if (rtl) offsetCenter = translate;
1221        swiper.visibleSlidesIndexes = [];
1222        swiper.visibleSlides = [];
1223        let spaceBetween = params.spaceBetween;
1224        if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1225            spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;
1226        } else if (typeof spaceBetween === 'string') {
1227            spaceBetween = parseFloat(spaceBetween);
1228        }
1229        for (let i = 0; i < slides.length; i += 1) {
1230            const slide = slides[i];
1231            let slideOffset = slide.swiperSlideOffset;
1232            if (params.cssMode && params.centeredSlides) {
1233                slideOffset -= slides[0].swiperSlideOffset;
1234            }
1235            const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1236            const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1237            const slideBefore = -(offsetCenter - slideOffset);
1238            const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1239            const isFullyVisible = slideBefore >= 0 && slideBefore <= swiper.size - swiper.slidesSizesGrid[i];
1240            const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1241            if (isVisible) {
1242                swiper.visibleSlides.push(slide);
1243                swiper.visibleSlidesIndexes.push(i);
1244            }

vendor: 5,557 bytes, lines 1245-1370

1245            toggleSlideClasses$1(slide, isVisible, params.slideVisibleClass);
1246            toggleSlideClasses$1(slide, isFullyVisible, params.slideFullyVisibleClass);
1247            slide.progress = rtl ? -slideProgress : slideProgress;
1248            slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1249        }
1250    }
1251
1252    function updateProgress(translate) {
1253        const swiper = this;
1254        if (typeof translate === 'undefined') {
1255            const multiplier = swiper.rtlTranslate ? -1 : 1;
1256            // eslint-disable-next-line
1257            translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
1258        }
1259        const params = swiper.params;
1260        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1261        let {
1262            progress,
1263            isBeginning,
1264            isEnd,
1265            progressLoop
1266        } = swiper;
1267        const wasBeginning = isBeginning;
1268        const wasEnd = isEnd;
1269        if (translatesDiff === 0) {
1270            progress = 0;
1271            isBeginning = true;
1272            isEnd = true;
1273        } else {
1274            progress = (translate - swiper.minTranslate()) / translatesDiff;
1275            const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;
1276            const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;
1277            isBeginning = isBeginningRounded || progress <= 0;
1278            isEnd = isEndRounded || progress >= 1;
1279            if (isBeginningRounded) progress = 0;
1280            if (isEndRounded) progress = 1;
1281        }
1282        if (params.loop) {
1283            const firstSlideIndex = swiper.getSlideIndexByData(0);
1284            const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1285            const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1286            const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1287            const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1288            const translateAbs = Math.abs(translate);
1289            if (translateAbs >= firstSlideTranslate) {
1290                progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
1291            } else {
1292                progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1293            }
1294            if (progressLoop > 1) progressLoop -= 1;
1295        }
1296        Object.assign(swiper, {
1297            progress,
1298            progressLoop,
1299            isBeginning,
1300            isEnd
1301        });
1302        if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
1303        if (isBeginning && !wasBeginning) {
1304            swiper.emit('reachBeginning toEdge');
1305        }
1306        if (isEnd && !wasEnd) {
1307            swiper.emit('reachEnd toEdge');
1308        }
1309        if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
1310            swiper.emit('fromEdge');
1311        }
1312        swiper.emit('progress', progress);
1313    }
1314
1315    const toggleSlideClasses = (slideEl, condition, className) => {
1316        if (condition && !slideEl.classList.contains(className)) {
1317            slideEl.classList.add(className);
1318        } else if (!condition && slideEl.classList.contains(className)) {
1319            slideEl.classList.remove(className);
1320        }
1321    };
1322    function updateSlidesClasses() {
1323        const swiper = this;
1324        const {
1325            slides,
1326            params,
1327            slidesEl,
1328            activeIndex
1329        } = swiper;
1330        const isVirtual = swiper.virtual && params.virtual.enabled;
1331        const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1332        const getFilteredSlide = selector => {
1333            return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1334        };
1335        let activeSlide;
1336        let prevSlide;
1337        let nextSlide;
1338        if (isVirtual) {
1339            if (params.loop) {
1340                let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1341                if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1342                if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1343                activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1344            } else {
1345                activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1346            }
1347        } else {
1348            if (gridEnabled) {
1349                activeSlide = slides.find(slideEl => slideEl.column === activeIndex);
1350                nextSlide = slides.find(slideEl => slideEl.column === activeIndex + 1);
1351                prevSlide = slides.find(slideEl => slideEl.column === activeIndex - 1);
1352            } else {
1353                activeSlide = slides[activeIndex];
1354            }
1355        }
1356        if (activeSlide) {
1357            if (!gridEnabled) {
1358                // Next Slide
1359                nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1360                if (params.loop && !nextSlide) {
1361                    nextSlide = slides[0];
1362                }
1363
1364                // Prev Slide
1365                prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1366                if (params.loop && !prevSlide === 0) {
1367                    prevSlide = slides[slides.length - 1];
1368                }
1369            }
1370        }

vendor: 31,584 bytes, lines 1371-2156

1371        slides.forEach(slideEl => {
1372            toggleSlideClasses(slideEl, slideEl === activeSlide, params.slideActiveClass);
1373            toggleSlideClasses(slideEl, slideEl === nextSlide, params.slideNextClass);
1374            toggleSlideClasses(slideEl, slideEl === prevSlide, params.slidePrevClass);
1375        });
1376        swiper.emitSlidesClasses();
1377    }
1378
1379    const processLazyPreloader = (swiper, imageEl) => {
1380        if (!swiper || swiper.destroyed || !swiper.params) return;
1381        const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1382        const slideEl = imageEl.closest(slideSelector());
1383        if (slideEl) {
1384            let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1385            if (!lazyEl && swiper.isElement) {
1386                if (slideEl.shadowRoot) {
1387                    lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1388                } else {
1389                    // init later
1390                    requestAnimationFrame(() => {
1391                        if (slideEl.shadowRoot) {
1392                            lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1393                            if (lazyEl) lazyEl.remove();
1394                        }
1395                    });
1396                }
1397            }
1398            if (lazyEl) lazyEl.remove();
1399        }
1400    };
1401    const unlazy = (swiper, index) => {
1402        if (!swiper.slides[index]) return;
1403        const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1404        if (imageEl) imageEl.removeAttribute('loading');
1405    };
1406    const preload = swiper => {
1407        if (!swiper || swiper.destroyed || !swiper.params) return;
1408        let amount = swiper.params.lazyPreloadPrevNext;
1409        const len = swiper.slides.length;
1410        if (!len || !amount || amount < 0) return;
1411        amount = Math.min(amount, len);
1412        const slidesPerView = swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1413        const activeIndex = swiper.activeIndex;
1414        if (swiper.params.grid && swiper.params.grid.rows > 1) {
1415            const activeColumn = activeIndex;
1416            const preloadColumns = [activeColumn - amount];
1417            preloadColumns.push(...Array.from({
1418                length: amount
1419            }).map((_, i) => {
1420                return activeColumn + slidesPerView + i;
1421            }));
1422            swiper.slides.forEach((slideEl, i) => {
1423                if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1424            });
1425            return;
1426        }
1427        const slideIndexLastInView = activeIndex + slidesPerView - 1;
1428        if (swiper.params.rewind || swiper.params.loop) {
1429            for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1430                const realIndex = (i % len + len) % len;
1431                if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1432            }
1433        } else {
1434            for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1435                if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1436                    unlazy(swiper, i);
1437                }
1438            }
1439        }
1440    };
1441
1442    function getActiveIndexByTranslate(swiper) {
1443        const {
1444            slidesGrid,
1445            params
1446        } = swiper;
1447        const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1448        let activeIndex;
1449        for (let i = 0; i < slidesGrid.length; i += 1) {
1450            if (typeof slidesGrid[i + 1] !== 'undefined') {
1451                if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1452                    activeIndex = i;
1453                } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1454                    activeIndex = i + 1;
1455                }
1456            } else if (translate >= slidesGrid[i]) {
1457                activeIndex = i;
1458            }
1459        }
1460        // Normalize slideIndex
1461        if (params.normalizeSlideIndex) {
1462            if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1463        }
1464        return activeIndex;
1465    }
1466    function updateActiveIndex(newActiveIndex) {
1467        const swiper = this;
1468        const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1469        const {
1470            snapGrid,
1471            params,
1472            activeIndex: previousIndex,
1473            realIndex: previousRealIndex,
1474            snapIndex: previousSnapIndex
1475        } = swiper;
1476        let activeIndex = newActiveIndex;
1477        let snapIndex;
1478        const getVirtualRealIndex = aIndex => {
1479            let realIndex = aIndex - swiper.virtual.slidesBefore;
1480            if (realIndex < 0) {
1481                realIndex = swiper.virtual.slides.length + realIndex;
1482            }
1483            if (realIndex >= swiper.virtual.slides.length) {
1484                realIndex -= swiper.virtual.slides.length;
1485            }
1486            return realIndex;
1487        };
1488        if (typeof activeIndex === 'undefined') {
1489            activeIndex = getActiveIndexByTranslate(swiper);
1490        }
1491        if (snapGrid.indexOf(translate) >= 0) {
1492            snapIndex = snapGrid.indexOf(translate);
1493        } else {
1494            const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1495            snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1496        }
1497        if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1498        if (activeIndex === previousIndex && !swiper.params.loop) {
1499            if (snapIndex !== previousSnapIndex) {
1500                swiper.snapIndex = snapIndex;
1501                swiper.emit('snapIndexChange');
1502            }
1503            return;
1504        }
1505        if (activeIndex === previousIndex && swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1506            swiper.realIndex = getVirtualRealIndex(activeIndex);
1507            return;
1508        }
1509        const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1510
1511        // Get real index
1512        let realIndex;
1513        if (swiper.virtual && params.virtual.enabled && params.loop) {
1514            realIndex = getVirtualRealIndex(activeIndex);
1515        } else if (gridEnabled) {
1516            const firstSlideInColumn = swiper.slides.find(slideEl => slideEl.column === activeIndex);
1517            let activeSlideIndex = parseInt(firstSlideInColumn.getAttribute('data-swiper-slide-index'), 10);
1518            if (Number.isNaN(activeSlideIndex)) {
1519                activeSlideIndex = Math.max(swiper.slides.indexOf(firstSlideInColumn), 0);
1520            }
1521            realIndex = Math.floor(activeSlideIndex / params.grid.rows);
1522        } else if (swiper.slides[activeIndex]) {
1523            const slideIndex = swiper.slides[activeIndex].getAttribute('data-swiper-slide-index');
1524            if (slideIndex) {
1525                realIndex = parseInt(slideIndex, 10);
1526            } else {
1527                realIndex = activeIndex;
1528            }
1529        } else {
1530            realIndex = activeIndex;
1531        }
1532        Object.assign(swiper, {
1533            previousSnapIndex,
1534            snapIndex,
1535            previousRealIndex,
1536            realIndex,
1537            previousIndex,
1538            activeIndex
1539        });
1540        if (swiper.initialized) {
1541            preload(swiper);
1542        }
1543        swiper.emit('activeIndexChange');
1544        swiper.emit('snapIndexChange');
1545        if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1546            if (previousRealIndex !== realIndex) {
1547                swiper.emit('realIndexChange');
1548            }
1549            swiper.emit('slideChange');
1550        }
1551    }
1552
1553    function updateClickedSlide(el, path) {
1554        const swiper = this;
1555        const params = swiper.params;
1556        let slide = el.closest(`.${params.slideClass}, swiper-slide`);
1557        if (!slide && swiper.isElement && path && path.length > 1 && path.includes(el)) {
1558            [...path.slice(path.indexOf(el) + 1, path.length)].forEach(pathEl => {
1559                if (!slide && pathEl.matches && pathEl.matches(`.${params.slideClass}, swiper-slide`)) {
1560                    slide = pathEl;
1561                }
1562            });
1563        }
1564        let slideFound = false;
1565        let slideIndex;
1566        if (slide) {
1567            for (let i = 0; i < swiper.slides.length; i += 1) {
1568                if (swiper.slides[i] === slide) {
1569                    slideFound = true;
1570                    slideIndex = i;
1571                    break;
1572                }
1573            }
1574        }
1575        if (slide && slideFound) {
1576            swiper.clickedSlide = slide;
1577            if (swiper.virtual && swiper.params.virtual.enabled) {
1578                swiper.clickedIndex = parseInt(slide.getAttribute('data-swiper-slide-index'), 10);
1579            } else {
1580                swiper.clickedIndex = slideIndex;
1581            }
1582        } else {
1583            swiper.clickedSlide = undefined;
1584            swiper.clickedIndex = undefined;
1585            return;
1586        }
1587        if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1588            swiper.slideToClickedSlide();
1589        }
1590    }
1591
1592    var update = {
1593        updateSize,
1594        updateSlides,
1595        updateAutoHeight,
1596        updateSlidesOffset,
1597        updateSlidesProgress,
1598        updateProgress,
1599        updateSlidesClasses,
1600        updateActiveIndex,
1601        updateClickedSlide
1602    };
1603
1604    function getSwiperTranslate(axis) {
1605        if (axis === void 0) {
1606            axis = this.isHorizontal() ? 'x' : 'y';
1607        }
1608        const swiper = this;
1609        const {
1610            params,
1611            rtlTranslate: rtl,
1612            translate,
1613            wrapperEl
1614        } = swiper;
1615        if (params.virtualTranslate) {
1616            return rtl ? -translate : translate;
1617        }
1618        if (params.cssMode) {
1619            return translate;
1620        }
1621        let currentTranslate = getTranslate(wrapperEl, axis);
1622        currentTranslate += swiper.cssOverflowAdjustment();
1623        if (rtl) currentTranslate = -currentTranslate;
1624        return currentTranslate || 0;
1625    }
1626
1627    function setTranslate(translate, byController) {
1628        const swiper = this;
1629        const {
1630            rtlTranslate: rtl,
1631            params,
1632            wrapperEl,
1633            progress
1634        } = swiper;
1635        let x = 0;
1636        let y = 0;
1637        const z = 0;
1638        if (swiper.isHorizontal()) {
1639            x = rtl ? -translate : translate;
1640        } else {
1641            y = translate;
1642        }
1643        if (params.roundLengths) {
1644            x = Math.floor(x);
1645            y = Math.floor(y);
1646        }
1647        swiper.previousTranslate = swiper.translate;
1648        swiper.translate = swiper.isHorizontal() ? x : y;
1649        if (params.cssMode) {
1650            wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
1651        } else if (!params.virtualTranslate) {
1652            if (swiper.isHorizontal()) {
1653                x -= swiper.cssOverflowAdjustment();
1654            } else {
1655                y -= swiper.cssOverflowAdjustment();
1656            }
1657            wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1658        }
1659
1660        // Check if we need to update progress
1661        let newProgress;
1662        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1663        if (translatesDiff === 0) {
1664            newProgress = 0;
1665        } else {
1666            newProgress = (translate - swiper.minTranslate()) / translatesDiff;
1667        }
1668        if (newProgress !== progress) {
1669            swiper.updateProgress(translate);
1670        }
1671        swiper.emit('setTranslate', swiper.translate, byController);
1672    }
1673
1674    function minTranslate() {
1675        return -this.snapGrid[0];
1676    }
1677
1678    function maxTranslate() {
1679        return -this.snapGrid[this.snapGrid.length - 1];
1680    }
1681
1682    function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
1683        if (translate === void 0) {
1684            translate = 0;
1685        }
1686        if (speed === void 0) {
1687            speed = this.params.speed;
1688        }
1689        if (runCallbacks === void 0) {
1690            runCallbacks = true;
1691        }
1692        if (translateBounds === void 0) {
1693            translateBounds = true;
1694        }
1695        const swiper = this;
1696        const {
1697            params,
1698            wrapperEl
1699        } = swiper;
1700        if (swiper.animating && params.preventInteractionOnTransition) {
1701            return false;
1702        }
1703        const minTranslate = swiper.minTranslate();
1704        const maxTranslate = swiper.maxTranslate();
1705        let newTranslate;
1706        if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate;
1707
1708        // Update progress
1709        swiper.updateProgress(newTranslate);
1710        if (params.cssMode) {
1711            const isH = swiper.isHorizontal();
1712            if (speed === 0) {
1713                wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1714            } else {
1715                if (!swiper.support.smoothScroll) {
1716                    animateCSSModeScroll({
1717                        swiper,
1718                        targetPosition: -newTranslate,
1719                        side: isH ? 'left' : 'top'
1720                    });
1721                    return true;
1722                }
1723                wrapperEl.scrollTo({
1724                    [isH ? 'left' : 'top']: -newTranslate,
1725                    behavior: 'smooth'
1726                });
1727            }
1728            return true;
1729        }
1730        if (speed === 0) {
1731            swiper.setTransition(0);
1732            swiper.setTranslate(newTranslate);
1733            if (runCallbacks) {
1734                swiper.emit('beforeTransitionStart', speed, internal);
1735                swiper.emit('transitionEnd');
1736            }
1737        } else {
1738            swiper.setTransition(speed);
1739            swiper.setTranslate(newTranslate);
1740            if (runCallbacks) {
1741                swiper.emit('beforeTransitionStart', speed, internal);
1742                swiper.emit('transitionStart');
1743            }
1744            if (!swiper.animating) {
1745                swiper.animating = true;
1746                if (!swiper.onTranslateToWrapperTransitionEnd) {
1747                    swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1748                        if (!swiper || swiper.destroyed) return;
1749                        if (e.target !== this) return;
1750                        swiper.wrapperEl.removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1751                        swiper.onTranslateToWrapperTransitionEnd = null;
1752                        delete swiper.onTranslateToWrapperTransitionEnd;
1753                        swiper.animating = false;
1754                        if (runCallbacks) {
1755                            swiper.emit('transitionEnd');
1756                        }
1757                    };
1758                }
1759                swiper.wrapperEl.addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1760            }
1761        }
1762        return true;
1763    }
1764
1765    var translate = {
1766        getTranslate: getSwiperTranslate,
1767        setTranslate,
1768        minTranslate,
1769        maxTranslate,
1770        translateTo
1771    };
1772
1773    function setTransition(duration, byController) {
1774        const swiper = this;
1775        if (!swiper.params.cssMode) {
1776            swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
1777            swiper.wrapperEl.style.transitionDelay = duration === 0 ? `0ms` : '';
1778        }
1779        swiper.emit('setTransition', duration, byController);
1780    }
1781
1782    function transitionEmit(_ref) {
1783        let {
1784            swiper,
1785            runCallbacks,
1786            direction,
1787            step
1788        } = _ref;
1789        const {
1790            activeIndex,
1791            previousIndex
1792        } = swiper;
1793        let dir = direction;
1794        if (!dir) {
1795            if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
1796        }
1797        swiper.emit(`transition${step}`);
1798        if (runCallbacks && activeIndex !== previousIndex) {
1799            if (dir === 'reset') {
1800                swiper.emit(`slideResetTransition${step}`);
1801                return;
1802            }
1803            swiper.emit(`slideChangeTransition${step}`);
1804            if (dir === 'next') {
1805                swiper.emit(`slideNextTransition${step}`);
1806            } else {
1807                swiper.emit(`slidePrevTransition${step}`);
1808            }
1809        }
1810    }
1811
1812    function transitionStart(runCallbacks, direction) {
1813        if (runCallbacks === void 0) {
1814            runCallbacks = true;
1815        }
1816        const swiper = this;
1817        const {
1818            params
1819        } = swiper;
1820        if (params.cssMode) return;
1821        if (params.autoHeight) {
1822            swiper.updateAutoHeight();
1823        }
1824        transitionEmit({
1825            swiper,
1826            runCallbacks,
1827            direction,
1828            step: 'Start'
1829        });
1830    }
1831
1832    function transitionEnd(runCallbacks, direction) {
1833        if (runCallbacks === void 0) {
1834            runCallbacks = true;
1835        }
1836        const swiper = this;
1837        const {
1838            params
1839        } = swiper;
1840        swiper.animating = false;
1841        if (params.cssMode) return;
1842        swiper.setTransition(0);
1843        transitionEmit({
1844            swiper,
1845            runCallbacks,
1846            direction,
1847            step: 'End'
1848        });
1849    }
1850
1851    var transition = {
1852        setTransition,
1853        transitionStart,
1854        transitionEnd
1855    };
1856
1857    function slideTo(index, speed, runCallbacks, internal, initial) {
1858        if (index === void 0) {
1859            index = 0;
1860        }
1861        if (runCallbacks === void 0) {
1862            runCallbacks = true;
1863        }
1864        if (typeof index === 'string') {
1865            index = parseInt(index, 10);
1866        }
1867        const swiper = this;
1868        let slideIndex = index;
1869        if (slideIndex < 0) slideIndex = 0;
1870        const {
1871            params,
1872            snapGrid,
1873            slidesGrid,
1874            previousIndex,
1875            activeIndex,
1876            rtlTranslate: rtl,
1877            wrapperEl,
1878            enabled
1879        } = swiper;
1880        if (!enabled && !internal && !initial || swiper.destroyed || swiper.animating && params.preventInteractionOnTransition) {
1881            return false;
1882        }
1883        if (typeof speed === 'undefined') {
1884            speed = swiper.params.speed;
1885        }
1886        const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
1887        let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
1888        if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1889        const translate = -snapGrid[snapIndex];
1890        // Normalize slideIndex
1891        if (params.normalizeSlideIndex) {
1892            for (let i = 0; i < slidesGrid.length; i += 1) {
1893                const normalizedTranslate = -Math.floor(translate * 100);
1894                const normalizedGrid = Math.floor(slidesGrid[i] * 100);
1895                const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
1896                if (typeof slidesGrid[i + 1] !== 'undefined') {
1897                    if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
1898                        slideIndex = i;
1899                    } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
1900                        slideIndex = i + 1;
1901                    }
1902                } else if (normalizedTranslate >= normalizedGrid) {
1903                    slideIndex = i;
1904                }
1905            }
1906        }
1907        // Directions locks
1908        if (swiper.initialized && slideIndex !== activeIndex) {
1909            if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) {
1910                return false;
1911            }
1912            if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
1913                if ((activeIndex || 0) !== slideIndex) {
1914                    return false;
1915                }
1916            }
1917        }
1918        if (slideIndex !== (previousIndex || 0) && runCallbacks) {
1919            swiper.emit('beforeSlideChangeStart');
1920        }
1921
1922        // Update progress
1923        swiper.updateProgress(translate);
1924        let direction;
1925        if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset';
1926
1927        // initial virtual
1928        const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1929        const isInitialVirtual = isVirtual && initial;
1930        // Update Index
1931        if (!isInitialVirtual && (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate)) {
1932            swiper.updateActiveIndex(slideIndex);
1933            // Update Height
1934            if (params.autoHeight) {
1935                swiper.updateAutoHeight();
1936            }
1937            swiper.updateSlidesClasses();
1938            if (params.effect !== 'slide') {
1939                swiper.setTranslate(translate);
1940            }
1941            if (direction !== 'reset') {
1942                swiper.transitionStart(runCallbacks, direction);
1943                swiper.transitionEnd(runCallbacks, direction);
1944            }
1945            return false;
1946        }
1947        if (params.cssMode) {
1948            const isH = swiper.isHorizontal();
1949            const t = rtl ? translate : -translate;
1950            if (speed === 0) {
1951                if (isVirtual) {
1952                    swiper.wrapperEl.style.scrollSnapType = 'none';
1953                    swiper._immediateVirtual = true;
1954                }
1955                if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
1956                    swiper._cssModeVirtualInitialSet = true;
1957                    requestAnimationFrame(() => {
1958                        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1959                    });
1960                } else {
1961                    wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1962                }
1963                if (isVirtual) {
1964                    requestAnimationFrame(() => {
1965                        swiper.wrapperEl.style.scrollSnapType = '';
1966                        swiper._immediateVirtual = false;
1967                    });
1968                }
1969            } else {
1970                if (!swiper.support.smoothScroll) {
1971                    animateCSSModeScroll({
1972                        swiper,
1973                        targetPosition: t,
1974                        side: isH ? 'left' : 'top'
1975                    });
1976                    return true;
1977                }
1978                wrapperEl.scrollTo({
1979                    [isH ? 'left' : 'top']: t,
1980                    behavior: 'smooth'
1981                });
1982            }
1983            return true;
1984        }
1985        const browser = getBrowser();
1986        const isSafari = browser.isSafari;
1987        if (isVirtual && !initial && isSafari && swiper.isElement) {
1988            swiper.virtual.update(false, false, slideIndex);
1989        }
1990        swiper.setTransition(speed);
1991        swiper.setTranslate(translate);
1992        swiper.updateActiveIndex(slideIndex);
1993        swiper.updateSlidesClasses();
1994        swiper.emit('beforeTransitionStart', speed, internal);
1995        swiper.transitionStart(runCallbacks, direction);
1996        if (speed === 0) {
1997            swiper.transitionEnd(runCallbacks, direction);
1998        } else if (!swiper.animating) {
1999            swiper.animating = true;
2000            if (!swiper.onSlideToWrapperTransitionEnd) {
2001                swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2002                    if (!swiper || swiper.destroyed) return;
2003                    if (e.target !== this) return;
2004                    swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2005                    swiper.onSlideToWrapperTransitionEnd = null;
2006                    delete swiper.onSlideToWrapperTransitionEnd;
2007                    swiper.transitionEnd(runCallbacks, direction);
2008                };
2009            }
2010            swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2011        }
2012        return true;
2013    }
2014
2015    function slideToLoop(index, speed, runCallbacks, internal) {
2016        if (index === void 0) {
2017            index = 0;
2018        }
2019        if (runCallbacks === void 0) {
2020            runCallbacks = true;
2021        }
2022        if (typeof index === 'string') {
2023            const indexAsNumber = parseInt(index, 10);
2024            index = indexAsNumber;
2025        }
2026        const swiper = this;
2027        if (swiper.destroyed) return;
2028        if (typeof speed === 'undefined') {
2029            speed = swiper.params.speed;
2030        }
2031        const gridEnabled = swiper.grid && swiper.params.grid && swiper.params.grid.rows > 1;
2032        let newIndex = index;
2033        if (swiper.params.loop) {
2034            if (swiper.virtual && swiper.params.virtual.enabled) {
2035                // eslint-disable-next-line
2036                newIndex = newIndex + swiper.virtual.slidesBefore;
2037            } else {
2038                let targetSlideIndex;
2039                if (gridEnabled) {
2040                    const slideIndex = newIndex * swiper.params.grid.rows;
2041                    targetSlideIndex = swiper.slides.find(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex).column;
2042                } else {
2043                    targetSlideIndex = swiper.getSlideIndexByData(newIndex);
2044                }
2045                const cols = gridEnabled ? Math.ceil(swiper.slides.length / swiper.params.grid.rows) : swiper.slides.length;
2046                const {
2047                    centeredSlides
2048                } = swiper.params;
2049                let slidesPerView = swiper.params.slidesPerView;
2050                if (slidesPerView === 'auto') {
2051                    slidesPerView = swiper.slidesPerViewDynamic();
2052                } else {
2053                    slidesPerView = Math.ceil(parseFloat(swiper.params.slidesPerView, 10));
2054                    if (centeredSlides && slidesPerView % 2 === 0) {
2055                        slidesPerView = slidesPerView + 1;
2056                    }
2057                }
2058                let needLoopFix = cols - targetSlideIndex < slidesPerView;
2059                if (centeredSlides) {
2060                    needLoopFix = needLoopFix || targetSlideIndex < Math.ceil(slidesPerView / 2);
2061                }
2062                if (internal && centeredSlides && swiper.params.slidesPerView !== 'auto' && !gridEnabled) {
2063                    needLoopFix = false;
2064                }
2065                if (needLoopFix) {
2066                    const direction = centeredSlides ? targetSlideIndex < swiper.activeIndex ? 'prev' : 'next' : targetSlideIndex - swiper.activeIndex - 1 < swiper.params.slidesPerView ? 'next' : 'prev';
2067                    swiper.loopFix({
2068                        direction,
2069                        slideTo: true,
2070                        activeSlideIndex: direction === 'next' ? targetSlideIndex + 1 : targetSlideIndex - cols + 1,
2071                        slideRealIndex: direction === 'next' ? swiper.realIndex : undefined
2072                    });
2073                }
2074                if (gridEnabled) {
2075                    const slideIndex = newIndex * swiper.params.grid.rows;
2076                    newIndex = swiper.slides.find(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex).column;
2077                } else {
2078                    newIndex = swiper.getSlideIndexByData(newIndex);
2079                }
2080            }
2081        }
2082        requestAnimationFrame(() => {
2083            swiper.slideTo(newIndex, speed, runCallbacks, internal);
2084        });
2085        return swiper;
2086    }
2087
2088    /* eslint no-unused-vars: "off" */
2089    function slideNext(speed, runCallbacks, internal) {
2090        if (runCallbacks === void 0) {
2091            runCallbacks = true;
2092        }
2093        const swiper = this;
2094        const {
2095            enabled,
2096            params,
2097            animating
2098        } = swiper;
2099        if (!enabled || swiper.destroyed) return swiper;
2100        if (typeof speed === 'undefined') {
2101            speed = swiper.params.speed;
2102        }
2103        let perGroup = params.slidesPerGroup;
2104        if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2105            perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
2106        }
2107        const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2108        const isVirtual = swiper.virtual && params.virtual.enabled;
2109        if (params.loop) {
2110            if (animating && !isVirtual && params.loopPreventsSliding) return false;
2111            swiper.loopFix({
2112                direction: 'next'
2113            });
2114            // eslint-disable-next-line
2115            swiper._clientLeft = swiper.wrapperEl.clientLeft;
2116            if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
2117                requestAnimationFrame(() => {
2118                    swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2119                });
2120                return true;
2121            }
2122        }
2123        if (params.rewind && swiper.isEnd) {
2124            return swiper.slideTo(0, speed, runCallbacks, internal);
2125        }
2126        return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2127    }
2128
2129    /* eslint no-unused-vars: "off" */
2130    function slidePrev(speed, runCallbacks, internal) {
2131        if (runCallbacks === void 0) {
2132            runCallbacks = true;
2133        }
2134        const swiper = this;
2135        const {
2136            params,
2137            snapGrid,
2138            slidesGrid,
2139            rtlTranslate,
2140            enabled,
2141            animating
2142        } = swiper;
2143        if (!enabled || swiper.destroyed) return swiper;
2144        if (typeof speed === 'undefined') {
2145            speed = swiper.params.speed;
2146        }
2147        const isVirtual = swiper.virtual && params.virtual.enabled;
2148        if (params.loop) {
2149            if (animating && !isVirtual && params.loopPreventsSliding) return false;
2150            swiper.loopFix({
2151                direction: 'prev'
2152            });
2153            // eslint-disable-next-line
2154            swiper._clientLeft = swiper.wrapperEl.clientLeft;
2155        }
2156        const translate = rtlTranslate ? swiper.translate : -swi

vendor: 13,313 bytes, lines 2156-2434

2156per.translate;
2157        function normalize(val) {
2158            if (val < 0) return -Math.floor(Math.abs(val));
2159            return Math.floor(val);
2160        }
2161        const normalizedTranslate = normalize(translate);
2162        const normalizedSnapGrid = snapGrid.map(val => normalize(val));
2163        const isFreeMode = params.freeMode && params.freeMode.enabled;
2164        let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2165        if (typeof prevSnap === 'undefined' && (params.cssMode || isFreeMode)) {
2166            let prevSnapIndex;
2167            snapGrid.forEach((snap, snapIndex) => {
2168                if (normalizedTranslate >= snap) {
2169                    // prevSnap = snap;
2170                    prevSnapIndex = snapIndex;
2171                }
2172            });
2173            if (typeof prevSnapIndex !== 'undefined') {
2174                prevSnap = isFreeMode ? snapGrid[prevSnapIndex] : snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2175            }
2176        }
2177        let prevIndex = 0;
2178        if (typeof prevSnap !== 'undefined') {
2179            prevIndex = slidesGrid.indexOf(prevSnap);
2180            if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2181            if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2182                prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2183                prevIndex = Math.max(prevIndex, 0);
2184            }
2185        }
2186        if (params.rewind && swiper.isBeginning) {
2187            const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2188            return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2189        } else if (params.loop && swiper.activeIndex === 0 && params.cssMode) {
2190            requestAnimationFrame(() => {
2191                swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2192            });
2193            return true;
2194        }
2195        return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2196    }
2197
2198    /* eslint no-unused-vars: "off" */
2199    function slideReset(speed, runCallbacks, internal) {
2200        if (runCallbacks === void 0) {
2201            runCallbacks = true;
2202        }
2203        const swiper = this;
2204        if (swiper.destroyed) return;
2205        if (typeof speed === 'undefined') {
2206            speed = swiper.params.speed;
2207        }
2208        return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2209    }
2210
2211    /* eslint no-unused-vars: "off" */
2212    function slideToClosest(speed, runCallbacks, internal, threshold) {
2213        if (runCallbacks === void 0) {
2214            runCallbacks = true;
2215        }
2216        if (threshold === void 0) {
2217            threshold = 0.5;
2218        }
2219        const swiper = this;
2220        if (swiper.destroyed) return;
2221        if (typeof speed === 'undefined') {
2222            speed = swiper.params.speed;
2223        }
2224        let index = swiper.activeIndex;
2225        const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2226        const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2227        const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2228        if (translate >= swiper.snapGrid[snapIndex]) {
2229            // The current translate is on or after the current snap index, so the choice
2230            // is between the current index and the one after it.
2231            const currentSnap = swiper.snapGrid[snapIndex];
2232            const nextSnap = swiper.snapGrid[snapIndex + 1];
2233            if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
2234                index += swiper.params.slidesPerGroup;
2235            }
2236        } else {
2237            // The current translate is before the current snap index, so the choice
2238            // is between the current index and the one before it.
2239            const prevSnap = swiper.snapGrid[snapIndex - 1];
2240            const currentSnap = swiper.snapGrid[snapIndex];
2241            if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
2242                index -= swiper.params.slidesPerGroup;
2243            }
2244        }
2245        index = Math.max(index, 0);
2246        index = Math.min(index, swiper.slidesGrid.length - 1);
2247        return swiper.slideTo(index, speed, runCallbacks, internal);
2248    }
2249
2250    function slideToClickedSlide() {
2251        const swiper = this;
2252        if (swiper.destroyed) return;
2253        const {
2254            params,
2255            slidesEl
2256        } = swiper;
2257        const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2258        let slideToIndex = swiper.clickedIndex;
2259        let realIndex;
2260        const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2261        if (params.loop) {
2262            if (swiper.animating) return;
2263            realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
2264            if (params.centeredSlides) {
2265                if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2266                    swiper.loopFix();
2267                    slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2268                    nextTick(() => {
2269                        swiper.slideTo(slideToIndex);
2270                    });
2271                } else {
2272                    swiper.slideTo(slideToIndex);
2273                }
2274            } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2275                swiper.loopFix();
2276                slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2277                nextTick(() => {
2278                    swiper.slideTo(slideToIndex);
2279                });
2280            } else {
2281                swiper.slideTo(slideToIndex);
2282            }
2283        } else {
2284            swiper.slideTo(slideToIndex);
2285        }
2286    }
2287
2288    var slide = {
2289        slideTo,
2290        slideToLoop,
2291        slideNext,
2292        slidePrev,
2293        slideReset,
2294        slideToClosest,
2295        slideToClickedSlide
2296    };
2297
2298    function loopCreate(slideRealIndex, initial) {
2299        const swiper = this;
2300        const {
2301            params,
2302            slidesEl
2303        } = swiper;
2304        if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2305        const initSlides = () => {
2306            const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
2307            slides.forEach((el, index) => {
2308                el.setAttribute('data-swiper-slide-index', index);
2309            });
2310        };
2311        const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2312        const slidesPerGroup = params.slidesPerGroup * (gridEnabled ? params.grid.rows : 1);
2313        const shouldFillGroup = swiper.slides.length % slidesPerGroup !== 0;
2314        const shouldFillGrid = gridEnabled && swiper.slides.length % params.grid.rows !== 0;
2315        const addBlankSlides = amountOfSlides => {
2316            for (let i = 0; i < amountOfSlides; i += 1) {
2317                const slideEl = swiper.isElement ? createElement('swiper-slide', [params.slideBlankClass]) : createElement('div', [params.slideClass, params.slideBlankClass]);
2318                swiper.slidesEl.append(slideEl);
2319            }
2320        };
2321        if (shouldFillGroup) {
2322            if (params.loopAddBlankSlides) {
2323                const slidesToAdd = slidesPerGroup - swiper.slides.length % slidesPerGroup;
2324                addBlankSlides(slidesToAdd);
2325                swiper.recalcSlides();
2326                swiper.updateSlides();
2327            } else {
2328                showWarning('Swiper Loop Warning: The number of slides is not even to slidesPerGroup, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)');
2329            }
2330            initSlides();
2331        } else if (shouldFillGrid) {
2332            if (params.loopAddBlankSlides) {
2333                const slidesToAdd = params.grid.rows - swiper.slides.length % params.grid.rows;
2334                addBlankSlides(slidesToAdd);
2335                swiper.recalcSlides();
2336                swiper.updateSlides();
2337            } else {
2338                showWarning('Swiper Loop Warning: The number of slides is not even to grid.rows, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)');
2339            }
2340            initSlides();
2341        } else {
2342            initSlides();
2343        }
2344        swiper.loopFix({
2345            slideRealIndex,
2346            direction: params.centeredSlides ? undefined : 'next',
2347            initial
2348        });
2349    }
2350
2351    function loopFix(_temp) {
2352        let {
2353            slideRealIndex,
2354            slideTo = true,
2355            direction,
2356            setTranslate,
2357            activeSlideIndex,
2358            initial,
2359            byController,
2360            byMousewheel
2361        } = _temp === void 0 ? {} : _temp;
2362        const swiper = this;
2363        if (!swiper.params.loop) return;
2364        swiper.emit('beforeLoopFix');
2365        const {
2366            slides,
2367            allowSlidePrev,
2368            allowSlideNext,
2369            slidesEl,
2370            params
2371        } = swiper;
2372        const {
2373            centeredSlides,
2374            initialSlide
2375        } = params;
2376        swiper.allowSlidePrev = true;
2377        swiper.allowSlideNext = true;
2378        if (swiper.virtual && params.virtual.enabled) {
2379            if (slideTo) {
2380                if (!params.centeredSlides && swiper.snapIndex === 0) {
2381                    swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
2382                } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
2383                    swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
2384                } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
2385                    swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2386                }
2387            }
2388            swiper.allowSlidePrev = allowSlidePrev;
2389            swiper.allowSlideNext = allowSlideNext;
2390            swiper.emit('loopFix');
2391            return;
2392        }
2393        let slidesPerView = params.slidesPerView;
2394        if (slidesPerView === 'auto') {
2395            slidesPerView = swiper.slidesPerViewDynamic();
2396        } else {
2397            slidesPerView = Math.ceil(parseFloat(params.slidesPerView, 10));
2398            if (centeredSlides && slidesPerView % 2 === 0) {
2399                slidesPerView = slidesPerView + 1;
2400            }
2401        }
2402        const slidesPerGroup = params.slidesPerGroupAuto ? slidesPerView : params.slidesPerGroup;
2403        let loopedSlides = slidesPerGroup;
2404        if (loopedSlides % slidesPerGroup !== 0) {
2405            loopedSlides += slidesPerGroup - loopedSlides % slidesPerGroup;
2406        }
2407        loopedSlides += params.loopAdditionalSlides;
2408        swiper.loopedSlides = loopedSlides;
2409        const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2410        if (slides.length < slidesPerView + loopedSlides || swiper.params.effect === 'cards' && slides.length < slidesPerView + loopedSlides * 2) {
2411            showWarning('Swiper Loop Warning: The number of slides is not enough for loop mode, it will be disabled or not function properly. You need to add more slides (or make duplicates) or lower the values of slidesPerView and slidesPerGroup parameters');
2412        } else if (gridEnabled && params.grid.fill === 'row') {
2413            showWarning('Swiper Loop Warning: Loop mode is not compatible with grid.fill = `row`');
2414        }
2415        const prependSlidesIndexes = [];
2416        const appendSlidesIndexes = [];
2417        const cols = gridEnabled ? Math.ceil(slides.length / params.grid.rows) : slides.length;
2418        const isInitialOverflow = initial && cols - initialSlide < slidesPerView && !centeredSlides;
2419        let activeIndex = isInitialOverflow ? initialSlide : swiper.activeIndex;
2420        if (typeof activeSlideIndex === 'undefined') {
2421            activeSlideIndex = swiper.getSlideIndex(slides.find(el => el.classList.contains(params.slideActiveClass)));
2422        } else {
2423            activeIndex = activeSlideIndex;
2424        }
2425        const isNext = direction === 'next' || !direction;
2426        const isPrev = direction === 'prev' || !direction;
2427        let slidesPrepended = 0;
2428        let slidesAppended = 0;
2429        const activeColIndex = gridEnabled ? slides[activeSlideIndex].column : activeSlideIndex;
2430        const activeColIndexWithShift = activeColIndex + (centeredSlides && typeof setTranslate === 'undefined' ? -slidesPerView / 2 + 0.5 : 0);
2431        // prepend last slides before start
2432        if (activeColIndexWithShift < loopedSlides) {
2433            slidesPrepended = Math.max(loopedSlides - activeColIndexWithShift, slidesPerGroup);
2434            for (let i = 0; i < loopedSlides - activeColIndexWithShift; i += 1) {

vendor: 7,242 bytes, lines 2435-2578

2435                const index = i - Math.floor(i / cols) * cols;
2436                if (gridEnabled) {
2437                    const colIndexToPrepend = cols - index - 1;
2438                    for (let i = slides.length - 1; i >= 0; i -= 1) {
2439                        if (slides[i].column === colIndexToPrepend) prependSlidesIndexes.push(i);
2440                    }
2441                    // slides.forEach((slide, slideIndex) => {
2442                    //   if (slide.column === colIndexToPrepend) prependSlidesIndexes.push(slideIndex);
2443                    // });
2444                } else {
2445                    prependSlidesIndexes.push(cols - index - 1);
2446                }
2447            }
2448        } else if (activeColIndexWithShift + slidesPerView > cols - loopedSlides) {
2449            slidesAppended = Math.max(activeColIndexWithShift - (cols - loopedSlides * 2), slidesPerGroup);
2450            if (isInitialOverflow) {
2451                slidesAppended = Math.max(slidesAppended, slidesPerView - cols + initialSlide + 1);
2452            }
2453            for (let i = 0; i < slidesAppended; i += 1) {
2454                const index = i - Math.floor(i / cols) * cols;
2455                if (gridEnabled) {
2456                    slides.forEach((slide, slideIndex) => {
2457                        if (slide.column === index) appendSlidesIndexes.push(slideIndex);
2458                    });
2459                } else {
2460                    appendSlidesIndexes.push(index);
2461                }
2462            }
2463        }
2464        swiper.__preventObserver__ = true;
2465        requestAnimationFrame(() => {
2466            swiper.__preventObserver__ = false;
2467        });
2468        if (swiper.params.effect === 'cards' && slides.length < slidesPerView + loopedSlides * 2) {
2469            if (appendSlidesIndexes.includes(activeSlideIndex)) {
2470                appendSlidesIndexes.splice(appendSlidesIndexes.indexOf(activeSlideIndex), 1);
2471            }
2472            if (prependSlidesIndexes.includes(activeSlideIndex)) {
2473                prependSlidesIndexes.splice(prependSlidesIndexes.indexOf(activeSlideIndex), 1);
2474            }
2475        }
2476        if (isPrev) {
2477            prependSlidesIndexes.forEach(index => {
2478                slides[index].swiperLoopMoveDOM = true;
2479                slidesEl.prepend(slides[index]);
2480                slides[index].swiperLoopMoveDOM = false;
2481            });
2482        }
2483        if (isNext) {
2484            appendSlidesIndexes.forEach(index => {
2485                slides[index].swiperLoopMoveDOM = true;
2486                slidesEl.append(slides[index]);
2487                slides[index].swiperLoopMoveDOM = false;
2488            });
2489        }
2490        swiper.recalcSlides();
2491        if (params.slidesPerView === 'auto') {
2492            swiper.updateSlides();
2493        } else if (gridEnabled && (prependSlidesIndexes.length > 0 && isPrev || appendSlidesIndexes.length > 0 && isNext)) {
2494            swiper.slides.forEach((slide, slideIndex) => {
2495                swiper.grid.updateSlide(slideIndex, slide, swiper.slides);
2496            });
2497        }
2498        if (params.watchSlidesProgress) {
2499            swiper.updateSlidesOffset();
2500        }
2501        if (slideTo) {
2502            if (prependSlidesIndexes.length > 0 && isPrev) {
2503                if (typeof slideRealIndex === 'undefined') {
2504                    const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2505                    const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2506                    const diff = newSlideTranslate - currentSlideTranslate;
2507                    if (byMousewheel) {
2508                        swiper.setTranslate(swiper.translate - diff);
2509                    } else {
2510                        swiper.slideTo(activeIndex + Math.ceil(slidesPrepended), 0, false, true);
2511                        if (setTranslate) {
2512                            swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2513                            swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2514                        }
2515                    }
2516                } else {
2517                    if (setTranslate) {
2518                        const shift = gridEnabled ? prependSlidesIndexes.length / params.grid.rows : prependSlidesIndexes.length;
2519                        swiper.slideTo(swiper.activeIndex + shift, 0, false, true);
2520                        swiper.touchEventsData.currentTranslate = swiper.translate;
2521                    }
2522                }
2523            } else if (appendSlidesIndexes.length > 0 && isNext) {
2524                if (typeof slideRealIndex === 'undefined') {
2525                    const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2526                    const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2527                    const diff = newSlideTranslate - currentSlideTranslate;
2528                    if (byMousewheel) {
2529                        swiper.setTranslate(swiper.translate - diff);
2530                    } else {
2531                        swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2532                        if (setTranslate) {
2533                            swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2534                            swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2535                        }
2536                    }
2537                } else {
2538                    const shift = gridEnabled ? appendSlidesIndexes.length / params.grid.rows : appendSlidesIndexes.length;
2539                    swiper.slideTo(swiper.activeIndex - shift, 0, false, true);
2540                }
2541            }
2542        }
2543        swiper.allowSlidePrev = allowSlidePrev;
2544        swiper.allowSlideNext = allowSlideNext;
2545        if (swiper.controller && swiper.controller.control && !byController) {
2546            const loopParams = {
2547                slideRealIndex,
2548                direction,
2549                setTranslate,
2550                activeSlideIndex,
2551                byController: true
2552            };
2553            if (Array.isArray(swiper.controller.control)) {
2554                swiper.controller.control.forEach(c => {
2555                    if (!c.destroyed && c.params.loop) c.loopFix({
2556                        ...loopParams,
2557                        slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo : false
2558                    });
2559                });
2560            } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
2561                swiper.controller.control.loopFix({
2562                    ...loopParams,
2563                    slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo : false
2564                });
2565            }
2566        }
2567        swiper.emit('loopFix');
2568    }
2569
2570    function loopDestroy() {
2571        const swiper = this;
2572        const {
2573            params,
2574            slidesEl
2575        } = swiper;
2576        if (!params.loop || !slidesEl || swiper.virtual && swiper.params.virtual.enabled) return;
2577        swiper.recalcSlides();
2578        const newSlidesOrder = [];

vendor: 6,392 bytes, lines 2579-2744

2579        swiper.slides.forEach(slideEl => {
2580            const index = typeof slideEl.swiperSlideIndex === 'undefined' ? slideEl.getAttribute('data-swiper-slide-index') * 1 : slideEl.swiperSlideIndex;
2581            newSlidesOrder[index] = slideEl;
2582        });
2583        swiper.slides.forEach(slideEl => {
2584            slideEl.removeAttribute('data-swiper-slide-index');
2585        });
2586        newSlidesOrder.forEach(slideEl => {
2587            slidesEl.append(slideEl);
2588        });
2589        swiper.recalcSlides();
2590        swiper.slideTo(swiper.realIndex, 0);
2591    }
2592
2593    var loop = {
2594        loopCreate,
2595        loopFix,
2596        loopDestroy
2597    };
2598
2599    function setGrabCursor(moving) {
2600        const swiper = this;
2601        if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
2602        const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
2603        if (swiper.isElement) {
2604            swiper.__preventObserver__ = true;
2605        }
2606        el.style.cursor = 'move';
2607        el.style.cursor = moving ? 'grabbing' : 'grab';
2608        if (swiper.isElement) {
2609            requestAnimationFrame(() => {
2610                swiper.__preventObserver__ = false;
2611            });
2612        }
2613    }
2614
2615    function unsetGrabCursor() {
2616        const swiper = this;
2617        if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
2618            return;
2619        }
2620        if (swiper.isElement) {
2621            swiper.__preventObserver__ = true;
2622        }
2623        swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
2624        if (swiper.isElement) {
2625            requestAnimationFrame(() => {
2626                swiper.__preventObserver__ = false;
2627            });
2628        }
2629    }
2630
2631    var grabCursor = {
2632        setGrabCursor,
2633        unsetGrabCursor
2634    };
2635
2636    // Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd
2637    function closestElement(selector, base) {
2638        if (base === void 0) {
2639            base = this;
2640        }
2641        function __closestFrom(el) {
2642            if (!el || el === getDocument() || el === getWindow()) return null;
2643            if (el.assignedSlot) el = el.assignedSlot;
2644            const found = el.closest(selector);
2645            if (!found && !el.getRootNode) {
2646                return null;
2647            }
2648            return found || __closestFrom(el.getRootNode().host);
2649        }
2650        return __closestFrom(base);
2651    }
2652    function preventEdgeSwipe(swiper, event, startX) {
2653        const window = getWindow();
2654        const {
2655            params
2656        } = swiper;
2657        const edgeSwipeDetection = params.edgeSwipeDetection;
2658        const edgeSwipeThreshold = params.edgeSwipeThreshold;
2659        if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
2660            if (edgeSwipeDetection === 'prevent') {
2661                event.preventDefault();
2662                return true;
2663            }
2664            return false;
2665        }
2666        return true;
2667    }
2668    function onTouchStart(event) {
2669        const swiper = this;
2670        const document = getDocument();
2671        let e = event;
2672        if (e.originalEvent) e = e.originalEvent;
2673        const data = swiper.touchEventsData;
2674        if (e.type === 'pointerdown') {
2675            if (data.pointerId !== null && data.pointerId !== e.pointerId) {
2676                return;
2677            }
2678            data.pointerId = e.pointerId;
2679        } else if (e.type === 'touchstart' && e.targetTouches.length === 1) {
2680            data.touchId = e.targetTouches[0].identifier;
2681        }
2682        if (e.type === 'touchstart') {
2683            // don't proceed touch event
2684            preventEdgeSwipe(swiper, e, e.targetTouches[0].pageX);
2685            return;
2686        }
2687        const {
2688            params,
2689            touches,
2690            enabled
2691        } = swiper;
2692        if (!enabled) return;
2693        if (!params.simulateTouch && e.pointerType === 'mouse') return;
2694        if (swiper.animating && params.preventInteractionOnTransition) {
2695            return;
2696        }
2697        if (!swiper.animating && params.cssMode && params.loop) {
2698            swiper.loopFix();
2699        }
2700        let targetEl = e.target;
2701        if (params.touchEventsTarget === 'wrapper') {
2702            if (!elementIsChildOf(targetEl, swiper.wrapperEl)) return;
2703        }
2704        if ('which' in e && e.which === 3) return;
2705        if ('button' in e && e.button > 0) return;
2706        if (data.isTouched && data.isMoved) return;
2707
2708        // change target el for shadow root component
2709        const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';
2710        // eslint-disable-next-line
2711        const eventPath = e.composedPath ? e.composedPath() : e.path;
2712        if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
2713            targetEl = eventPath[0];
2714        }
2715        const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2716        const isTargetShadow = !!(e.target && e.target.shadowRoot);
2717
2718        // use closestElement for shadow root element to get the actual closest for nested shadow root element
2719        if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {
2720            swiper.allowClick = true;
2721            return;
2722        }
2723        if (params.swipeHandler) {
2724            if (!targetEl.closest(params.swipeHandler)) return;
2725        }
2726        touches.currentX = e.pageX;
2727        touches.currentY = e.pageY;
2728        const startX = touches.currentX;
2729        const startY = touches.currentY;
2730
2731        // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
2732
2733        if (!preventEdgeSwipe(swiper, e, startX)) {
2734            return;
2735        }
2736        Object.assign(data, {
2737            isTouched: true,
2738            isMoved: false,
2739            allowTouchCallbacks: true,
2740            isScrolling: undefined,
2741            startMoving: undefined
2742        });
2743        touches.startX = startX;
2744        touches.startY = startY;

vendor: 7,981 bytes, lines 2745-2924

2745        data.touchStartTime = now();
2746        swiper.allowClick = true;
2747        swiper.updateSize();
2748        swiper.swipeDirection = undefined;
2749        if (params.threshold > 0) data.allowThresholdMove = false;
2750        let preventDefault = true;
2751        if (targetEl.matches(data.focusableElements)) {
2752            preventDefault = false;
2753            if (targetEl.nodeName === 'SELECT') {
2754                data.isTouched = false;
2755            }
2756        }
2757        if (document.activeElement && document.activeElement.matches(data.focusableElements) && document.activeElement !== targetEl && (e.pointerType === 'mouse' || e.pointerType !== 'mouse' && !targetEl.matches(data.focusableElements))) {
2758            document.activeElement.blur();
2759        }
2760        const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
2761        if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !targetEl.isContentEditable) {
2762            e.preventDefault();
2763        }
2764        if (params.freeMode && params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
2765            swiper.freeMode.onTouchStart();
2766        }
2767        swiper.emit('touchStart', e);
2768    }
2769
2770    function onTouchMove(event) {
2771        const document = getDocument();
2772        const swiper = this;
2773        const data = swiper.touchEventsData;
2774        const {
2775            params,
2776            touches,
2777            rtlTranslate: rtl,
2778            enabled
2779        } = swiper;
2780        if (!enabled) return;
2781        if (!params.simulateTouch && event.pointerType === 'mouse') return;
2782        let e = event;
2783        if (e.originalEvent) e = e.originalEvent;
2784        if (e.type === 'pointermove') {
2785            if (data.touchId !== null) return; // return from pointer if we use touch
2786            const id = e.pointerId;
2787            if (id !== data.pointerId) return;
2788        }
2789        let targetTouch;
2790        if (e.type === 'touchmove') {
2791            targetTouch = [...e.changedTouches].find(t => t.identifier === data.touchId);
2792            if (!targetTouch || targetTouch.identifier !== data.touchId) return;
2793        } else {
2794            targetTouch = e;
2795        }
2796        if (!data.isTouched) {
2797            if (data.startMoving && data.isScrolling) {
2798                swiper.emit('touchMoveOpposite', e);
2799            }
2800            return;
2801        }
2802        const pageX = targetTouch.pageX;
2803        const pageY = targetTouch.pageY;
2804        if (e.preventedByNestedSwiper) {
2805            touches.startX = pageX;
2806            touches.startY = pageY;
2807            return;
2808        }
2809        if (!swiper.allowTouchMove) {
2810            if (!e.target.matches(data.focusableElements)) {
2811                swiper.allowClick = false;
2812            }
2813            if (data.isTouched) {
2814                Object.assign(touches, {
2815                    startX: pageX,
2816                    startY: pageY,
2817                    currentX: pageX,
2818                    currentY: pageY
2819                });
2820                data.touchStartTime = now();
2821            }
2822            return;
2823        }
2824        if (params.touchReleaseOnEdges && !params.loop) {
2825            if (swiper.isVertical()) {
2826                // Vertical
2827                if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {
2828                    data.isTouched = false;
2829                    data.isMoved = false;
2830                    return;
2831                }
2832            } else if (rtl && (pageX > touches.startX && -swiper.translate <= swiper.maxTranslate() || pageX < touches.startX && -swiper.translate >= swiper.minTranslate())) {
2833                return;
2834            } else if (!rtl && (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate())) {
2835                return;
2836            }
2837        }
2838        if (document.activeElement && document.activeElement.matches(data.focusableElements) && document.activeElement !== e.target && e.pointerType !== 'mouse') {
2839            document.activeElement.blur();
2840        }
2841        if (document.activeElement) {
2842            if (e.target === document.activeElement && e.target.matches(data.focusableElements)) {
2843                data.isMoved = true;
2844                swiper.allowClick = false;
2845                return;
2846            }
2847        }
2848        if (data.allowTouchCallbacks) {
2849            swiper.emit('touchMove', e);
2850        }
2851        touches.previousX = touches.currentX;
2852        touches.previousY = touches.currentY;
2853        touches.currentX = pageX;
2854        touches.currentY = pageY;
2855        const diffX = touches.currentX - touches.startX;
2856        const diffY = touches.currentY - touches.startY;
2857        if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;
2858        if (typeof data.isScrolling === 'undefined') {
2859            let touchAngle;
2860            if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {
2861                data.isScrolling = false;
2862            } else {
2863                // eslint-disable-next-line
2864                if (diffX * diffX + diffY * diffY >= 25) {
2865                    touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
2866                    data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
2867                }
2868            }
2869        }
2870        if (data.isScrolling) {
2871            swiper.emit('touchMoveOpposite', e);
2872        }
2873        if (typeof data.startMoving === 'undefined') {
2874            if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
2875                data.startMoving = true;
2876            }
2877        }
2878        if (data.isScrolling || e.type === 'touchmove' && data.preventTouchMoveFromPointerMove) {
2879            data.isTouched = false;
2880            return;
2881        }
2882        if (!data.startMoving) {
2883            return;
2884        }
2885        swiper.allowClick = false;
2886        if (!params.cssMode && e.cancelable) {
2887            e.preventDefault();
2888        }
2889        if (params.touchMoveStopPropagation && !params.nested) {
2890            e.stopPropagation();
2891        }
2892        let diff = swiper.isHorizontal() ? diffX : diffY;
2893        let touchesDiff = swiper.isHorizontal() ? touches.currentX - touches.previousX : touches.currentY - touches.previousY;
2894        if (params.oneWayMovement) {
2895            diff = Math.abs(diff) * (rtl ? 1 : -1);
2896            touchesDiff = Math.abs(touchesDiff) * (rtl ? 1 : -1);
2897        }
2898        touches.diff = diff;
2899        diff *= params.touchRatio;
2900        if (rtl) {
2901            diff = -diff;
2902            touchesDiff = -touchesDiff;
2903        }
2904        const prevTouchesDirection = swiper.touchesDirection;
2905        swiper.swipeDirection = diff > 0 ? 'prev' : 'next';
2906        swiper.touchesDirection = touchesDiff > 0 ? 'prev' : 'next';
2907        const isLoop = swiper.params.loop && !params.cssMode;
2908        const allowLoopFix = swiper.touchesDirection === 'next' && swiper.allowSlideNext || swiper.touchesDirection === 'prev' && swiper.allowSlidePrev;
2909        if (!data.isMoved) {
2910            if (isLoop && allowLoopFix) {
2911                swiper.loopFix({
2912                    direction: swiper.swipeDirection
2913                });
2914            }
2915            data.startTranslate = swiper.getTranslate();
2916            swiper.setTransition(0);
2917            if (swiper.animating) {
2918                const evt = new window.CustomEvent('transitionend', {
2919                    bubbles: true,
2920                    cancelable: true,
2921                    detail: {
2922                        bySwiperTouchMove: true
2923                    }
2924                });

vendor: 5,652 bytes, lines 2925-3037

2925                swiper.wrapperEl.dispatchEvent(evt);
2926            }
2927            data.allowMomentumBounce = false;
2928            // Grab Cursor
2929            if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
2930                swiper.setGrabCursor(true);
2931            }
2932            swiper.emit('sliderFirstMove', e);
2933        }
2934        let loopFixed;
2935        new Date().getTime();
2936        if (params._loopSwapReset !== false && data.isMoved && data.allowThresholdMove && prevTouchesDirection !== swiper.touchesDirection && isLoop && allowLoopFix && Math.abs(diff) >= 1) {
2937            Object.assign(touches, {
2938                startX: pageX,
2939                startY: pageY,
2940                currentX: pageX,
2941                currentY: pageY,
2942                startTranslate: data.currentTranslate
2943            });
2944            data.loopSwapReset = true;
2945            data.startTranslate = data.currentTranslate;
2946            return;
2947        }
2948        swiper.emit('sliderMove', e);
2949        data.isMoved = true;
2950        data.currentTranslate = diff + data.startTranslate;
2951        let disableParentSwiper = true;
2952        let resistanceRatio = params.resistanceRatio;
2953        if (params.touchReleaseOnEdges) {
2954            resistanceRatio = 0;
2955        }
2956        if (diff > 0) {
2957            if (isLoop && allowLoopFix && !loopFixed && data.allowThresholdMove && data.currentTranslate > (params.centeredSlides ? swiper.minTranslate() - swiper.slidesSizesGrid[swiper.activeIndex + 1] - (params.slidesPerView !== 'auto' && swiper.slides.length - params.slidesPerView >= 2 ? swiper.slidesSizesGrid[swiper.activeIndex + 1] + swiper.params.spaceBetween : 0) - swiper.params.spaceBetween : swiper.minTranslate())) {
2958                swiper.loopFix({
2959                    direction: 'prev',
2960                    setTranslate: true,
2961                    activeSlideIndex: 0
2962                });
2963            }
2964            if (data.currentTranslate > swiper.minTranslate()) {
2965                disableParentSwiper = false;
2966                if (params.resistance) {
2967                    data.currentTranslate = swiper.minTranslate() - 1 + (-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio;
2968                }
2969            }
2970        } else if (diff < 0) {
2971            if (isLoop && allowLoopFix && !loopFixed && data.allowThresholdMove && data.currentTranslate < (params.centeredSlides ? swiper.maxTranslate() + swiper.slidesSizesGrid[swiper.slidesSizesGrid.length - 1] + swiper.params.spaceBetween + (params.slidesPerView !== 'auto' && swiper.slides.length - params.slidesPerView >= 2 ? swiper.slidesSizesGrid[swiper.slidesSizesGrid.length - 1] + swiper.params.spaceBetween : 0) : swiper.maxTranslate())) {
2972                swiper.loopFix({
2973                    direction: 'next',
2974                    setTranslate: true,
2975                    activeSlideIndex: swiper.slides.length - (params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(parseFloat(params.slidesPerView, 10)))
2976                });
2977            }
2978            if (data.currentTranslate < swiper.maxTranslate()) {
2979                disableParentSwiper = false;
2980                if (params.resistance) {
2981                    data.currentTranslate = swiper.maxTranslate() + 1 - (swiper.maxTranslate() - data.startTranslate - diff) ** resistanceRatio;
2982                }
2983            }
2984        }
2985        if (disableParentSwiper) {
2986            e.preventedByNestedSwiper = true;
2987        }
2988
2989        // Directions locks
2990        if (!swiper.allowSlideNext && swiper.swipeDirection === 'next' && data.currentTranslate < data.startTranslate) {
2991            data.currentTranslate = data.startTranslate;
2992        }
2993        if (!swiper.allowSlidePrev && swiper.swipeDirection === 'prev' && data.currentTranslate > data.startTranslate) {
2994            data.currentTranslate = data.startTranslate;
2995        }
2996        if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {
2997            data.currentTranslate = data.startTranslate;
2998        }
2999
3000        // Threshold
3001        if (params.threshold > 0) {
3002            if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
3003                if (!data.allowThresholdMove) {
3004                    data.allowThresholdMove = true;
3005                    touches.startX = touches.currentX;
3006                    touches.startY = touches.currentY;
3007                    data.currentTranslate = data.startTranslate;
3008                    touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;
3009                    return;
3010                }
3011            } else {
3012                data.currentTranslate = data.startTranslate;
3013                return;
3014            }
3015        }
3016        if (!params.followFinger || params.cssMode) return;
3017
3018        // Update active index in free mode
3019        if (params.freeMode && params.freeMode.enabled && swiper.freeMode || params.watchSlidesProgress) {
3020            swiper.updateActiveIndex();
3021            swiper.updateSlidesClasses();
3022        }
3023        if (params.freeMode && params.freeMode.enabled && swiper.freeMode) {
3024            swiper.freeMode.onTouchMove();
3025        }
3026        // Update progress
3027        swiper.updateProgress(data.currentTranslate);
3028        // Update translate
3029        swiper.setTranslate(data.currentTranslate);
3030    }
3031
3032    function onTouchEnd(event) {
3033        const swiper = this;
3034        const data = swiper.touchEventsData;
3035        let e = event;
3036        if (e.originalEvent) e = e.originalEvent;
3037        let targetTouch;

vendor: 6,898 bytes, lines 3038-3199

3038        const isTouchEvent = e.type === 'touchend' || e.type === 'touchcancel';
3039        if (!isTouchEvent) {
3040            if (data.touchId !== null) return; // return from pointer if we use touch
3041            if (e.pointerId !== data.pointerId) return;
3042            targetTouch = e;
3043        } else {
3044            targetTouch = [...e.changedTouches].find(t => t.identifier === data.touchId);
3045            if (!targetTouch || targetTouch.identifier !== data.touchId) return;
3046        }
3047        if (['pointercancel', 'pointerout', 'pointerleave', 'contextmenu'].includes(e.type)) {
3048            const proceed = ['pointercancel', 'contextmenu'].includes(e.type) && (swiper.browser.isSafari || swiper.browser.isWebView);
3049            if (!proceed) {
3050                return;
3051            }
3052        }
3053        data.pointerId = null;
3054        data.touchId = null;
3055        const {
3056            params,
3057            touches,
3058            rtlTranslate: rtl,
3059            slidesGrid,
3060            enabled
3061        } = swiper;
3062        if (!enabled) return;
3063        if (!params.simulateTouch && e.pointerType === 'mouse') return;
3064        if (data.allowTouchCallbacks) {
3065            swiper.emit('touchEnd', e);
3066        }
3067        data.allowTouchCallbacks = false;
3068        if (!data.isTouched) {
3069            if (data.isMoved && params.grabCursor) {
3070                swiper.setGrabCursor(false);
3071            }
3072            data.isMoved = false;
3073            data.startMoving = false;
3074            return;
3075        }
3076
3077        // Return Grab Cursor
3078        if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
3079            swiper.setGrabCursor(false);
3080        }
3081
3082        // Time diff
3083        const touchEndTime = now();
3084        const timeDiff = touchEndTime - data.touchStartTime;
3085
3086        // Tap, doubleTap, Click
3087        if (swiper.allowClick) {
3088            const pathTree = e.path || e.composedPath && e.composedPath();
3089            swiper.updateClickedSlide(pathTree && pathTree[0] || e.target, pathTree);
3090            swiper.emit('tap click', e);
3091            if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {
3092                swiper.emit('doubleTap doubleClick', e);
3093            }
3094        }
3095        data.lastClickTime = now();
3096        nextTick(() => {
3097            if (!swiper.destroyed) swiper.allowClick = true;
3098        });
3099        if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 && !data.loopSwapReset || data.currentTranslate === data.startTranslate && !data.loopSwapReset) {
3100            data.isTouched = false;
3101            data.isMoved = false;
3102            data.startMoving = false;
3103            return;
3104        }
3105        data.isTouched = false;
3106        data.isMoved = false;
3107        data.startMoving = false;
3108        let currentPos;
3109        if (params.followFinger) {
3110            currentPos = rtl ? swiper.translate : -swiper.translate;
3111        } else {
3112            currentPos = -data.currentTranslate;
3113        }
3114        if (params.cssMode) {
3115            return;
3116        }
3117        if (params.freeMode && params.freeMode.enabled) {
3118            swiper.freeMode.onTouchEnd({
3119                currentPos
3120            });
3121            return;
3122        }
3123
3124        // Find current slide
3125        const swipeToLast = currentPos >= -swiper.maxTranslate() && !swiper.params.loop;
3126        let stopIndex = 0;
3127        let groupSize = swiper.slidesSizesGrid[0];
3128        for (let i = 0; i < slidesGrid.length; i += i < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup) {
3129            const increment = i < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
3130            if (typeof slidesGrid[i + increment] !== 'undefined') {
3131                if (swipeToLast || currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + increment]) {
3132                    stopIndex = i;
3133                    groupSize = slidesGrid[i + increment] - slidesGrid[i];
3134                }
3135            } else if (swipeToLast || currentPos >= slidesGrid[i]) {
3136                stopIndex = i;
3137                groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];
3138            }
3139        }
3140        let rewindFirstIndex = null;
3141        let rewindLastIndex = null;
3142        if (params.rewind) {
3143            if (swiper.isBeginning) {
3144                rewindLastIndex = params.virtual && params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
3145            } else if (swiper.isEnd) {
3146                rewindFirstIndex = 0;
3147            }
3148        }
3149        // Find current slide size
3150        const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;
3151        const increment = stopIndex < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
3152        if (timeDiff > params.longSwipesMs) {
3153            // Long touches
3154            if (!params.longSwipes) {
3155                swiper.slideTo(swiper.activeIndex);
3156                return;
3157            }
3158            if (swiper.swipeDirection === 'next') {
3159                if (ratio >= params.longSwipesRatio) swiper.slideTo(params.rewind && swiper.isEnd ? rewindFirstIndex : stopIndex + increment);else swiper.slideTo(stopIndex);
3160            }
3161            if (swiper.swipeDirection === 'prev') {
3162                if (ratio > 1 - params.longSwipesRatio) {
3163                    swiper.slideTo(stopIndex + increment);
3164                } else if (rewindLastIndex !== null && ratio < 0 && Math.abs(ratio) > params.longSwipesRatio) {
3165                    swiper.slideTo(rewindLastIndex);
3166                } else {
3167                    swiper.slideTo(stopIndex);
3168                }
3169            }
3170        } else {
3171            // Short swipes
3172            if (!params.shortSwipes) {
3173                swiper.slideTo(swiper.activeIndex);
3174                return;
3175            }
3176            const isNavButtonTarget = swiper.navigation && (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);
3177            if (!isNavButtonTarget) {
3178                if (swiper.swipeDirection === 'next') {
3179                    swiper.slideTo(rewindFirstIndex !== null ? rewindFirstIndex : stopIndex + increment);
3180                }
3181                if (swiper.swipeDirection === 'prev') {
3182                    swiper.slideTo(rewindLastIndex !== null ? rewindLastIndex : stopIndex);
3183                }
3184            } else if (e.target === swiper.navigation.nextEl) {
3185                swiper.slideTo(stopIndex + increment);
3186            } else {
3187                swiper.slideTo(stopIndex);
3188            }
3189        }
3190    }
3191
3192    function onResize() {
3193        const swiper = this;
3194        const {
3195            params,
3196            el
3197        } = swiper;
3198        if (el && el.offsetWidth === 0) return;
3199

vendor: 6,264 bytes, lines 3200-3375

3200        // Breakpoints
3201        if (params.breakpoints) {
3202            swiper.setBreakpoint();
3203        }
3204
3205        // Save locks
3206        const {
3207            allowSlideNext,
3208            allowSlidePrev,
3209            snapGrid
3210        } = swiper;
3211        const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
3212
3213        // Disable locks on resize
3214        swiper.allowSlideNext = true;
3215        swiper.allowSlidePrev = true;
3216        swiper.updateSize();
3217        swiper.updateSlides();
3218        swiper.updateSlidesClasses();
3219        const isVirtualLoop = isVirtual && params.loop;
3220        if ((params.slidesPerView === 'auto' || params.slidesPerView > 1) && swiper.isEnd && !swiper.isBeginning && !swiper.params.centeredSlides && !isVirtualLoop) {
3221            swiper.slideTo(swiper.slides.length - 1, 0, false, true);
3222        } else {
3223            if (swiper.params.loop && !isVirtual) {
3224                swiper.slideToLoop(swiper.realIndex, 0, false, true);
3225            } else {
3226                swiper.slideTo(swiper.activeIndex, 0, false, true);
3227            }
3228        }
3229        if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
3230            clearTimeout(swiper.autoplay.resizeTimeout);
3231            swiper.autoplay.resizeTimeout = setTimeout(() => {
3232                if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
3233                    swiper.autoplay.resume();
3234                }
3235            }, 500);
3236        }
3237        // Return locks after resize
3238        swiper.allowSlidePrev = allowSlidePrev;
3239        swiper.allowSlideNext = allowSlideNext;
3240        if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {
3241            swiper.checkOverflow();
3242        }
3243    }
3244
3245    function onClick(e) {
3246        const swiper = this;
3247        if (!swiper.enabled) return;
3248        if (!swiper.allowClick) {
3249            if (swiper.params.preventClicks) e.preventDefault();
3250            if (swiper.params.preventClicksPropagation && swiper.animating) {
3251                e.stopPropagation();
3252                e.stopImmediatePropagation();
3253            }
3254        }
3255    }
3256
3257    function onScroll() {
3258        const swiper = this;
3259        const {
3260            wrapperEl,
3261            rtlTranslate,
3262            enabled
3263        } = swiper;
3264        if (!enabled) return;
3265        swiper.previousTranslate = swiper.translate;
3266        if (swiper.isHorizontal()) {
3267            swiper.translate = -wrapperEl.scrollLeft;
3268        } else {
3269            swiper.translate = -wrapperEl.scrollTop;
3270        }
3271        // eslint-disable-next-line
3272        if (swiper.translate === 0) swiper.translate = 0;
3273        swiper.updateActiveIndex();
3274        swiper.updateSlidesClasses();
3275        let newProgress;
3276        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
3277        if (translatesDiff === 0) {
3278            newProgress = 0;
3279        } else {
3280            newProgress = (swiper.translate - swiper.minTranslate()) / translatesDiff;
3281        }
3282        if (newProgress !== swiper.progress) {
3283            swiper.updateProgress(rtlTranslate ? -swiper.translate : swiper.translate);
3284        }
3285        swiper.emit('setTranslate', swiper.translate, false);
3286    }
3287
3288    function onLoad(e) {
3289        const swiper = this;
3290        processLazyPreloader(swiper, e.target);
3291        if (swiper.params.cssMode || swiper.params.slidesPerView !== 'auto' && !swiper.params.autoHeight) {
3292            return;
3293        }
3294        swiper.update();
3295    }
3296
3297    function onDocumentTouchStart() {
3298        const swiper = this;
3299        if (swiper.documentTouchHandlerProceeded) return;
3300        swiper.documentTouchHandlerProceeded = true;
3301        if (swiper.params.touchReleaseOnEdges) {
3302            swiper.el.style.touchAction = 'auto';
3303        }
3304    }
3305
3306    const events = (swiper, method) => {
3307        const document = getDocument();
3308        const {
3309            params,
3310            el,
3311            wrapperEl,
3312            device
3313        } = swiper;
3314        const capture = !!params.nested;
3315        const domMethod = method === 'on' ? 'addEventListener' : 'removeEventListener';
3316        const swiperMethod = method;
3317        if (!el || typeof el === 'string') return;
3318
3319        // Touch Events
3320        document[domMethod]('touchstart', swiper.onDocumentTouchStart, {
3321            passive: false,
3322            capture
3323        });
3324        el[domMethod]('touchstart', swiper.onTouchStart, {
3325            passive: false
3326        });
3327        el[domMethod]('pointerdown', swiper.onTouchStart, {
3328            passive: false
3329        });
3330        document[domMethod]('touchmove', swiper.onTouchMove, {
3331            passive: false,
3332            capture
3333        });
3334        document[domMethod]('pointermove', swiper.onTouchMove, {
3335            passive: false,
3336            capture
3337        });
3338        document[domMethod]('touchend', swiper.onTouchEnd, {
3339            passive: true
3340        });
3341        document[domMethod]('pointerup', swiper.onTouchEnd, {
3342            passive: true
3343        });
3344        document[domMethod]('pointercancel', swiper.onTouchEnd, {
3345            passive: true
3346        });
3347        document[domMethod]('touchcancel', swiper.onTouchEnd, {
3348            passive: true
3349        });
3350        document[domMethod]('pointerout', swiper.onTouchEnd, {
3351            passive: true
3352        });
3353        document[domMethod]('pointerleave', swiper.onTouchEnd, {
3354            passive: true
3355        });
3356        document[domMethod]('contextmenu', swiper.onTouchEnd, {
3357            passive: true
3358        });
3359
3360        // Prevent Links Clicks
3361        if (params.preventClicks || params.preventClicksPropagation) {
3362            el[domMethod]('click', swiper.onClick, true);
3363        }
3364        if (params.cssMode) {
3365            wrapperEl[domMethod]('scroll', swiper.onScroll);
3366        }
3367
3368        // Resize handler
3369        if (params.updateOnWindowResize) {
3370            swiper[swiperMethod](device.ios || device.android ? 'resize orientationchange observerUpdate' : 'resize observerUpdate', onResize, true);
3371        } else {
3372            swiper[swiperMethod]('observerUpdate', onResize, true);
3373        }
3374
3375        // Images loader

vendor: 5,335 bytes, lines 3376-3495

3376        el[domMethod]('load', swiper.onLoad, {
3377            capture: true
3378        });
3379    };
3380    function attachEvents() {
3381        const swiper = this;
3382        const {
3383            params
3384        } = swiper;
3385        swiper.onTouchStart = onTouchStart.bind(swiper);
3386        swiper.onTouchMove = onTouchMove.bind(swiper);
3387        swiper.onTouchEnd = onTouchEnd.bind(swiper);
3388        swiper.onDocumentTouchStart = onDocumentTouchStart.bind(swiper);
3389        if (params.cssMode) {
3390            swiper.onScroll = onScroll.bind(swiper);
3391        }
3392        swiper.onClick = onClick.bind(swiper);
3393        swiper.onLoad = onLoad.bind(swiper);
3394        events(swiper, 'on');
3395    }
3396    function detachEvents() {
3397        const swiper = this;
3398        events(swiper, 'off');
3399    }
3400    var events$1 = {
3401        attachEvents,
3402        detachEvents
3403    };
3404
3405    const isGridEnabled = (swiper, params) => {
3406        return swiper.grid && params.grid && params.grid.rows > 1;
3407    };
3408    function setBreakpoint() {
3409        const swiper = this;
3410        const {
3411            realIndex,
3412            initialized,
3413            params,
3414            el
3415        } = swiper;
3416        const breakpoints = params.breakpoints;
3417        if (!breakpoints || breakpoints && Object.keys(breakpoints).length === 0) return;
3418        const document = getDocument();
3419
3420        // Get breakpoint for window/container width and update parameters
3421        const breakpointsBase = params.breakpointsBase === 'window' || !params.breakpointsBase ? params.breakpointsBase : 'container';
3422        const breakpointContainer = ['window', 'container'].includes(params.breakpointsBase) || !params.breakpointsBase ? swiper.el : document.querySelector(params.breakpointsBase);
3423        const breakpoint = swiper.getBreakpoint(breakpoints, breakpointsBase, breakpointContainer);
3424        if (!breakpoint || swiper.currentBreakpoint === breakpoint) return;
3425        const breakpointOnlyParams = breakpoint in breakpoints ? breakpoints[breakpoint] : undefined;
3426        const breakpointParams = breakpointOnlyParams || swiper.originalParams;
3427        const wasMultiRow = isGridEnabled(swiper, params);
3428        const isMultiRow = isGridEnabled(swiper, breakpointParams);
3429        const wasGrabCursor = swiper.params.grabCursor;
3430        const isGrabCursor = breakpointParams.grabCursor;
3431        const wasEnabled = params.enabled;
3432        if (wasMultiRow && !isMultiRow) {
3433            el.classList.remove(`${params.containerModifierClass}grid`, `${params.containerModifierClass}grid-column`);
3434            swiper.emitContainerClasses();
3435        } else if (!wasMultiRow && isMultiRow) {
3436            el.classList.add(`${params.containerModifierClass}grid`);
3437            if (breakpointParams.grid.fill && breakpointParams.grid.fill === 'column' || !breakpointParams.grid.fill && params.grid.fill === 'column') {
3438                el.classList.add(`${params.containerModifierClass}grid-column`);
3439            }
3440            swiper.emitContainerClasses();
3441        }
3442        if (wasGrabCursor && !isGrabCursor) {
3443            swiper.unsetGrabCursor();
3444        } else if (!wasGrabCursor && isGrabCursor) {
3445            swiper.setGrabCursor();
3446        }
3447
3448        // Toggle navigation, pagination, scrollbar
3449        ['navigation', 'pagination', 'scrollbar'].forEach(prop => {
3450            if (typeof breakpointParams[prop] === 'undefined') return;
3451            const wasModuleEnabled = params[prop] && params[prop].enabled;
3452            const isModuleEnabled = breakpointParams[prop] && breakpointParams[prop].enabled;
3453            if (wasModuleEnabled && !isModuleEnabled) {
3454                swiper[prop].disable();
3455            }
3456            if (!wasModuleEnabled && isModuleEnabled) {
3457                swiper[prop].enable();
3458            }
3459        });
3460        const directionChanged = breakpointParams.direction && breakpointParams.direction !== params.direction;
3461        const needsReLoop = params.loop && (breakpointParams.slidesPerView !== params.slidesPerView || directionChanged);
3462        const wasLoop = params.loop;
3463        if (directionChanged && initialized) {
3464            swiper.changeDirection();
3465        }
3466        extend(swiper.params, breakpointParams);
3467        const isEnabled = swiper.params.enabled;
3468        const hasLoop = swiper.params.loop;
3469        Object.assign(swiper, {
3470            allowTouchMove: swiper.params.allowTouchMove,
3471            allowSlideNext: swiper.params.allowSlideNext,
3472            allowSlidePrev: swiper.params.allowSlidePrev
3473        });
3474        if (wasEnabled && !isEnabled) {
3475            swiper.disable();
3476        } else if (!wasEnabled && isEnabled) {
3477            swiper.enable();
3478        }
3479        swiper.currentBreakpoint = breakpoint;
3480        swiper.emit('_beforeBreakpoint', breakpointParams);
3481        if (initialized) {
3482            if (needsReLoop) {
3483                swiper.loopDestroy();
3484                swiper.loopCreate(realIndex);
3485                swiper.updateSlides();
3486            } else if (!wasLoop && hasLoop) {
3487                swiper.loopCreate(realIndex);
3488                swiper.updateSlides();
3489            } else if (wasLoop && !hasLoop) {
3490                swiper.loopDestroy();
3491            }
3492        }
3493        swiper.emit('breakpoint', breakpointParams);
3494    }
3495

vendor: 4,112 bytes, lines 3496-3620

3496    function getBreakpoint(breakpoints, base, containerEl) {
3497        if (base === void 0) {
3498            base = 'window';
3499        }
3500        if (!breakpoints || base === 'container' && !containerEl) return undefined;
3501        let breakpoint = false;
3502        const window = getWindow();
3503        const currentHeight = base === 'window' ? window.innerHeight : containerEl.clientHeight;
3504        const points = Object.keys(breakpoints).map(point => {
3505            if (typeof point === 'string' && point.indexOf('@') === 0) {
3506                const minRatio = parseFloat(point.substr(1));
3507                const value = currentHeight * minRatio;
3508                return {
3509                    value,
3510                    point
3511                };
3512            }
3513            return {
3514                value: point,
3515                point
3516            };
3517        });
3518        points.sort((a, b) => parseInt(a.value, 10) - parseInt(b.value, 10));
3519        for (let i = 0; i < points.length; i += 1) {
3520            const {
3521                point,
3522                value
3523            } = points[i];
3524            if (base === 'window') {
3525                if (window.matchMedia(`(min-width: ${value}px)`).matches) {
3526                    breakpoint = point;
3527                }
3528            } else if (value <= containerEl.clientWidth) {
3529                breakpoint = point;
3530            }
3531        }
3532        return breakpoint || 'max';
3533    }
3534
3535    var breakpoints = {
3536        setBreakpoint,
3537        getBreakpoint
3538    };
3539
3540    function prepareClasses(entries, prefix) {
3541        const resultClasses = [];
3542        entries.forEach(item => {
3543            if (typeof item === 'object') {
3544                Object.keys(item).forEach(classNames => {
3545                    if (item[classNames]) {
3546                        resultClasses.push(prefix + classNames);
3547                    }
3548                });
3549            } else if (typeof item === 'string') {
3550                resultClasses.push(prefix + item);
3551            }
3552        });
3553        return resultClasses;
3554    }
3555    function addClasses() {
3556        const swiper = this;
3557        const {
3558            classNames,
3559            params,
3560            rtl,
3561            el,
3562            device
3563        } = swiper;
3564        // prettier-ignore
3565        const suffixes = prepareClasses(['initialized', params.direction, {
3566            'free-mode': swiper.params.freeMode && params.freeMode.enabled
3567        }, {
3568            'autoheight': params.autoHeight
3569        }, {
3570            'rtl': rtl
3571        }, {
3572            'grid': params.grid && params.grid.rows > 1
3573        }, {
3574            'grid-column': params.grid && params.grid.rows > 1 && params.grid.fill === 'column'
3575        }, {
3576            'android': device.android
3577        }, {
3578            'ios': device.ios
3579        }, {
3580            'css-mode': params.cssMode
3581        }, {
3582            'centered': params.cssMode && params.centeredSlides
3583        }, {
3584            'watch-progress': params.watchSlidesProgress
3585        }], params.containerModifierClass);
3586        classNames.push(...suffixes);
3587        el.classList.add(...classNames);
3588        swiper.emitContainerClasses();
3589    }
3590
3591    function removeClasses() {
3592        const swiper = this;
3593        const {
3594            el,
3595            classNames
3596        } = swiper;
3597        if (!el || typeof el === 'string') return;
3598        el.classList.remove(...classNames);
3599        swiper.emitContainerClasses();
3600    }
3601
3602    var classes = {
3603        addClasses,
3604        removeClasses
3605    };
3606
3607    function checkOverflow() {
3608        const swiper = this;
3609        const {
3610            isLocked: wasLocked,
3611            params
3612        } = swiper;
3613        const {
3614            slidesOffsetBefore
3615        } = params;
3616        if (slidesOffsetBefore) {
3617            const lastSlideIndex = swiper.slides.length - 1;
3618            const lastSlideRightEdge = swiper.slidesGrid[lastSlideIndex] + swiper.slidesSizesGrid[lastSlideIndex] + slidesOffsetBefore * 2;
3619            swiper.isLocked = swiper.size > lastSlideRightEdge;
3620        } else {

vendor: 1,758 bytes, lines 3621-3676

3621            swiper.isLocked = swiper.snapGrid.length === 1;
3622        }
3623        if (params.allowSlideNext === true) {
3624            swiper.allowSlideNext = !swiper.isLocked;
3625        }
3626        if (params.allowSlidePrev === true) {
3627            swiper.allowSlidePrev = !swiper.isLocked;
3628        }
3629        if (wasLocked && wasLocked !== swiper.isLocked) {
3630            swiper.isEnd = false;
3631        }
3632        if (wasLocked !== swiper.isLocked) {
3633            swiper.emit(swiper.isLocked ? 'lock' : 'unlock');
3634        }
3635    }
3636    var checkOverflow$1 = {
3637        checkOverflow
3638    };
3639
3640    var defaults = {
3641        init: true,
3642        direction: 'horizontal',
3643        oneWayMovement: false,
3644        swiperElementNodeName: 'SWIPER-CONTAINER',
3645        touchEventsTarget: 'wrapper',
3646        initialSlide: 0,
3647        speed: 300,
3648        cssMode: false,
3649        updateOnWindowResize: true,
3650        resizeObserver: true,
3651        nested: false,
3652        createElements: false,
3653        eventsPrefix: 'swiper',
3654        enabled: true,
3655        focusableElements: 'input, select, option, textarea, button, video, label',
3656        // Overrides
3657        width: null,
3658        height: null,
3659        //
3660        preventInteractionOnTransition: false,
3661        // ssr
3662        userAgent: null,
3663        url: null,
3664        // To support iOS's swipe-to-go-back gesture (when being used in-app).
3665        edgeSwipeDetection: false,
3666        edgeSwipeThreshold: 20,
3667        // Autoheight
3668        autoHeight: false,
3669        // Set wrapper width
3670        setWrapperSize: false,
3671        // Virtual Translate
3672        virtualTranslate: false,
3673        // Effects
3674        effect: 'slide',
3675        // 'slide' or 'fade' or 'cube' or 'coverflow' or 'flip'
3676

vendor: 4,995 bytes, lines 3677-3820

3677        // Breakpoints
3678        breakpoints: undefined,
3679        breakpointsBase: 'window',
3680        // Slides grid
3681        spaceBetween: 0,
3682        slidesPerView: 1,
3683        slidesPerGroup: 1,
3684        slidesPerGroupSkip: 0,
3685        slidesPerGroupAuto: false,
3686        centeredSlides: false,
3687        centeredSlidesBounds: false,
3688        slidesOffsetBefore: 0,
3689        // in px
3690        slidesOffsetAfter: 0,
3691        // in px
3692        normalizeSlideIndex: true,
3693        centerInsufficientSlides: false,
3694        // Disable swiper and hide navigation when container not overflow
3695        watchOverflow: true,
3696        // Round length
3697        roundLengths: false,
3698        // Touches
3699        touchRatio: 1,
3700        touchAngle: 45,
3701        simulateTouch: true,
3702        shortSwipes: true,
3703        longSwipes: true,
3704        longSwipesRatio: 0.5,
3705        longSwipesMs: 300,
3706        followFinger: true,
3707        allowTouchMove: true,
3708        threshold: 5,
3709        touchMoveStopPropagation: false,
3710        touchStartPreventDefault: true,
3711        touchStartForcePreventDefault: false,
3712        touchReleaseOnEdges: false,
3713        // Unique Navigation Elements
3714        uniqueNavElements: true,
3715        // Resistance
3716        resistance: true,
3717        resistanceRatio: 0.85,
3718        // Progress
3719        watchSlidesProgress: false,
3720        // Cursor
3721        grabCursor: false,
3722        // Clicks
3723        preventClicks: true,
3724        preventClicksPropagation: true,
3725        slideToClickedSlide: false,
3726        // loop
3727        loop: false,
3728        loopAddBlankSlides: true,
3729        loopAdditionalSlides: 0,
3730        loopPreventsSliding: true,
3731        // rewind
3732        rewind: false,
3733        // Swiping/no swiping
3734        allowSlidePrev: true,
3735        allowSlideNext: true,
3736        swipeHandler: null,
3737        // '.swipe-handler',
3738        noSwiping: true,
3739        noSwipingClass: 'swiper-no-swiping',
3740        noSwipingSelector: null,
3741        // Passive Listeners
3742        passiveListeners: true,
3743        maxBackfaceHiddenSlides: 10,
3744        // NS
3745        containerModifierClass: 'swiper-',
3746        // NEW
3747        slideClass: 'swiper-slide',
3748        slideBlankClass: 'swiper-slide-blank',
3749        slideActiveClass: 'swiper-slide-active',
3750        slideVisibleClass: 'swiper-slide-visible',
3751        slideFullyVisibleClass: 'swiper-slide-fully-visible',
3752        slideNextClass: 'swiper-slide-next',
3753        slidePrevClass: 'swiper-slide-prev',
3754        wrapperClass: 'swiper-wrapper',
3755        lazyPreloaderClass: 'swiper-lazy-preloader',
3756        lazyPreloadPrevNext: 0,
3757        // Callbacks
3758        runCallbacksOnInit: true,
3759        // Internals
3760        _emitClasses: false
3761    };
3762
3763    function moduleExtendParams(params, allModulesParams) {
3764        return function extendParams(obj) {
3765            if (obj === void 0) {
3766                obj = {};
3767            }
3768            const moduleParamName = Object.keys(obj)[0];
3769            const moduleParams = obj[moduleParamName];
3770            if (typeof moduleParams !== 'object' || moduleParams === null) {
3771                extend(allModulesParams, obj);
3772                return;
3773            }
3774            if (params[moduleParamName] === true) {
3775                params[moduleParamName] = {
3776                    enabled: true
3777                };
3778            }
3779            if (moduleParamName === 'navigation' && params[moduleParamName] && params[moduleParamName].enabled && !params[moduleParamName].prevEl && !params[moduleParamName].nextEl) {
3780                params[moduleParamName].auto = true;
3781            }
3782            if (['pagination', 'scrollbar'].indexOf(moduleParamName) >= 0 && params[moduleParamName] && params[moduleParamName].enabled && !params[moduleParamName].el) {
3783                params[moduleParamName].auto = true;
3784            }
3785            if (!(moduleParamName in params && 'enabled' in moduleParams)) {
3786                extend(allModulesParams, obj);
3787                return;
3788            }
3789            if (typeof params[moduleParamName] === 'object' && !('enabled' in params[moduleParamName])) {
3790                params[moduleParamName].enabled = true;
3791            }
3792            if (!params[moduleParamName]) params[moduleParamName] = {
3793                enabled: false
3794            };
3795            extend(allModulesParams, obj);
3796        };
3797    }
3798
3799    /* eslint no-param-reassign: "off" */
3800    const prototypes = {
3801        eventsEmitter,
3802        update,
3803        translate,
3804        transition,
3805        slide,
3806        loop,
3807        grabCursor,
3808        events: events$1,
3809        breakpoints,
3810        checkOverflow: checkOverflow$1,
3811        classes
3812    };
3813    const extendedDefaults = {};
3814    class Swiper {
3815        constructor() {
3816            let el;
3817            let params;
3818            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
3819                args[_key] = arguments[_key];
3820            }

vendor: 1,074 bytes, lines 3821-3844

3821            if (args.length === 1 && args[0].constructor && Object.prototype.toString.call(args[0]).slice(8, -1) === 'Object') {
3822                params = args[0];
3823            } else {
3824                [el, params] = args;
3825            }
3826            if (!params) params = {};
3827            params = extend({}, params);
3828            if (el && !params.el) params.el = el;
3829            const document = getDocument();
3830            if (params.el && typeof params.el === 'string' && document.querySelectorAll(params.el).length > 1) {
3831                const swipers = [];
3832                document.querySelectorAll(params.el).forEach(containerEl => {
3833                    const newParams = extend({}, params, {
3834                        el: containerEl
3835                    });
3836                    swipers.push(new Swiper(newParams));
3837                });
3838                // eslint-disable-next-line no-constructor-return
3839                return swipers;
3840            }
3841
3842            // Swiper Instance
3843            const swiper = this;
3844            swiper.__swiper__ = true;

vendor: 1,438 bytes, lines 3845-3878

3845            swiper.support = getSupport();
3846            swiper.device = getDevice({
3847                userAgent: params.userAgent
3848            });
3849            swiper.browser = getBrowser();
3850            swiper.eventsListeners = {};
3851            swiper.eventsAnyListeners = [];
3852            swiper.modules = [...swiper.__modules__];
3853            if (params.modules && Array.isArray(params.modules)) {
3854                swiper.modules.push(...params.modules);
3855            }
3856            const allModulesParams = {};
3857            swiper.modules.forEach(mod => {
3858                mod({
3859                    params,
3860                    swiper,
3861                    extendParams: moduleExtendParams(params, allModulesParams),
3862                    on: swiper.on.bind(swiper),
3863                    once: swiper.once.bind(swiper),
3864                    off: swiper.off.bind(swiper),
3865                    emit: swiper.emit.bind(swiper)
3866                });
3867            });
3868
3869            // Extend defaults with modules params
3870            const swiperParams = extend({}, defaults, allModulesParams);
3871
3872            // Extend defaults with passed params
3873            swiper.params = extend({}, swiperParams, extendedDefaults, params);
3874            swiper.originalParams = extend({}, swiper.params);
3875            swiper.passedParams = extend({}, params);
3876
3877            // add event listeners
3878            if (swiper.params && swiper.params.on) {

vendor: 6,824 bytes, lines 3879-4055

3879                Object.keys(swiper.params.on).forEach(eventName => {
3880                    swiper.on(eventName, swiper.params.on[eventName]);
3881                });
3882            }
3883            if (swiper.params && swiper.params.onAny) {
3884                swiper.onAny(swiper.params.onAny);
3885            }
3886
3887            // Extend Swiper
3888            Object.assign(swiper, {
3889                enabled: swiper.params.enabled,
3890                el,
3891                // Classes
3892                classNames: [],
3893                // Slides
3894                slides: [],
3895                slidesGrid: [],
3896                snapGrid: [],
3897                slidesSizesGrid: [],
3898                // isDirection
3899                isHorizontal() {
3900                    return swiper.params.direction === 'horizontal';
3901                },
3902                isVertical() {
3903                    return swiper.params.direction === 'vertical';
3904                },
3905                // Indexes
3906                activeIndex: 0,
3907                realIndex: 0,
3908                //
3909                isBeginning: true,
3910                isEnd: false,
3911                // Props
3912                translate: 0,
3913                previousTranslate: 0,
3914                progress: 0,
3915                velocity: 0,
3916                animating: false,
3917                cssOverflowAdjustment() {
3918                    // Returns 0 unless `translate` is > 2**23
3919                    // Should be subtracted from css values to prevent overflow
3920                    return Math.trunc(this.translate / 2 ** 23) * 2 ** 23;
3921                },
3922                // Locks
3923                allowSlideNext: swiper.params.allowSlideNext,
3924                allowSlidePrev: swiper.params.allowSlidePrev,
3925                // Touch Events
3926                touchEventsData: {
3927                    isTouched: undefined,
3928                    isMoved: undefined,
3929                    allowTouchCallbacks: undefined,
3930                    touchStartTime: undefined,
3931                    isScrolling: undefined,
3932                    currentTranslate: undefined,
3933                    startTranslate: undefined,
3934                    allowThresholdMove: undefined,
3935                    // Form elements to match
3936                    focusableElements: swiper.params.focusableElements,
3937                    // Last click time
3938                    lastClickTime: 0,
3939                    clickTimeout: undefined,
3940                    // Velocities
3941                    velocities: [],
3942                    allowMomentumBounce: undefined,
3943                    startMoving: undefined,
3944                    pointerId: null,
3945                    touchId: null
3946                },
3947                // Clicks
3948                allowClick: true,
3949                // Touches
3950                allowTouchMove: swiper.params.allowTouchMove,
3951                touches: {
3952                    startX: 0,
3953                    startY: 0,
3954                    currentX: 0,
3955                    currentY: 0,
3956                    diff: 0
3957                },
3958                // Images
3959                imagesToLoad: [],
3960                imagesLoaded: 0
3961            });
3962            swiper.emit('_swiper');
3963
3964            // Init
3965            if (swiper.params.init) {
3966                swiper.init();
3967            }
3968
3969            // Return app instance
3970            // eslint-disable-next-line no-constructor-return
3971            return swiper;
3972        }
3973        getDirectionLabel(property) {
3974            if (this.isHorizontal()) {
3975                return property;
3976            }
3977            // prettier-ignore
3978            return {
3979                'width': 'height',
3980                'margin-top': 'margin-left',
3981                'margin-bottom ': 'margin-right',
3982                'margin-left': 'margin-top',
3983                'margin-right': 'margin-bottom',
3984                'padding-left': 'padding-top',
3985                'padding-right': 'padding-bottom',
3986                'marginRight': 'marginBottom'
3987            }[property];
3988        }
3989        getSlideIndex(slideEl) {
3990            const {
3991                slidesEl,
3992                params
3993            } = this;
3994            const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
3995            const firstSlideIndex = elementIndex(slides[0]);
3996            return elementIndex(slideEl) - firstSlideIndex;
3997        }
3998        getSlideIndexByData(index) {
3999            return this.getSlideIndex(this.slides.find(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === index));
4000        }
4001        recalcSlides() {
4002            const swiper = this;
4003            const {
4004                slidesEl,
4005                params
4006            } = swiper;
4007            swiper.slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
4008        }
4009        enable() {
4010            const swiper = this;
4011            if (swiper.enabled) return;
4012            swiper.enabled = true;
4013            if (swiper.params.grabCursor) {
4014                swiper.setGrabCursor();
4015            }
4016            swiper.emit('enable');
4017        }
4018        disable() {
4019            const swiper = this;
4020            if (!swiper.enabled) return;
4021            swiper.enabled = false;
4022            if (swiper.params.grabCursor) {
4023                swiper.unsetGrabCursor();
4024            }
4025            swiper.emit('disable');
4026        }
4027        setProgress(progress, speed) {
4028            const swiper = this;
4029            progress = Math.min(Math.max(progress, 0), 1);
4030            const min = swiper.minTranslate();
4031            const max = swiper.maxTranslate();
4032            const current = (max - min) * progress + min;
4033            swiper.translateTo(current, typeof speed === 'undefined' ? 0 : speed);
4034            swiper.updateActiveIndex();
4035            swiper.updateSlidesClasses();
4036        }
4037        emitContainerClasses() {
4038            const swiper = this;
4039            if (!swiper.params._emitClasses || !swiper.el) return;
4040            const cls = swiper.el.className.split(' ').filter(className => {
4041                return className.indexOf('swiper') === 0 || className.indexOf(swiper.params.containerModifierClass) === 0;
4042            });
4043            swiper.emit('_containerClasses', cls.join(' '));
4044        }
4045        getSlideClasses(slideEl) {
4046            const swiper = this;
4047            if (swiper.destroyed) return '';
4048            return slideEl.className.split(' ').filter(className => {
4049                return className.indexOf('swiper-slide') === 0 || className.indexOf(swiper.params.slideClass) === 0;
4050            }).join(' ');
4051        }
4052        emitSlidesClasses() {
4053            const swiper = this;
4054            if (!swiper.params._emitClasses || !swiper.el) return;
4055            const updates = [];

vendor: 2,968 bytes, lines 4056-4128

4056            swiper.slides.forEach(slideEl => {
4057                const classNames = swiper.getSlideClasses(slideEl);
4058                updates.push({
4059                    slideEl,
4060                    classNames
4061                });
4062                swiper.emit('_slideClass', slideEl, classNames);
4063            });
4064            swiper.emit('_slideClasses', updates);
4065        }
4066        slidesPerViewDynamic(view, exact) {
4067            if (view === void 0) {
4068                view = 'current';
4069            }
4070            if (exact === void 0) {
4071                exact = false;
4072            }
4073            const swiper = this;
4074            const {
4075                params,
4076                slides,
4077                slidesGrid,
4078                slidesSizesGrid,
4079                size: swiperSize,
4080                activeIndex
4081            } = swiper;
4082            let spv = 1;
4083            if (typeof params.slidesPerView === 'number') return params.slidesPerView;
4084            if (params.centeredSlides) {
4085                let slideSize = slides[activeIndex] ? Math.ceil(slides[activeIndex].swiperSlideSize) : 0;
4086                let breakLoop;
4087                for (let i = activeIndex + 1; i < slides.length; i += 1) {
4088                    if (slides[i] && !breakLoop) {
4089                        slideSize += Math.ceil(slides[i].swiperSlideSize);
4090                        spv += 1;
4091                        if (slideSize > swiperSize) breakLoop = true;
4092                    }
4093                }
4094                for (let i = activeIndex - 1; i >= 0; i -= 1) {
4095                    if (slides[i] && !breakLoop) {
4096                        slideSize += slides[i].swiperSlideSize;
4097                        spv += 1;
4098                        if (slideSize > swiperSize) breakLoop = true;
4099                    }
4100                }
4101            } else {
4102                // eslint-disable-next-line
4103                if (view === 'current') {
4104                    for (let i = activeIndex + 1; i < slides.length; i += 1) {
4105                        const slideInView = exact ? slidesGrid[i] + slidesSizesGrid[i] - slidesGrid[activeIndex] < swiperSize : slidesGrid[i] - slidesGrid[activeIndex] < swiperSize;
4106                        if (slideInView) {
4107                            spv += 1;
4108                        }
4109                    }
4110                } else {
4111                    // previous
4112                    for (let i = activeIndex - 1; i >= 0; i -= 1) {
4113                        const slideInView = slidesGrid[activeIndex] - slidesGrid[i] < swiperSize;
4114                        if (slideInView) {
4115                            spv += 1;
4116                        }
4117                    }
4118                }
4119            }
4120            return spv;
4121        }
4122        update() {
4123            const swiper = this;
4124            if (!swiper || swiper.destroyed) return;
4125            const {
4126                snapGrid,
4127                params
4128            } = swiper;

vendor: 2,832 bytes, lines 4129-4187

4129            // Breakpoints
4130            if (params.breakpoints) {
4131                swiper.setBreakpoint();
4132            }
4133            [...swiper.el.querySelectorAll('[loading="lazy"]')].forEach(imageEl => {
4134                if (imageEl.complete) {
4135                    processLazyPreloader(swiper, imageEl);
4136                }
4137            });
4138            swiper.updateSize();
4139            swiper.updateSlides();
4140            swiper.updateProgress();
4141            swiper.updateSlidesClasses();
4142            function setTranslate() {
4143                const translateValue = swiper.rtlTranslate ? swiper.translate * -1 : swiper.translate;
4144                const newTranslate = Math.min(Math.max(translateValue, swiper.maxTranslate()), swiper.minTranslate());
4145                swiper.setTranslate(newTranslate);
4146                swiper.updateActiveIndex();
4147                swiper.updateSlidesClasses();
4148            }
4149            let translated;
4150            if (params.freeMode && params.freeMode.enabled && !params.cssMode) {
4151                setTranslate();
4152                if (params.autoHeight) {
4153                    swiper.updateAutoHeight();
4154                }
4155            } else {
4156                if ((params.slidesPerView === 'auto' || params.slidesPerView > 1) && swiper.isEnd && !params.centeredSlides) {
4157                    const slides = swiper.virtual && params.virtual.enabled ? swiper.virtual.slides : swiper.slides;
4158                    translated = swiper.slideTo(slides.length - 1, 0, false, true);
4159                } else {
4160                    translated = swiper.slideTo(swiper.activeIndex, 0, false, true);
4161                }
4162                if (!translated) {
4163                    setTranslate();
4164                }
4165            }
4166            if (params.watchOverflow && snapGrid !== swiper.snapGrid) {
4167                swiper.checkOverflow();
4168            }
4169            swiper.emit('update');
4170        }
4171        changeDirection(newDirection, needUpdate) {
4172            if (needUpdate === void 0) {
4173                needUpdate = true;
4174            }
4175            const swiper = this;
4176            const currentDirection = swiper.params.direction;
4177            if (!newDirection) {
4178                // eslint-disable-next-line
4179                newDirection = currentDirection === 'horizontal' ? 'vertical' : 'horizontal';
4180            }
4181            if (newDirection === currentDirection || newDirection !== 'horizontal' && newDirection !== 'vertical') {
4182                return swiper;
4183            }
4184            swiper.el.classList.remove(`${swiper.params.containerModifierClass}${currentDirection}`);
4185            swiper.el.classList.add(`${swiper.params.containerModifierClass}${newDirection}`);
4186            swiper.emitContainerClasses();
4187            swiper.params.direction = newDirection;

vendor: 2,536 bytes, lines 4188-4245

4188            swiper.slides.forEach(slideEl => {
4189                if (newDirection === 'vertical') {
4190                    slideEl.style.width = '';
4191                } else {
4192                    slideEl.style.height = '';
4193                }
4194            });
4195            swiper.emit('changeDirection');
4196            if (needUpdate) swiper.update();
4197            return swiper;
4198        }
4199        changeLanguageDirection(direction) {
4200            const swiper = this;
4201            if (swiper.rtl && direction === 'rtl' || !swiper.rtl && direction === 'ltr') return;
4202            swiper.rtl = direction === 'rtl';
4203            swiper.rtlTranslate = swiper.params.direction === 'horizontal' && swiper.rtl;
4204            if (swiper.rtl) {
4205                swiper.el.classList.add(`${swiper.params.containerModifierClass}rtl`);
4206                swiper.el.dir = 'rtl';
4207            } else {
4208                swiper.el.classList.remove(`${swiper.params.containerModifierClass}rtl`);
4209                swiper.el.dir = 'ltr';
4210            }
4211            swiper.update();
4212        }
4213        mount(element) {
4214            const swiper = this;
4215            if (swiper.mounted) return true;
4216
4217            // Find el
4218            let el = element || swiper.params.el;
4219            if (typeof el === 'string') {
4220                el = document.querySelector(el);
4221            }
4222            if (!el) {
4223                return false;
4224            }
4225            el.swiper = swiper;
4226            if (el.parentNode && el.parentNode.host && el.parentNode.host.nodeName === swiper.params.swiperElementNodeName.toUpperCase()) {
4227                swiper.isElement = true;
4228            }
4229            const getWrapperSelector = () => {
4230                return `.${(swiper.params.wrapperClass || '').trim().split(' ').join('.')}`;
4231            };
4232            const getWrapper = () => {
4233                if (el && el.shadowRoot && el.shadowRoot.querySelector) {
4234                    const res = el.shadowRoot.querySelector(getWrapperSelector());
4235                    // Children needs to return slot items
4236                    return res;
4237                }
4238                return elementChildren(el, getWrapperSelector())[0];
4239            };
4240            // Find Wrapper
4241            let wrapperEl = getWrapper();
4242            if (!wrapperEl && swiper.params.createElements) {
4243                wrapperEl = createElement('div', swiper.params.wrapperClass);
4244                el.append(wrapperEl);
4245                elementChildren(el, `.${swiper.params.slideClass}

4245`).forEach(slideEl => {
4246                    wrapperEl.append(slideEl);
4247                });
4248            }
4249            Object.assign(swiper, {
4250                el,
4251                wrapperEl,
4252                slidesEl: swiper.isElement && !el.parentNode.host.slideSlots ? el.parentNode.host : wrapperEl,
4253                hostEl: swiper.isElement ? el.parentNode.host : el,
4254                mounted: true,
4255                // RTL
4256                rtl: el.dir.toLowerCase() === 'rtl' || elementStyle(el, 'direction') === 'rtl',
4257                rtlTranslate: swiper.params.direction === 'horizontal' && (el.dir.toLowerCase() === 'rtl' || elementStyle(el, 'direction') === 'rtl'),
4258                wrongRTL: elementStyle(wrapperEl, 'display') === '-webkit-box'
4259            });
4260            return true;
4261        }
4262        init(el) {
4263            const swiper = this;
4264            if (swiper.initialized) return swiper;
4265            const mounted = swiper.mount(el);
4266            if (mounted === false) return swiper;
4267            swiper.emit('beforeInit');
4268
4269            // Set breakpoint
4270            if (swiper.params.breakpoints) {
4271                swiper.setBreakpoint();
4272            }
4273
4274            // Add Classes
4275            swiper.addClasses();
4276
4277            // Update size
4278            swiper.updateSize();
4279
4280            // Update slides
4281            swiper.updateSlides();
4282            if (swiper.params.watchOverflow) {
4283                swiper.checkOverflow();
4284            }
4285
4286            // Set Grab Cursor
4287            if (swiper.params.grabCursor && swiper.enabled) {
4288                swiper.setGrabCursor();
4289            }
4290
4291            // Slide To Initial Slide
4292            if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
4293                swiper.slideTo(swiper.params.initialSlide + swiper.virtual.slidesBefore, 0, swiper.params.runCallbacksOnInit, false, true);
4294            } else {
4295                swiper.slideTo(swiper.params.initialSlide, 0, swiper.params.runCallbacksOnInit, false, true);
4296            }
4297
4298            // Create loop
4299            if (swiper.params.loop) {
4300                swiper.loopCreate(undefined, true);
4301            }
4302
4303            // Attach events
4304            swiper.attachEvents();
4305            const lazyElements = [...swiper.el.querySelectorAll('[loading="lazy"]')];
4306            if (swiper.isElement) {
4307                lazyElements.push(...swiper.hostEl.querySelectorAll('[loading="lazy"]'));
4308            }
4309            lazyElements.forEach(imageEl => {
4310                if (imageEl.complete) {
4311                    processLazyPreloader(swiper, imageEl);
4312                } else {
4313                    imageEl.addEventListener('load', e => {
4314                        processLazyPreloader(swiper, e.target);
4315                    });
4316                }
4317            });
4318            preload(swiper);
4319
4320            // Init Flag
4321            swiper.initialized = true;
4322            preload(swiper);
4323
4324            // Emit
4325            swiper.emit('init');
4326            swiper.emit('afterInit');
4327            return swiper;
4328        }
4329        destroy(deleteInstance, cleanStyles) {
4330            if (deleteInstance === void 0) {
4331                deleteInstance = true;
4332            }
4333            if (cleanStyles === void 0) {
4334                cleanStyles = true;
4335            }
4336            const swiper = this;
4337            const {
4338                params,
4339                el,
4340                wrapperEl,
4341                slides
4342            } = swiper;
4343            if (typeof swiper.params === 'undefined' || swiper.destroyed) {
4344                return null;
4345            }
4346            swiper.emit('beforeDestroy');
4347
4348            // Init Flag
4349            swiper.initialized = false;
4350
4351            // Detach events
4352            swiper.detachEvents();
4353
4354            // Destroy loop
4355            if (params.loop) {
4356                swiper.loopDestroy();
4357            }
4358
4359            // Cleanup styles
4360            if (cleanStyles) {
4361                swiper.removeClasses();
4362                if (el && typeof el !== 'string') {
4363                    el.removeAttribute('style');
4364                }
4365                if (wrapperEl) {
4366                    wrapperEl.removeAttribute('style');
4367                }
4368                if (slides && slides.length) {

vendor: 6,939 bytes, lines 4369-4546

4369                    slides.forEach(slideEl => {
4370                        slideEl.classList.remove(params.slideVisibleClass, params.slideFullyVisibleClass, params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
4371                        slideEl.removeAttribute('style');
4372                        slideEl.removeAttribute('data-swiper-slide-index');
4373                    });
4374                }
4375            }
4376            swiper.emit('destroy');
4377
4378            // Detach emitter events
4379            Object.keys(swiper.eventsListeners).forEach(eventName => {
4380                swiper.off(eventName);
4381            });
4382            if (deleteInstance !== false) {
4383                if (swiper.el && typeof swiper.el !== 'string') {
4384                    swiper.el.swiper = null;
4385                }
4386                deleteProps(swiper);
4387            }
4388            swiper.destroyed = true;
4389            return null;
4390        }
4391        static extendDefaults(newDefaults) {
4392            extend(extendedDefaults, newDefaults);
4393        }
4394        static get extendedDefaults() {
4395            return extendedDefaults;
4396        }
4397        static get defaults() {
4398            return defaults;
4399        }
4400        static installModule(mod) {
4401            if (!Swiper.prototype.__modules__) Swiper.prototype.__modules__ = [];
4402            const modules = Swiper.prototype.__modules__;
4403            if (typeof mod === 'function' && modules.indexOf(mod) < 0) {
4404                modules.push(mod);
4405            }
4406        }
4407        static use(module) {
4408            if (Array.isArray(module)) {
4409                module.forEach(m => Swiper.installModule(m));
4410                return Swiper;
4411            }
4412            Swiper.installModule(module);
4413            return Swiper;
4414        }
4415    }
4416    Object.keys(prototypes).forEach(prototypeGroup => {
4417        Object.keys(prototypes[prototypeGroup]).forEach(protoMethod => {
4418            Swiper.prototype[protoMethod] = prototypes[prototypeGroup][protoMethod];
4419        });
4420    });
4421    Swiper.use([Resize, Observer]);
4422
4423    function Virtual(_ref) {
4424        let {
4425            swiper,
4426            extendParams,
4427            on,
4428            emit
4429        } = _ref;
4430        extendParams({
4431            virtual: {
4432                enabled: false,
4433                slides: [],
4434                cache: true,
4435                renderSlide: null,
4436                renderExternal: null,
4437                renderExternalUpdate: true,
4438                addSlidesBefore: 0,
4439                addSlidesAfter: 0
4440            }
4441        });
4442        let cssModeTimeout;
4443        const document = getDocument();
4444        swiper.virtual = {
4445            cache: {},
4446            from: undefined,
4447            to: undefined,
4448            slides: [],
4449            offset: 0,
4450            slidesGrid: []
4451        };
4452        const tempDOM = document.createElement('div');
4453        function renderSlide(slide, index) {
4454            const params = swiper.params.virtual;
4455            if (params.cache && swiper.virtual.cache[index]) {
4456                return swiper.virtual.cache[index];
4457            }
4458            // eslint-disable-next-line
4459            let slideEl;
4460            if (params.renderSlide) {
4461                slideEl = params.renderSlide.call(swiper, slide, index);
4462                if (typeof slideEl === 'string') {
4463                    tempDOM.innerHTML = slideEl;
4464                    slideEl = tempDOM.children[0];
4465                }
4466            } else if (swiper.isElement) {
4467                slideEl = createElement('swiper-slide');
4468            } else {
4469                slideEl = createElement('div', swiper.params.slideClass);
4470            }
4471            slideEl.setAttribute('data-swiper-slide-index', index);
4472            if (!params.renderSlide) {
4473                slideEl.innerHTML = slide;
4474            }
4475            if (params.cache) {
4476                swiper.virtual.cache[index] = slideEl;
4477            }
4478            return slideEl;
4479        }
4480        function update(force, beforeInit, forceActiveIndex) {
4481            const {
4482                slidesPerView,
4483                slidesPerGroup,
4484                centeredSlides,
4485                loop: isLoop,
4486                initialSlide
4487            } = swiper.params;
4488            if (beforeInit && !isLoop && initialSlide > 0) {
4489                return;
4490            }
4491            const {
4492                addSlidesBefore,
4493                addSlidesAfter
4494            } = swiper.params.virtual;
4495            const {
4496                from: previousFrom,
4497                to: previousTo,
4498                slides,
4499                slidesGrid: previousSlidesGrid,
4500                offset: previousOffset
4501            } = swiper.virtual;
4502            if (!swiper.params.cssMode) {
4503                swiper.updateActiveIndex();
4504            }
4505            const activeIndex = typeof forceActiveIndex === 'undefined' ? swiper.activeIndex || 0 : forceActiveIndex;
4506            let offsetProp;
4507            if (swiper.rtlTranslate) offsetProp = 'right';else offsetProp = swiper.isHorizontal() ? 'left' : 'top';
4508            let slidesAfter;
4509            let slidesBefore;
4510            if (centeredSlides) {
4511                slidesAfter = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesAfter;
4512                slidesBefore = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesBefore;
4513            } else {
4514                slidesAfter = slidesPerView + (slidesPerGroup - 1) + addSlidesAfter;
4515                slidesBefore = (isLoop ? slidesPerView : slidesPerGroup) + addSlidesBefore;
4516            }
4517            let from = activeIndex - slidesBefore;
4518            let to = activeIndex + slidesAfter;
4519            if (!isLoop) {
4520                from = Math.max(from, 0);
4521                to = Math.min(to, slides.length - 1);
4522            }
4523            let offset = (swiper.slidesGrid[from] || 0) - (swiper.slidesGrid[0] || 0);
4524            if (isLoop && activeIndex >= slidesBefore) {
4525                from -= slidesBefore;
4526                if (!centeredSlides) offset += swiper.slidesGrid[0];
4527            } else if (isLoop && activeIndex < slidesBefore) {
4528                from = -slidesBefore;
4529                if (centeredSlides) offset += swiper.slidesGrid[0];
4530            }
4531            Object.assign(swiper.virtual, {
4532                from,
4533                to,
4534                offset,
4535                slidesGrid: swiper.slidesGrid,
4536                slidesBefore,
4537                slidesAfter
4538            });
4539            function onRendered() {
4540                swiper.updateSlides();
4541                swiper.updateProgress();
4542                swiper.updateSlidesClasses();
4543                emit('virtualUpdate');
4544            }
4545            if (previousFrom === from && previousTo === to && !force) {
4546                if (swiper.slidesGrid !== previousSlidesGrid && offset !== previousOffset) {

vendor: 1,727 bytes, lines 4547-4588

4547                    swiper.slides.forEach(slideEl => {
4548                        slideEl.style[offsetProp] = `${offset - Math.abs(swiper.cssOverflowAdjustment())}px`;
4549                    });
4550                }
4551                swiper.updateProgress();
4552                emit('virtualUpdate');
4553                return;
4554            }
4555            if (swiper.params.virtual.renderExternal) {
4556                swiper.params.virtual.renderExternal.call(swiper, {
4557                    offset,
4558                    from,
4559                    to,
4560                    slides: function getSlides() {
4561                        const slidesToRender = [];
4562                        for (let i = from; i <= to; i += 1) {
4563                            slidesToRender.push(slides[i]);
4564                        }
4565                        return slidesToRender;
4566                    }()
4567                });
4568                if (swiper.params.virtual.renderExternalUpdate) {
4569                    onRendered();
4570                } else {
4571                    emit('virtualUpdate');
4572                }
4573                return;
4574            }
4575            const prependIndexes = [];
4576            const appendIndexes = [];
4577            const getSlideIndex = index => {
4578                let slideIndex = index;
4579                if (index < 0) {
4580                    slideIndex = slides.length + index;
4581                } else if (slideIndex >= slides.length) {
4582                    // eslint-disable-next-line
4583                    slideIndex = slideIndex - slides.length;
4584                }
4585                return slideIndex;
4586            };
4587            if (force) {
4588                swiper.slides.filter(el => el.matches(`.${swiper.params.slideClass}

4588, swiper-slide`)).forEach(slideEl => {
4589                    slideEl.remove();
4590                });
4591            } else {
4592                for (let i = previousFrom; i <= previousTo; i += 1) {
4593                    if (i < from || i > to) {
4594                        const slideIndex = getSlideIndex(i);
4595                        swiper.slides.filter(el => el.matches(`.${swiper.params.slideClass}[data-swiper-slide-index="${slideIndex}"], swiper-slide[data-swiper-slide-index="${slideIndex}"]`)).forEach(slideEl => {
4596                            slideEl.remove();
4597                        });
4598                    }
4599                }
4600            }
4601            const loopFrom = isLoop ? -slides.length : 0;
4602            const loopTo = isLoop ? slides.length * 2 : slides.length;
4603            for (let i = loopFrom; i < loopTo; i += 1) {
4604                if (i >= from && i <= to) {
4605                    const slideIndex = getSlideIndex(i);
4606                    if (typeof previousTo === 'undefined' || force) {
4607                        appendIndexes.push(slideIndex);
4608                    } else {
4609                        if (i > previousTo) appendIndexes.push(slideIndex);
4610                        if (i < previousFrom) prependIndexes.push(slideIndex);
4611                    }
4612                }
4613            }
4614            appendIndexes.forEach(index => {
4615                swiper.slidesEl.append(renderSlide(slides[index], index));
4616            });
4617            if (isLoop) {
4618                for (let i = prependIndexes.length - 1; i >= 0; i -= 1) {
4619                    const index = prependIndexes[i];
4620                    swiper.slidesEl.prepend(renderSlide(slides[index], index));
4621                }
4622            } else {
4623                prependIndexes.sort((a, b) => b - a);
4624                prependIndexes.forEach(index => {
4625                    swiper.slidesEl.prepend(renderSlide(slides[index], index));
4626                });
4627            }
4628            elementChildren(swiper.slidesEl, '.swiper-slide, swiper-slide').forEach(sli

vendor: 4,834 bytes, lines 4628-4726

4628deEl => {
4629                slideEl.style[offsetProp] = `${offset - Math.abs(swiper.cssOverflowAdjustment())}px`;
4630            });
4631            onRendered();
4632        }
4633        function appendSlide(slides) {
4634            if (typeof slides === 'object' && 'length' in slides) {
4635                for (let i = 0; i < slides.length; i += 1) {
4636                    if (slides[i]) swiper.virtual.slides.push(slides[i]);
4637                }
4638            } else {
4639                swiper.virtual.slides.push(slides);
4640            }
4641            update(true);
4642        }
4643        function prependSlide(slides) {
4644            const activeIndex = swiper.activeIndex;
4645            let newActiveIndex = activeIndex + 1;
4646            let numberOfNewSlides = 1;
4647            if (Array.isArray(slides)) {
4648                for (let i = 0; i < slides.length; i += 1) {
4649                    if (slides[i]) swiper.virtual.slides.unshift(slides[i]);
4650                }
4651                newActiveIndex = activeIndex + slides.length;
4652                numberOfNewSlides = slides.length;
4653            } else {
4654                swiper.virtual.slides.unshift(slides);
4655            }
4656            if (swiper.params.virtual.cache) {
4657                const cache = swiper.virtual.cache;
4658                const newCache = {};
4659                Object.keys(cache).forEach(cachedIndex => {
4660                    const cachedEl = cache[cachedIndex];
4661                    const cachedElIndex = cachedEl.getAttribute('data-swiper-slide-index');
4662                    if (cachedElIndex) {
4663                        cachedEl.setAttribute('data-swiper-slide-index', parseInt(cachedElIndex, 10) + numberOfNewSlides);
4664                    }
4665                    newCache[parseInt(cachedIndex, 10) + numberOfNewSlides] = cachedEl;
4666                });
4667                swiper.virtual.cache = newCache;
4668            }
4669            update(true);
4670            swiper.slideTo(newActiveIndex, 0);
4671        }
4672        function removeSlide(slidesIndexes) {
4673            if (typeof slidesIndexes === 'undefined' || slidesIndexes === null) return;
4674            let activeIndex = swiper.activeIndex;
4675            if (Array.isArray(slidesIndexes)) {
4676                for (let i = slidesIndexes.length - 1; i >= 0; i -= 1) {
4677                    if (swiper.params.virtual.cache) {
4678                        delete swiper.virtual.cache[slidesIndexes[i]];
4679                        // shift cache indexes
4680                        Object.keys(swiper.virtual.cache).forEach(key => {
4681                            if (key > slidesIndexes) {
4682                                swiper.virtual.cache[key - 1] = swiper.virtual.cache[key];
4683                                swiper.virtual.cache[key - 1].setAttribute('data-swiper-slide-index', key - 1);
4684                                delete swiper.virtual.cache[key];
4685                            }
4686                        });
4687                    }
4688                    swiper.virtual.slides.splice(slidesIndexes[i], 1);
4689                    if (slidesIndexes[i] < activeIndex) activeIndex -= 1;
4690                    activeIndex = Math.max(activeIndex, 0);
4691                }
4692            } else {
4693                if (swiper.params.virtual.cache) {
4694                    delete swiper.virtual.cache[slidesIndexes];
4695                    // shift cache indexes
4696                    Object.keys(swiper.virtual.cache).forEach(key => {
4697                        if (key > slidesIndexes) {
4698                            swiper.virtual.cache[key - 1] = swiper.virtual.cache[key];
4699                            swiper.virtual.cache[key - 1].setAttribute('data-swiper-slide-index', key - 1);
4700                            delete swiper.virtual.cache[key];
4701                        }
4702                    });
4703                }
4704                swiper.virtual.slides.splice(slidesIndexes, 1);
4705                if (slidesIndexes < activeIndex) activeIndex -= 1;
4706                activeIndex = Math.max(activeIndex, 0);
4707            }
4708            update(true);
4709            swiper.slideTo(activeIndex, 0);
4710        }
4711        function removeAllSlides() {
4712            swiper.virtual.slides = [];
4713            if (swiper.params.virtual.cache) {
4714                swiper.virtual.cache = {};
4715            }
4716            update(true);
4717            swiper.slideTo(0, 0);
4718        }
4719        on('beforeInit', () => {
4720            if (!swiper.params.virtual.enabled) return;
4721            let domSlidesAssigned;
4722            if (typeof swiper.passedParams.virtual.slides === 'undefined') {
4723                const slides = [...swiper.slidesEl.children].filter(el => el.matches(`.${swiper.params.slideClass}, swiper-slide`));
4724                if (slides && slides.length) {
4725                    swiper.virtual.slides = [...slides];
4726                    domSlidesAssigned = true;

vendor: 42,810 bytes, lines 4727-5662

4727                    slides.forEach((slideEl, slideIndex) => {
4728                        slideEl.setAttribute('data-swiper-slide-index', slideIndex);
4729                        swiper.virtual.cache[slideIndex] = slideEl;
4730                        slideEl.remove();
4731                    });
4732                }
4733            }
4734            if (!domSlidesAssigned) {
4735                swiper.virtual.slides = swiper.params.virtual.slides;
4736            }
4737            swiper.classNames.push(`${swiper.params.containerModifierClass}virtual`);
4738            swiper.params.watchSlidesProgress = true;
4739            swiper.originalParams.watchSlidesProgress = true;
4740            update(false, true);
4741        });
4742        on('setTranslate', () => {
4743            if (!swiper.params.virtual.enabled) return;
4744            if (swiper.params.cssMode && !swiper._immediateVirtual) {
4745                clearTimeout(cssModeTimeout);
4746                cssModeTimeout = setTimeout(() => {
4747                    update();
4748                }, 100);
4749            } else {
4750                update();
4751            }
4752        });
4753        on('init update resize', () => {
4754            if (!swiper.params.virtual.enabled) return;
4755            if (swiper.params.cssMode) {
4756                setCSSProperty(swiper.wrapperEl, '--swiper-virtual-size', `${swiper.virtualSize}px`);
4757            }
4758        });
4759        Object.assign(swiper.virtual, {
4760            appendSlide,
4761            prependSlide,
4762            removeSlide,
4763            removeAllSlides,
4764            update
4765        });
4766    }
4767
4768    /* eslint-disable consistent-return */
4769    function Keyboard(_ref) {
4770        let {
4771            swiper,
4772            extendParams,
4773            on,
4774            emit
4775        } = _ref;
4776        const document = getDocument();
4777        const window = getWindow();
4778        swiper.keyboard = {
4779            enabled: false
4780        };
4781        extendParams({
4782            keyboard: {
4783                enabled: false,
4784                onlyInViewport: true,
4785                pageUpDown: true
4786            }
4787        });
4788        function handle(event) {
4789            if (!swiper.enabled) return;
4790            const {
4791                rtlTranslate: rtl
4792            } = swiper;
4793            let e = event;
4794            if (e.originalEvent) e = e.originalEvent; // jquery fix
4795            const kc = e.keyCode || e.charCode;
4796            const pageUpDown = swiper.params.keyboard.pageUpDown;
4797            const isPageUp = pageUpDown && kc === 33;
4798            const isPageDown = pageUpDown && kc === 34;
4799            const isArrowLeft = kc === 37;
4800            const isArrowRight = kc === 39;
4801            const isArrowUp = kc === 38;
4802            const isArrowDown = kc === 40;
4803            // Directions locks
4804            if (!swiper.allowSlideNext && (swiper.isHorizontal() && isArrowRight || swiper.isVertical() && isArrowDown || isPageDown)) {
4805                return false;
4806            }
4807            if (!swiper.allowSlidePrev && (swiper.isHorizontal() && isArrowLeft || swiper.isVertical() && isArrowUp || isPageUp)) {
4808                return false;
4809            }
4810            if (e.shiftKey || e.altKey || e.ctrlKey || e.metaKey) {
4811                return undefined;
4812            }
4813            if (document.activeElement && document.activeElement.nodeName && (document.activeElement.nodeName.toLowerCase() === 'input' || document.activeElement.nodeName.toLowerCase() === 'textarea')) {
4814                return undefined;
4815            }
4816            if (swiper.params.keyboard.onlyInViewport && (isPageUp || isPageDown || isArrowLeft || isArrowRight || isArrowUp || isArrowDown)) {
4817                let inView = false;
4818                // Check that swiper should be inside of visible area of window
4819                if (elementParents(swiper.el, `.${swiper.params.slideClass}, swiper-slide`).length > 0 && elementParents(swiper.el, `.${swiper.params.slideActiveClass}`).length === 0) {
4820                    return undefined;
4821                }
4822                const el = swiper.el;
4823                const swiperWidth = el.clientWidth;
4824                const swiperHeight = el.clientHeight;
4825                const windowWidth = window.innerWidth;
4826                const windowHeight = window.innerHeight;
4827                const swiperOffset = elementOffset(el);
4828                if (rtl) swiperOffset.left -= el.scrollLeft;
4829                const swiperCoord = [[swiperOffset.left, swiperOffset.top], [swiperOffset.left + swiperWidth, swiperOffset.top], [swiperOffset.left, swiperOffset.top + swiperHeight], [swiperOffset.left + swiperWidth, swiperOffset.top + swiperHeight]];
4830                for (let i = 0; i < swiperCoord.length; i += 1) {
4831                    const point = swiperCoord[i];
4832                    if (point[0] >= 0 && point[0] <= windowWidth && point[1] >= 0 && point[1] <= windowHeight) {
4833                        if (point[0] === 0 && point[1] === 0) continue; // eslint-disable-line
4834                        inView = true;
4835                    }
4836                }
4837                if (!inView) return undefined;
4838            }
4839            if (swiper.isHorizontal()) {
4840                if (isPageUp || isPageDown || isArrowLeft || isArrowRight) {
4841                    if (e.preventDefault) e.preventDefault();else e.returnValue = false;
4842                }
4843                if ((isPageDown || isArrowRight) && !rtl || (isPageUp || isArrowLeft) && rtl) swiper.slideNext();
4844                if ((isPageUp || isArrowLeft) && !rtl || (isPageDown || isArrowRight) && rtl) swiper.slidePrev();
4845            } else {
4846                if (isPageUp || isPageDown || isArrowUp || isArrowDown) {
4847                    if (e.preventDefault) e.preventDefault();else e.returnValue = false;
4848                }
4849                if (isPageDown || isArrowDown) swiper.slideNext();
4850                if (isPageUp || isArrowUp) swiper.slidePrev();
4851            }
4852            emit('keyPress', kc);
4853            return undefined;
4854        }
4855        function enable() {
4856            if (swiper.keyboard.enabled) return;
4857            document.addEventListener('keydown', handle);
4858            swiper.keyboard.enabled = true;
4859        }
4860        function disable() {
4861            if (!swiper.keyboard.enabled) return;
4862            document.removeEventListener('keydown', handle);
4863            swiper.keyboard.enabled = false;
4864        }
4865        on('init', () => {
4866            if (swiper.params.keyboard.enabled) {
4867                enable();
4868            }
4869        });
4870        on('destroy', () => {
4871            if (swiper.keyboard.enabled) {
4872                disable();
4873            }
4874        });
4875        Object.assign(swiper.keyboard, {
4876            enable,
4877            disable
4878        });
4879    }
4880
4881    /* eslint-disable consistent-return */
4882    function Mousewheel(_ref) {
4883        let {
4884            swiper,
4885            extendParams,
4886            on,
4887            emit
4888        } = _ref;
4889        const window = getWindow();
4890        extendParams({
4891            mousewheel: {
4892                enabled: false,
4893                releaseOnEdges: false,
4894                invert: false,
4895                forceToAxis: false,
4896                sensitivity: 1,
4897                eventsTarget: 'container',
4898                thresholdDelta: null,
4899                thresholdTime: null,
4900                noMousewheelClass: 'swiper-no-mousewheel'
4901            }
4902        });
4903        swiper.mousewheel = {
4904            enabled: false
4905        };
4906        let timeout;
4907        let lastScrollTime = now();
4908        let lastEventBeforeSnap;
4909        const recentWheelEvents = [];
4910        function normalize(e) {
4911            // Reasonable defaults
4912            const PIXEL_STEP = 10;
4913            const LINE_HEIGHT = 40;
4914            const PAGE_HEIGHT = 800;
4915            let sX = 0;
4916            let sY = 0; // spinX, spinY
4917            let pX = 0;
4918            let pY = 0; // pixelX, pixelY
4919
4920            // Legacy
4921            if ('detail' in e) {
4922                sY = e.detail;
4923            }
4924            if ('wheelDelta' in e) {
4925                sY = -e.wheelDelta / 120;
4926            }
4927            if ('wheelDeltaY' in e) {
4928                sY = -e.wheelDeltaY / 120;
4929            }
4930            if ('wheelDeltaX' in e) {
4931                sX = -e.wheelDeltaX / 120;
4932            }
4933
4934            // side scrolling on FF with DOMMouseScroll
4935            if ('axis' in e && e.axis === e.HORIZONTAL_AXIS) {
4936                sX = sY;
4937                sY = 0;
4938            }
4939            pX = sX * PIXEL_STEP;
4940            pY = sY * PIXEL_STEP;
4941            if ('deltaY' in e) {
4942                pY = e.deltaY;
4943            }
4944            if ('deltaX' in e) {
4945                pX = e.deltaX;
4946            }
4947            if (e.shiftKey && !pX) {
4948                // if user scrolls with shift he wants horizontal scroll
4949                pX = pY;
4950                pY = 0;
4951            }
4952            if ((pX || pY) && e.deltaMode) {
4953                if (e.deltaMode === 1) {
4954                    // delta in LINE units
4955                    pX *= LINE_HEIGHT;
4956                    pY *= LINE_HEIGHT;
4957                } else {
4958                    // delta in PAGE units
4959                    pX *= PAGE_HEIGHT;
4960                    pY *= PAGE_HEIGHT;
4961                }
4962            }
4963
4964            // Fall-back if spin cannot be determined
4965            if (pX && !sX) {
4966                sX = pX < 1 ? -1 : 1;
4967            }
4968            if (pY && !sY) {
4969                sY = pY < 1 ? -1 : 1;
4970            }
4971            return {
4972                spinX: sX,
4973                spinY: sY,
4974                pixelX: pX,
4975                pixelY: pY
4976            };
4977        }
4978        function handleMouseEnter() {
4979            if (!swiper.enabled) return;
4980            swiper.mouseEntered = true;
4981        }
4982        function handleMouseLeave() {
4983            if (!swiper.enabled) return;
4984            swiper.mouseEntered = false;
4985        }
4986        function animateSlider(newEvent) {
4987            if (swiper.params.mousewheel.thresholdDelta && newEvent.delta < swiper.params.mousewheel.thresholdDelta) {
4988                // Prevent if delta of wheel scroll delta is below configured threshold
4989                return false;
4990            }
4991            if (swiper.params.mousewheel.thresholdTime && now() - lastScrollTime < swiper.params.mousewheel.thresholdTime) {
4992                // Prevent if time between scrolls is below configured threshold
4993                return false;
4994            }
4995
4996            // If the movement is NOT big enough and
4997            // if the last time the user scrolled was too close to the current one (avoid continuously triggering the slider):
4998            //   Don't go any further (avoid insignificant scroll movement).
4999            if (newEvent.delta >= 6 && now() - lastScrollTime < 60) {
5000                // Return false as a default
5001                return true;
5002            }
5003            // If user is scrolling towards the end:
5004            //   If the slider hasn't hit the latest slide or
5005            //   if the slider is a loop and
5006            //   if the slider isn't moving right now:
5007            //     Go to next slide and
5008            //     emit a scroll event.
5009            // Else (the user is scrolling towards the beginning) and
5010            // if the slider hasn't hit the first slide or
5011            // if the slider is a loop and
5012            // if the slider isn't moving right now:
5013            //   Go to prev slide and
5014            //   emit a scroll event.
5015            if (newEvent.direction < 0) {
5016                if ((!swiper.isEnd || swiper.params.loop) && !swiper.animating) {
5017                    swiper.slideNext();
5018                    emit('scroll', newEvent.raw);
5019                }
5020            } else if ((!swiper.isBeginning || swiper.params.loop) && !swiper.animating) {
5021                swiper.slidePrev();
5022                emit('scroll', newEvent.raw);
5023            }
5024            // If you got here is because an animation has been triggered so store the current time
5025            lastScrollTime = new window.Date().getTime();
5026            // Return false as a default
5027            return false;
5028        }
5029        function releaseScroll(newEvent) {
5030            const params = swiper.params.mousewheel;
5031            if (newEvent.direction < 0) {
5032                if (swiper.isEnd && !swiper.params.loop && params.releaseOnEdges) {
5033                    // Return true to animate scroll on edges
5034                    return true;
5035                }
5036            } else if (swiper.isBeginning && !swiper.params.loop && params.releaseOnEdges) {
5037                // Return true to animate scroll on edges
5038                return true;
5039            }
5040            return false;
5041        }
5042        function handle(event) {
5043            let e = event;
5044            let disableParentSwiper = true;
5045            if (!swiper.enabled) return;
5046
5047            // Ignore event if the target or its parents have the swiper-no-mousewheel class
5048            if (event.target.closest(`.${swiper.params.mousewheel.noMousewheelClass}`)) return;
5049            const params = swiper.params.mousewheel;
5050            if (swiper.params.cssMode) {
5051                e.preventDefault();
5052            }
5053            let targetEl = swiper.el;
5054            if (swiper.params.mousewheel.eventsTarget !== 'container') {
5055                targetEl = document.querySelector(swiper.params.mousewheel.eventsTarget);
5056            }
5057            const targetElContainsTarget = targetEl && targetEl.contains(e.target);
5058            if (!swiper.mouseEntered && !targetElContainsTarget && !params.releaseOnEdges) return true;
5059            if (e.originalEvent) e = e.originalEvent; // jquery fix
5060            let delta = 0;
5061            const rtlFactor = swiper.rtlTranslate ? -1 : 1;
5062            const data = normalize(e);
5063            if (params.forceToAxis) {
5064                if (swiper.isHorizontal()) {
5065                    if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = -data.pixelX * rtlFactor;else return true;
5066                } else if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = -data.pixelY;else return true;
5067            } else {
5068                delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? -data.pixelX * rtlFactor : -data.pixelY;
5069            }
5070            if (delta === 0) return true;
5071            if (params.invert) delta = -delta;
5072
5073            // Get the scroll positions
5074            let positions = swiper.getTranslate() + delta * params.sensitivity;
5075            if (positions >= swiper.minTranslate()) positions = swiper.minTranslate();
5076            if (positions <= swiper.maxTranslate()) positions = swiper.maxTranslate();
5077
5078            // When loop is true:
5079            //     the disableParentSwiper will be true.
5080            // When loop is false:
5081            //     if the scroll positions is not on edge,
5082            //     then the disableParentSwiper will be true.
5083            //     if the scroll on edge positions,
5084            //     then the disableParentSwiper will be false.
5085            disableParentSwiper = swiper.params.loop ? true : !(positions === swiper.minTranslate() || positions === swiper.maxTranslate());
5086            if (disableParentSwiper && swiper.params.nested) e.stopPropagation();
5087            if (!swiper.params.freeMode || !swiper.params.freeMode.enabled) {
5088                // Register the new event in a variable which stores the relevant data
5089                const newEvent = {
5090                    time: now(),
5091                    delta: Math.abs(delta),
5092                    direction: Math.sign(delta),
5093                    raw: event
5094                };
5095
5096                // Keep the most recent events
5097                if (recentWheelEvents.length >= 2) {
5098                    recentWheelEvents.shift(); // only store the last N events
5099                }
5100
5101                const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;
5102                recentWheelEvents.push(newEvent);
5103
5104                // If there is at least one previous recorded event:
5105                //   If direction has changed or
5106                //   if the scroll is quicker than the previous one:
5107                //     Animate the slider.
5108                // Else (this is the first time the wheel is moved):
5109                //     Animate the slider.
5110                if (prevEvent) {
5111                    if (newEvent.direction !== prevEvent.direction || newEvent.delta > prevEvent.delta || newEvent.time > prevEvent.time + 150) {
5112                        animateSlider(newEvent);
5113                    }
5114                } else {
5115                    animateSlider(newEvent);
5116                }
5117
5118                // If it's time to release the scroll:
5119                //   Return now so you don't hit the preventDefault.
5120                if (releaseScroll(newEvent)) {
5121                    return true;
5122                }
5123            } else {
5124                // Freemode or scrollContainer:
5125
5126                // If we recently snapped after a momentum scroll, then ignore wheel events
5127                // to give time for the deceleration to finish. Stop ignoring after 500 msecs
5128                // or if it's a new scroll (larger delta or inverse sign as last event before
5129                // an end-of-momentum snap).
5130                const newEvent = {
5131                    time: now(),
5132                    delta: Math.abs(delta),
5133                    direction: Math.sign(delta)
5134                };
5135                const ignoreWheelEvents = lastEventBeforeSnap && newEvent.time < lastEventBeforeSnap.time + 500 && newEvent.delta <= lastEventBeforeSnap.delta && newEvent.direction === lastEventBeforeSnap.direction;
5136                if (!ignoreWheelEvents) {
5137                    lastEventBeforeSnap = undefined;
5138                    let position = swiper.getTranslate() + delta * params.sensitivity;
5139                    const wasBeginning = swiper.isBeginning;
5140                    const wasEnd = swiper.isEnd;
5141                    if (position >= swiper.minTranslate()) position = swiper.minTranslate();
5142                    if (position <= swiper.maxTranslate()) position = swiper.maxTranslate();
5143                    swiper.setTransition(0);
5144                    swiper.setTranslate(position);
5145                    swiper.updateProgress();
5146                    swiper.updateActiveIndex();
5147                    swiper.updateSlidesClasses();
5148                    if (!wasBeginning && swiper.isBeginning || !wasEnd && swiper.isEnd) {
5149                        swiper.updateSlidesClasses();
5150                    }
5151                    if (swiper.params.loop) {
5152                        swiper.loopFix({
5153                            direction: newEvent.direction < 0 ? 'next' : 'prev',
5154                            byMousewheel: true
5155                        });
5156                    }
5157                    if (swiper.params.freeMode.sticky) {
5158                        // When wheel scrolling starts with sticky (aka snap) enabled, then detect
5159                        // the end of a momentum scroll by storing recent (N=15?) wheel events.
5160                        // 1. do all N events have decreasing or same (absolute value) delta?
5161                        // 2. did all N events arrive in the last M (M=500?) msecs?
5162                        // 3. does the earliest event have an (absolute value) delta that's
5163                        //    at least P (P=1?) larger than the most recent event's delta?
5164                        // 4. does the latest event have a delta that's smaller than Q (Q=6?) pixels?
5165                        // If 1-4 are "yes" then we're near the end of a momentum scroll deceleration.
5166                        // Snap immediately and ignore remaining wheel events in this scroll.
5167                        // See comment above for "remaining wheel events in this scroll" determination.
5168                        // If 1-4 aren't satisfied, then wait to snap until 500ms after the last event.
5169                        clearTimeout(timeout);
5170                        timeout = undefined;
5171                        if (recentWheelEvents.length >= 15) {
5172                            recentWheelEvents.shift(); // only store the last N events
5173                        }
5174
5175                        const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;
5176                        const firstEvent = recentWheelEvents[0];
5177                        recentWheelEvents.push(newEvent);
5178                        if (prevEvent && (newEvent.delta > prevEvent.delta || newEvent.direction !== prevEvent.direction)) {
5179                            // Increasing or reverse-sign delta means the user started scrolling again. Clear the wheel event log.
5180                            recentWheelEvents.splice(0);
5181                        } else if (recentWheelEvents.length >= 15 && newEvent.time - firstEvent.time < 500 && firstEvent.delta - newEvent.delta >= 1 && newEvent.delta <= 6) {
5182                            // We're at the end of the deceleration of a momentum scroll, so there's no need
5183                            // to wait for more events. Snap ASAP on the next tick.
5184                            // Also, because there's some remaining momentum we'll bias the snap in the
5185                            // direction of the ongoing scroll because it's better UX for the scroll to snap
5186                            // in the same direction as the scroll instead of reversing to snap.  Therefore,
5187                            // if it's already scrolled more than 20% in the current direction, keep going.
5188                            const snapToThreshold = delta > 0 ? 0.8 : 0.2;
5189                            lastEventBeforeSnap = newEvent;
5190                            recentWheelEvents.splice(0);
5191                            timeout = nextTick(() => {
5192                                if (swiper.destroyed || !swiper.params) return;
5193                                swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);
5194                            }, 0); // no delay; move on next tick
5195                        }
5196
5197                        if (!timeout) {
5198                            // if we get here, then we haven't detected the end of a momentum scroll, so
5199                            // we'll consider a scroll "complete" when there haven't been any wheel events
5200                            // for 500ms.
5201                            timeout = nextTick(() => {
5202                                if (swiper.destroyed || !swiper.params) return;
5203                                const snapToThreshold = 0.5;
5204                                lastEventBeforeSnap = newEvent;
5205                                recentWheelEvents.splice(0);
5206                                swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);
5207                            }, 500);
5208                        }
5209                    }
5210
5211                    // Emit event
5212                    if (!ignoreWheelEvents) emit('scroll', e);
5213
5214                    // Stop autoplay
5215                    if (swiper.params.autoplay && swiper.params.autoplay.disableOnInteraction) swiper.autoplay.stop();
5216                    // Return page scroll on edge positions
5217                    if (params.releaseOnEdges && (position === swiper.minTranslate() || position === swiper.maxTranslate())) {
5218                        return true;
5219                    }
5220                }
5221            }
5222            if (e.preventDefault) e.preventDefault();else e.returnValue = false;
5223            return false;
5224        }
5225        function events(method) {
5226            let targetEl = swiper.el;
5227            if (swiper.params.mousewheel.eventsTarget !== 'container') {
5228                targetEl = document.querySelector(swiper.params.mousewheel.eventsTarget);
5229            }
5230            targetEl[method]('mouseenter', handleMouseEnter);
5231            targetEl[method]('mouseleave', handleMouseLeave);
5232            targetEl[method]('wheel', handle);
5233        }
5234        function enable() {
5235            if (swiper.params.cssMode) {
5236                swiper.wrapperEl.removeEventListener('wheel', handle);
5237                return true;
5238            }
5239            if (swiper.mousewheel.enabled) return false;
5240            events('addEventListener');
5241            swiper.mousewheel.enabled = true;
5242            return true;
5243        }
5244        function disable() {
5245            if (swiper.params.cssMode) {
5246                swiper.wrapperEl.addEventListener(event, handle);
5247                return true;
5248            }
5249            if (!swiper.mousewheel.enabled) return false;
5250            events('removeEventListener');
5251            swiper.mousewheel.enabled = false;
5252            return true;
5253        }
5254        on('init', () => {
5255            if (!swiper.params.mousewheel.enabled && swiper.params.cssMode) {
5256                disable();
5257            }
5258            if (swiper.params.mousewheel.enabled) enable();
5259        });
5260        on('destroy', () => {
5261            if (swiper.params.cssMode) {
5262                enable();
5263            }
5264            if (swiper.mousewheel.enabled) disable();
5265        });
5266        Object.assign(swiper.mousewheel, {
5267            enable,
5268            disable
5269        });
5270    }
5271
5272    function createElementIfNotDefined(swiper, originalParams, params, checkProps) {
5273        if (swiper.params.createElements) {
5274            Object.keys(checkProps).forEach(key => {
5275                if (!params[key] && params.auto === true) {
5276                    let element = elementChildren(swiper.el, `.${checkProps[key]}`)[0];
5277                    if (!element) {
5278                        element = createElement('div', checkProps[key]);
5279                        element.className = checkProps[key];
5280                        swiper.el.append(element);
5281                    }
5282                    params[key] = element;
5283                    originalParams[key] = element;
5284                }
5285            });
5286        }
5287        return params;
5288    }
5289
5290    function Navigation(_ref) {
5291        let {
5292            swiper,
5293            extendParams,
5294            on,
5295            emit
5296        } = _ref;
5297        extendParams({
5298            navigation: {
5299                nextEl: null,
5300                prevEl: null,
5301                hideOnClick: false,
5302                disabledClass: 'swiper-button-disabled',
5303                hiddenClass: 'swiper-button-hidden',
5304                lockClass: 'swiper-button-lock',
5305                navigationDisabledClass: 'swiper-navigation-disabled'
5306            }
5307        });
5308        swiper.navigation = {
5309            nextEl: null,
5310            prevEl: null
5311        };
5312        function getEl(el) {
5313            let res;
5314            if (el && typeof el === 'string' && swiper.isElement) {
5315                res = swiper.el.querySelector(el) || swiper.hostEl.querySelector(el);
5316                if (res) return res;
5317            }
5318            if (el) {
5319                if (typeof el === 'string') res = [...document.querySelectorAll(el)];
5320                if (swiper.params.uniqueNavElements && typeof el === 'string' && res && res.length > 1 && swiper.el.querySelectorAll(el).length === 1) {
5321                    res = swiper.el.querySelector(el);
5322                } else if (res && res.length === 1) {
5323                    res = res[0];
5324                }
5325            }
5326            if (el && !res) return el;
5327            // if (Array.isArray(res) && res.length === 1) res = res[0];
5328            return res;
5329        }
5330        function toggleEl(el, disabled) {
5331            const params = swiper.params.navigation;
5332            el = makeElementsArray(el);
5333            el.forEach(subEl => {
5334                if (subEl) {
5335                    subEl.classList[disabled ? 'add' : 'remove'](...params.disabledClass.split(' '));
5336                    if (subEl.tagName === 'BUTTON') subEl.disabled = disabled;
5337                    if (swiper.params.watchOverflow && swiper.enabled) {
5338                        subEl.classList[swiper.isLocked ? 'add' : 'remove'](params.lockClass);
5339                    }
5340                }
5341            });
5342        }
5343        function update() {
5344            // Update Navigation Buttons
5345            const {
5346                nextEl,
5347                prevEl
5348            } = swiper.navigation;
5349            if (swiper.params.loop) {
5350                toggleEl(prevEl, false);
5351                toggleEl(nextEl, false);
5352                return;
5353            }
5354            toggleEl(prevEl, swiper.isBeginning && !swiper.params.rewind);
5355            toggleEl(nextEl, swiper.isEnd && !swiper.params.rewind);
5356        }
5357        function onPrevClick(e) {
5358            e.preventDefault();
5359            if (swiper.isBeginning && !swiper.params.loop && !swiper.params.rewind) return;
5360            swiper.slidePrev();
5361            emit('navigationPrev');
5362        }
5363        function onNextClick(e) {
5364            e.preventDefault();
5365            if (swiper.isEnd && !swiper.params.loop && !swiper.params.rewind) return;
5366            swiper.slideNext();
5367            emit('navigationNext');
5368        }
5369        function init() {
5370            const params = swiper.params.navigation;
5371            swiper.params.navigation = createElementIfNotDefined(swiper, swiper.originalParams.navigation, swiper.params.navigation, {
5372                nextEl: 'swiper-button-next',
5373                prevEl: 'swiper-button-prev'
5374            });
5375            if (!(params.nextEl || params.prevEl)) return;
5376            let nextEl = getEl(params.nextEl);
5377            let prevEl = getEl(params.prevEl);
5378            Object.assign(swiper.navigation, {
5379                nextEl,
5380                prevEl
5381            });
5382            nextEl = makeElementsArray(nextEl);
5383            prevEl = makeElementsArray(prevEl);
5384            const initButton = (el, dir) => {
5385                if (el) {
5386                    el.addEventListener('click', dir === 'next' ? onNextClick : onPrevClick);
5387                }
5388                if (!swiper.enabled && el) {
5389                    el.classList.add(...params.lockClass.split(' '));
5390                }
5391            };
5392            nextEl.forEach(el => initButton(el, 'next'));
5393            prevEl.forEach(el => initButton(el, 'prev'));
5394        }
5395        function destroy() {
5396            let {
5397                nextEl,
5398                prevEl
5399            } = swiper.navigation;
5400            nextEl = makeElementsArray(nextEl);
5401            prevEl = makeElementsArray(prevEl);
5402            const destroyButton = (el, dir) => {
5403                el.removeEventListener('click', dir === 'next' ? onNextClick : onPrevClick);
5404                el.classList.remove(...swiper.params.navigation.disabledClass.split(' '));
5405            };
5406            nextEl.forEach(el => destroyButton(el, 'next'));
5407            prevEl.forEach(el => destroyButton(el, 'prev'));
5408        }
5409        on('init', () => {
5410            if (swiper.params.navigation.enabled === false) {
5411                // eslint-disable-next-line
5412                disable();
5413            } else {
5414                init();
5415                update();
5416            }
5417        });
5418        on('toEdge fromEdge lock unlock', () => {
5419            update();
5420        });
5421        on('destroy', () => {
5422            destroy();
5423        });
5424        on('enable disable', () => {
5425            let {
5426                nextEl,
5427                prevEl
5428            } = swiper.navigation;
5429            nextEl = makeElementsArray(nextEl);
5430            prevEl = makeElementsArray(prevEl);
5431            if (swiper.enabled) {
5432                update();
5433                return;
5434            }
5435            [...nextEl, ...prevEl].filter(el => !!el).forEach(el => el.classList.add(swiper.params.navigation.lockClass));
5436        });
5437        on('click', (_s, e) => {
5438            let {
5439                nextEl,
5440                prevEl
5441            } = swiper.navigation;
5442            nextEl = makeElementsArray(nextEl);
5443            prevEl = makeElementsArray(prevEl);
5444            const targetEl = e.target;
5445            let targetIsButton = prevEl.includes(targetEl) || nextEl.includes(targetEl);
5446            if (swiper.isElement && !targetIsButton) {
5447                const path = e.path || e.composedPath && e.composedPath();
5448                if (path) {
5449                    targetIsButton = path.find(pathEl => nextEl.includes(pathEl) || prevEl.includes(pathEl));
5450                }
5451            }
5452            if (swiper.params.navigation.hideOnClick && !targetIsButton) {
5453                if (swiper.pagination && swiper.params.pagination && swiper.params.pagination.clickable && (swiper.pagination.el === targetEl || swiper.pagination.el.contains(targetEl))) return;
5454                let isHidden;
5455                if (nextEl.length) {
5456                    isHidden = nextEl[0].classList.contains(swiper.params.navigation.hiddenClass);
5457                } else if (prevEl.length) {
5458                    isHidden = prevEl[0].classList.contains(swiper.params.navigation.hiddenClass);
5459                }
5460                if (isHidden === true) {
5461                    emit('navigationShow');
5462                } else {
5463                    emit('navigationHide');
5464                }
5465                [...nextEl, ...prevEl].filter(el => !!el).forEach(el => el.classList.toggle(swiper.params.navigation.hiddenClass));
5466            }
5467        });
5468        const enable = () => {
5469            swiper.el.classList.remove(...swiper.params.navigation.navigationDisabledClass.split(' '));
5470            init();
5471            update();
5472        };
5473        const disable = () => {
5474            swiper.el.classList.add(...swiper.params.navigation.navigationDisabledClass.split(' '));
5475            destroy();
5476        };
5477        Object.assign(swiper.navigation, {
5478            enable,
5479            disable,
5480            update,
5481            init,
5482            destroy
5483        });
5484    }
5485
5486    function classesToSelector(classes) {
5487        if (classes === void 0) {
5488            classes = '';
5489        }
5490        return `.${classes.trim().replace(/([\.:!+\/])/g, '\\$1') // eslint-disable-line
5491            .replace(/ /g, '.')}`;
5492    }
5493
5494    function Pagination(_ref) {
5495        let {
5496            swiper,
5497            extendParams,
5498            on,
5499            emit
5500        } = _ref;
5501        const pfx = 'swiper-pagination';
5502        extendParams({
5503            pagination: {
5504                el: null,
5505                bulletElement: 'span',
5506                clickable: false,
5507                hideOnClick: false,
5508                renderBullet: null,
5509                renderProgressbar: null,
5510                renderFraction: null,
5511                renderCustom: null,
5512                progressbarOpposite: false,
5513                type: 'bullets',
5514                // 'bullets' or 'progressbar' or 'fraction' or 'custom'
5515                dynamicBullets: false,
5516                dynamicMainBullets: 1,
5517                formatFractionCurrent: number => number,
5518                formatFractionTotal: number => number,
5519                bulletClass: `${pfx}-bullet`,
5520                bulletActiveClass: `${pfx}-bullet-active`,
5521                modifierClass: `${pfx}-`,
5522                currentClass: `${pfx}-current`,
5523                totalClass: `${pfx}-total`,
5524                hiddenClass: `${pfx}-hidden`,
5525                progressbarFillClass: `${pfx}-progressbar-fill`,
5526                progressbarOppositeClass: `${pfx}-progressbar-opposite`,
5527                clickableClass: `${pfx}-clickable`,
5528                lockClass: `${pfx}-lock`,
5529                horizontalClass: `${pfx}-horizontal`,
5530                verticalClass: `${pfx}-vertical`,
5531                paginationDisabledClass: `${pfx}-disabled`
5532            }
5533        });
5534        swiper.pagination = {
5535            el: null,
5536            bullets: []
5537        };
5538        let bulletSize;
5539        let dynamicBulletIndex = 0;
5540        function isPaginationDisabled() {
5541            return !swiper.params.pagination.el || !swiper.pagination.el || Array.isArray(swiper.pagination.el) && swiper.pagination.el.length === 0;
5542        }
5543        function setSideBullets(bulletEl, position) {
5544            const {
5545                bulletActiveClass
5546            } = swiper.params.pagination;
5547            if (!bulletEl) return;
5548            bulletEl = bulletEl[`${position === 'prev' ? 'previous' : 'next'}ElementSibling`];
5549            if (bulletEl) {
5550                bulletEl.classList.add(`${bulletActiveClass}-${position}`);
5551                bulletEl = bulletEl[`${position === 'prev' ? 'previous' : 'next'}ElementSibling`];
5552                if (bulletEl) {
5553                    bulletEl.classList.add(`${bulletActiveClass}-${position}-${position}`);
5554                }
5555            }
5556        }
5557        function getMoveDirection(prevIndex, nextIndex, length) {
5558            prevIndex = prevIndex % length;
5559            nextIndex = nextIndex % length;
5560            if (nextIndex === prevIndex + 1) {
5561                return 'next';
5562            } else if (nextIndex === prevIndex - 1) {
5563                return 'previous';
5564            }
5565            return;
5566        }
5567        function onBulletClick(e) {
5568            const bulletEl = e.target.closest(classesToSelector(swiper.params.pagination.bulletClass));
5569            if (!bulletEl) {
5570                return;
5571            }
5572            e.preventDefault();
5573            const index = elementIndex(bulletEl) * swiper.params.slidesPerGroup;
5574            if (swiper.params.loop) {
5575                if (swiper.realIndex === index) return;
5576                const moveDirection = getMoveDirection(swiper.realIndex, index, swiper.slides.length);
5577                if (moveDirection === 'next') {
5578                    swiper.slideNext();
5579                } else if (moveDirection === 'previous') {
5580                    swiper.slidePrev();
5581                } else {
5582                    swiper.slideToLoop(index);
5583                }
5584            } else {
5585                swiper.slideTo(index);
5586            }
5587        }
5588        function update() {
5589            // Render || Update Pagination bullets/items
5590            const rtl = swiper.rtl;
5591            const params = swiper.params.pagination;
5592            if (isPaginationDisabled()) return;
5593            let el = swiper.pagination.el;
5594            el = makeElementsArray(el);
5595            // Current/Total
5596            let current;
5597            let previousIndex;
5598            const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;
5599            const total = swiper.params.loop ? Math.ceil(slidesLength / swiper.params.slidesPerGroup) : swiper.snapGrid.length;
5600            if (swiper.params.loop) {
5601                previousIndex = swiper.previousRealIndex || 0;
5602                current = swiper.params.slidesPerGroup > 1 ? Math.floor(swiper.realIndex / swiper.params.slidesPerGroup) : swiper.realIndex;
5603            } else if (typeof swiper.snapIndex !== 'undefined') {
5604                current = swiper.snapIndex;
5605                previousIndex = swiper.previousSnapIndex;
5606            } else {
5607                previousIndex = swiper.previousIndex || 0;
5608                current = swiper.activeIndex || 0;
5609            }
5610            // Types
5611            if (params.type === 'bullets' && swiper.pagination.bullets && swiper.pagination.bullets.length > 0) {
5612                const bullets = swiper.pagination.bullets;
5613                let firstIndex;
5614                let lastIndex;
5615                let midIndex;
5616                if (params.dynamicBullets) {
5617                    bulletSize = elementOuterSize(bullets[0], swiper.isHorizontal() ? 'width' : 'height', true);
5618                    el.forEach(subEl => {
5619                        subEl.style[swiper.isHorizontal() ? 'width' : 'height'] = `${bulletSize * (params.dynamicMainBullets + 4)}px`;
5620                    });
5621                    if (params.dynamicMainBullets > 1 && previousIndex !== undefined) {
5622                        dynamicBulletIndex += current - (previousIndex || 0);
5623                        if (dynamicBulletIndex > params.dynamicMainBullets - 1) {
5624                            dynamicBulletIndex = params.dynamicMainBullets - 1;
5625                        } else if (dynamicBulletIndex < 0) {
5626                            dynamicBulletIndex = 0;
5627                        }
5628                    }
5629                    firstIndex = Math.max(current - dynamicBulletIndex, 0);
5630                    lastIndex = firstIndex + (Math.min(bullets.length, params.dynamicMainBullets) - 1);
5631                    midIndex = (lastIndex + firstIndex) / 2;
5632                }
5633                bullets.forEach(bulletEl => {
5634                    const classesToRemove = [...['', '-next', '-next-next', '-prev', '-prev-prev', '-main'].map(suffix => `${params.bulletActiveClass}${suffix}`)].map(s => typeof s === 'string' && s.includes(' ') ? s.split(' ') : s).flat();
5635                    bulletEl.classList.remove(...classesToRemove);
5636                });
5637                if (el.length > 1) {
5638                    bullets.forEach(bullet => {
5639                        const bulletIndex = elementIndex(bullet);
5640                        if (bulletIndex === current) {
5641                            bullet.classList.add(...params.bulletActiveClass.split(' '));
5642                        } else if (swiper.isElement) {
5643                            bullet.setAttribute('part', 'bullet');
5644                        }
5645                        if (params.dynamicBullets) {
5646                            if (bulletIndex >= firstIndex && bulletIndex <= lastIndex) {
5647                                bullet.classList.add(...`${params.bulletActiveClass}-main`.split(' '));
5648                            }
5649                            if (bulletIndex === firstIndex) {
5650                                setSideBullets(bullet, 'prev');
5651                            }
5652                            if (bulletIndex === lastIndex) {
5653                                setSideBullets(bullet, 'next');
5654                            }
5655                        }
5656                    });
5657                } else {
5658                    const bullet = bullets[current];
5659                    if (bullet) {
5660                        bullet.classList.add(...params.bulletActiveClass.split(' '));
5661                    }
5662                    if (swiper.isElement) {

vendor: 4,823 bytes, lines 5663-5744

5663                        bullets.forEach((bulletEl, bulletIndex) => {
5664                            bulletEl.setAttribute('part', bulletIndex === current ? 'bullet-active' : 'bullet');
5665                        });
5666                    }
5667                    if (params.dynamicBullets) {
5668                        const firstDisplayedBullet = bullets[firstIndex];
5669                        const lastDisplayedBullet = bullets[lastIndex];
5670                        for (let i = firstIndex; i <= lastIndex; i += 1) {
5671                            if (bullets[i]) {
5672                                bullets[i].classList.add(...`${params.bulletActiveClass}-main`.split(' '));
5673                            }
5674                        }
5675                        setSideBullets(firstDisplayedBullet, 'prev');
5676                        setSideBullets(lastDisplayedBullet, 'next');
5677                    }
5678                }
5679                if (params.dynamicBullets) {
5680                    const dynamicBulletsLength = Math.min(bullets.length, params.dynamicMainBullets + 4);
5681                    const bulletsOffset = (bulletSize * dynamicBulletsLength - bulletSize) / 2 - midIndex * bulletSize;
5682                    const offsetProp = rtl ? 'right' : 'left';
5683                    bullets.forEach(bullet => {
5684                        bullet.style[swiper.isHorizontal() ? offsetProp : 'top'] = `${bulletsOffset}px`;
5685                    });
5686                }
5687            }
5688            el.forEach((subEl, subElIndex) => {
5689                if (params.type === 'fraction') {
5690                    subEl.querySelectorAll(classesToSelector(params.currentClass)).forEach(fractionEl => {
5691                        fractionEl.textContent = params.formatFractionCurrent(current + 1);
5692                    });
5693                    subEl.querySelectorAll(classesToSelector(params.totalClass)).forEach(totalEl => {
5694                        totalEl.textContent = params.formatFractionTotal(total);
5695                    });
5696                }
5697                if (params.type === 'progressbar') {
5698                    let progressbarDirection;
5699                    if (params.progressbarOpposite) {
5700                        progressbarDirection = swiper.isHorizontal() ? 'vertical' : 'horizontal';
5701                    } else {
5702                        progressbarDirection = swiper.isHorizontal() ? 'horizontal' : 'vertical';
5703                    }
5704                    const scale = (current + 1) / total;
5705                    let scaleX = 1;
5706                    let scaleY = 1;
5707                    if (progressbarDirection === 'horizontal') {
5708                        scaleX = scale;
5709                    } else {
5710                        scaleY = scale;
5711                    }
5712                    subEl.querySelectorAll(classesToSelector(params.progressbarFillClass)).forEach(progressEl => {
5713                        progressEl.style.transform = `translate3d(0,0,0) scaleX(${scaleX}) scaleY(${scaleY})`;
5714                        progressEl.style.transitionDuration = `${swiper.params.speed}ms`;
5715                    });
5716                }
5717                if (params.type === 'custom' && params.renderCustom) {
5718                    subEl.innerHTML = params.renderCustom(swiper, current + 1, total);
5719                    if (subElIndex === 0) emit('paginationRender', subEl);
5720                } else {
5721                    if (subElIndex === 0) emit('paginationRender', subEl);
5722                    emit('paginationUpdate', subEl);
5723                }
5724                if (swiper.params.watchOverflow && swiper.enabled) {
5725                    subEl.classList[swiper.isLocked ? 'add' : 'remove'](params.lockClass);
5726                }
5727            });
5728        }
5729        function render() {
5730            // Render Container
5731            const params = swiper.params.pagination;
5732            if (isPaginationDisabled()) return;
5733            const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.grid && swiper.params.grid.rows > 1 ? swiper.slides.length / Math.ceil(swiper.params.grid.rows) : swiper.slides.length;
5734            let el = swiper.pagination.el;
5735            el = makeElementsArray(el);
5736            let paginationHTML = '';
5737            if (params.type === 'bullets') {
5738                let numberOfBullets = swiper.params.loop ? Math.ceil(slidesLength / swiper.params.slidesPerGroup) : swiper.snapGrid.length;
5739                if (swiper.params.freeMode && swiper.params.freeMode.enabled && numberOfBullets > slidesLength) {
5740                    numberOfBullets = slidesLength;
5741                }
5742                for (let i = 0; i < numberOfBullets; i += 1) {
5743                    if (params.renderBullet) {
5744                        paginationHTML += params.renderBullet.call(swi

vendor: 25,735 bytes, lines 5744-6378

5744per, i, params.bulletClass);
5745                    } else {
5746                        // prettier-ignore
5747                        paginationHTML += `<${params.bulletElement} ${swiper.isElement ? 'part="bullet"' : ''} class="${params.bulletClass}"></${params.bulletElement}>`;
5748                    }
5749                }
5750            }
5751            if (params.type === 'fraction') {
5752                if (params.renderFraction) {
5753                    paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass);
5754                } else {
5755                    paginationHTML = `<span class="${params.currentClass}"></span>` + ' / ' + `<span class="${params.totalClass}"></span>`;
5756                }
5757            }
5758            if (params.type === 'progressbar') {
5759                if (params.renderProgressbar) {
5760                    paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass);
5761                } else {
5762                    paginationHTML = `<span class="${params.progressbarFillClass}"></span>`;
5763                }
5764            }
5765            swiper.pagination.bullets = [];
5766            el.forEach(subEl => {
5767                if (params.type !== 'custom') {
5768                    subEl.innerHTML = paginationHTML || '';
5769                }
5770                if (params.type === 'bullets') {
5771                    swiper.pagination.bullets.push(...subEl.querySelectorAll(classesToSelector(params.bulletClass)));
5772                }
5773            });
5774            if (params.type !== 'custom') {
5775                emit('paginationRender', el[0]);
5776            }
5777        }
5778        function init() {
5779            swiper.params.pagination = createElementIfNotDefined(swiper, swiper.originalParams.pagination, swiper.params.pagination, {
5780                el: 'swiper-pagination'
5781            });
5782            const params = swiper.params.pagination;
5783            if (!params.el) return;
5784            let el;
5785            if (typeof params.el === 'string' && swiper.isElement) {
5786                el = swiper.el.querySelector(params.el);
5787            }
5788            if (!el && typeof params.el === 'string') {
5789                el = [...document.querySelectorAll(params.el)];
5790            }
5791            if (!el) {
5792                el = params.el;
5793            }
5794            if (!el || el.length === 0) return;
5795            if (swiper.params.uniqueNavElements && typeof params.el === 'string' && Array.isArray(el) && el.length > 1) {
5796                el = [...swiper.el.querySelectorAll(params.el)];
5797                // check if it belongs to another nested Swiper
5798                if (el.length > 1) {
5799                    el = el.find(subEl => {
5800                        if (elementParents(subEl, '.swiper')[0] !== swiper.el) return false;
5801                        return true;
5802                    });
5803                }
5804            }
5805            if (Array.isArray(el) && el.length === 1) el = el[0];
5806            Object.assign(swiper.pagination, {
5807                el
5808            });
5809            el = makeElementsArray(el);
5810            el.forEach(subEl => {
5811                if (params.type === 'bullets' && params.clickable) {
5812                    subEl.classList.add(...(params.clickableClass || '').split(' '));
5813                }
5814                subEl.classList.add(params.modifierClass + params.type);
5815                subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
5816                if (params.type === 'bullets' && params.dynamicBullets) {
5817                    subEl.classList.add(`${params.modifierClass}${params.type}-dynamic`);
5818                    dynamicBulletIndex = 0;
5819                    if (params.dynamicMainBullets < 1) {
5820                        params.dynamicMainBullets = 1;
5821                    }
5822                }
5823                if (params.type === 'progressbar' && params.progressbarOpposite) {
5824                    subEl.classList.add(params.progressbarOppositeClass);
5825                }
5826                if (params.clickable) {
5827                    subEl.addEventListener('click', onBulletClick);
5828                }
5829                if (!swiper.enabled) {
5830                    subEl.classList.add(params.lockClass);
5831                }
5832            });
5833        }
5834        function destroy() {
5835            const params = swiper.params.pagination;
5836            if (isPaginationDisabled()) return;
5837            let el = swiper.pagination.el;
5838            if (el) {
5839                el = makeElementsArray(el);
5840                el.forEach(subEl => {
5841                    subEl.classList.remove(params.hiddenClass);
5842                    subEl.classList.remove(params.modifierClass + params.type);
5843                    subEl.classList.remove(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
5844                    if (params.clickable) {
5845                        subEl.classList.remove(...(params.clickableClass || '').split(' '));
5846                        subEl.removeEventListener('click', onBulletClick);
5847                    }
5848                });
5849            }
5850            if (swiper.pagination.bullets) swiper.pagination.bullets.forEach(subEl => subEl.classList.remove(...params.bulletActiveClass.split(' ')));
5851        }
5852        on('changeDirection', () => {
5853            if (!swiper.pagination || !swiper.pagination.el) return;
5854            const params = swiper.params.pagination;
5855            let {
5856                el
5857            } = swiper.pagination;
5858            el = makeElementsArray(el);
5859            el.forEach(subEl => {
5860                subEl.classList.remove(params.horizontalClass, params.verticalClass);
5861                subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
5862            });
5863        });
5864        on('init', () => {
5865            if (swiper.params.pagination.enabled === false) {
5866                // eslint-disable-next-line
5867                disable();
5868            } else {
5869                init();
5870                render();
5871                update();
5872            }
5873        });
5874        on('activeIndexChange', () => {
5875            if (typeof swiper.snapIndex === 'undefined') {
5876                update();
5877            }
5878        });
5879        on('snapIndexChange', () => {
5880            update();
5881        });
5882        on('snapGridLengthChange', () => {
5883            render();
5884            update();
5885        });
5886        on('destroy', () => {
5887            destroy();
5888        });
5889        on('enable disable', () => {
5890            let {
5891                el
5892            } = swiper.pagination;
5893            if (el) {
5894                el = makeElementsArray(el);
5895                el.forEach(subEl => subEl.classList[swiper.enabled ? 'remove' : 'add'](swiper.params.pagination.lockClass));
5896            }
5897        });
5898        on('lock unlock', () => {
5899            update();
5900        });
5901        on('click', (_s, e) => {
5902            const targetEl = e.target;
5903            const el = makeElementsArray(swiper.pagination.el);
5904            if (swiper.params.pagination.el && swiper.params.pagination.hideOnClick && el && el.length > 0 && !targetEl.classList.contains(swiper.params.pagination.bulletClass)) {
5905                if (swiper.navigation && (swiper.navigation.nextEl && targetEl === swiper.navigation.nextEl || swiper.navigation.prevEl && targetEl === swiper.navigation.prevEl)) return;
5906                const isHidden = el[0].classList.contains(swiper.params.pagination.hiddenClass);
5907                if (isHidden === true) {
5908                    emit('paginationShow');
5909                } else {
5910                    emit('paginationHide');
5911                }
5912                el.forEach(subEl => subEl.classList.toggle(swiper.params.pagination.hiddenClass));
5913            }
5914        });
5915        const enable = () => {
5916            swiper.el.classList.remove(swiper.params.pagination.paginationDisabledClass);
5917            let {
5918                el
5919            } = swiper.pagination;
5920            if (el) {
5921                el = makeElementsArray(el);
5922                el.forEach(subEl => subEl.classList.remove(swiper.params.pagination.paginationDisabledClass));
5923            }
5924            init();
5925            render();
5926            update();
5927        };
5928        const disable = () => {
5929            swiper.el.classList.add(swiper.params.pagination.paginationDisabledClass);
5930            let {
5931                el
5932            } = swiper.pagination;
5933            if (el) {
5934                el = makeElementsArray(el);
5935                el.forEach(subEl => subEl.classList.add(swiper.params.pagination.paginationDisabledClass));
5936            }
5937            destroy();
5938        };
5939        Object.assign(swiper.pagination, {
5940            enable,
5941            disable,
5942            render,
5943            update,
5944            init,
5945            destroy
5946        });
5947    }
5948
5949    function Scrollbar(_ref) {
5950        let {
5951            swiper,
5952            extendParams,
5953            on,
5954            emit
5955        } = _ref;
5956        const document = getDocument();
5957        let isTouched = false;
5958        let timeout = null;
5959        let dragTimeout = null;
5960        let dragStartPos;
5961        let dragSize;
5962        let trackSize;
5963        let divider;
5964        extendParams({
5965            scrollbar: {
5966                el: null,
5967                dragSize: 'auto',
5968                hide: false,
5969                draggable: false,
5970                snapOnRelease: true,
5971                lockClass: 'swiper-scrollbar-lock',
5972                dragClass: 'swiper-scrollbar-drag',
5973                scrollbarDisabledClass: 'swiper-scrollbar-disabled',
5974                horizontalClass: `swiper-scrollbar-horizontal`,
5975                verticalClass: `swiper-scrollbar-vertical`
5976            }
5977        });
5978        swiper.scrollbar = {
5979            el: null,
5980            dragEl: null
5981        };
5982        function setTranslate() {
5983            if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
5984            const {
5985                scrollbar,
5986                rtlTranslate: rtl
5987            } = swiper;
5988            const {
5989                dragEl,
5990                el
5991            } = scrollbar;
5992            const params = swiper.params.scrollbar;
5993            const progress = swiper.params.loop ? swiper.progressLoop : swiper.progress;
5994            let newSize = dragSize;
5995            let newPos = (trackSize - dragSize) * progress;
5996            if (rtl) {
5997                newPos = -newPos;
5998                if (newPos > 0) {
5999                    newSize = dragSize - newPos;
6000                    newPos = 0;
6001                } else if (-newPos + dragSize > trackSize) {
6002                    newSize = trackSize + newPos;
6003                }
6004            } else if (newPos < 0) {
6005                newSize = dragSize + newPos;
6006                newPos = 0;
6007            } else if (newPos + dragSize > trackSize) {
6008                newSize = trackSize - newPos;
6009            }
6010            if (swiper.isHorizontal()) {
6011                dragEl.style.transform = `translate3d(${newPos}px, 0, 0)`;
6012                dragEl.style.width = `${newSize}px`;
6013            } else {
6014                dragEl.style.transform = `translate3d(0px, ${newPos}px, 0)`;
6015                dragEl.style.height = `${newSize}px`;
6016            }
6017            if (params.hide) {
6018                clearTimeout(timeout);
6019                el.style.opacity = 1;
6020                timeout = setTimeout(() => {
6021                    el.style.opacity = 0;
6022                    el.style.transitionDuration = '400ms';
6023                }, 1000);
6024            }
6025        }
6026        function setTransition(duration) {
6027            if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
6028            swiper.scrollbar.dragEl.style.transitionDuration = `${duration}ms`;
6029        }
6030        function updateSize() {
6031            if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
6032            const {
6033                scrollbar
6034            } = swiper;
6035            const {
6036                dragEl,
6037                el
6038            } = scrollbar;
6039            dragEl.style.width = '';
6040            dragEl.style.height = '';
6041            trackSize = swiper.isHorizontal() ? el.offsetWidth : el.offsetHeight;
6042            divider = swiper.size / (swiper.virtualSize + swiper.params.slidesOffsetBefore - (swiper.params.centeredSlides ? swiper.snapGrid[0] : 0));
6043            if (swiper.params.scrollbar.dragSize === 'auto') {
6044                dragSize = trackSize * divider;
6045            } else {
6046                dragSize = parseInt(swiper.params.scrollbar.dragSize, 10);
6047            }
6048            if (swiper.isHorizontal()) {
6049                dragEl.style.width = `${dragSize}px`;
6050            } else {
6051                dragEl.style.height = `${dragSize}px`;
6052            }
6053            if (divider >= 1) {
6054                el.style.display = 'none';
6055            } else {
6056                el.style.display = '';
6057            }
6058            if (swiper.params.scrollbar.hide) {
6059                el.style.opacity = 0;
6060            }
6061            if (swiper.params.watchOverflow && swiper.enabled) {
6062                scrollbar.el.classList[swiper.isLocked ? 'add' : 'remove'](swiper.params.scrollbar.lockClass);
6063            }
6064        }
6065        function getPointerPosition(e) {
6066            return swiper.isHorizontal() ? e.clientX : e.clientY;
6067        }
6068        function setDragPosition(e) {
6069            const {
6070                scrollbar,
6071                rtlTranslate: rtl
6072            } = swiper;
6073            const {
6074                el
6075            } = scrollbar;
6076            let positionRatio;
6077            positionRatio = (getPointerPosition(e) - elementOffset(el)[swiper.isHorizontal() ? 'left' : 'top'] - (dragStartPos !== null ? dragStartPos : dragSize / 2)) / (trackSize - dragSize);
6078            positionRatio = Math.max(Math.min(positionRatio, 1), 0);
6079            if (rtl) {
6080                positionRatio = 1 - positionRatio;
6081            }
6082            const position = swiper.minTranslate() + (swiper.maxTranslate() - swiper.minTranslate()) * positionRatio;
6083            swiper.updateProgress(position);
6084            swiper.setTranslate(position);
6085            swiper.updateActiveIndex();
6086            swiper.updateSlidesClasses();
6087        }
6088        function onDragStart(e) {
6089            const params = swiper.params.scrollbar;
6090            const {
6091                scrollbar,
6092                wrapperEl
6093            } = swiper;
6094            const {
6095                el,
6096                dragEl
6097            } = scrollbar;
6098            isTouched = true;
6099            dragStartPos = e.target === dragEl ? getPointerPosition(e) - e.target.getBoundingClientRect()[swiper.isHorizontal() ? 'left' : 'top'] : null;
6100            e.preventDefault();
6101            e.stopPropagation();
6102            wrapperEl.style.transitionDuration = '100ms';
6103            dragEl.style.transitionDuration = '100ms';
6104            setDragPosition(e);
6105            clearTimeout(dragTimeout);
6106            el.style.transitionDuration = '0ms';
6107            if (params.hide) {
6108                el.style.opacity = 1;
6109            }
6110            if (swiper.params.cssMode) {
6111                swiper.wrapperEl.style['scroll-snap-type'] = 'none';
6112            }
6113            emit('scrollbarDragStart', e);
6114        }
6115        function onDragMove(e) {
6116            const {
6117                scrollbar,
6118                wrapperEl
6119            } = swiper;
6120            const {
6121                el,
6122                dragEl
6123            } = scrollbar;
6124            if (!isTouched) return;
6125            if (e.preventDefault && e.cancelable) e.preventDefault();else e.returnValue = false;
6126            setDragPosition(e);
6127            wrapperEl.style.transitionDuration = '0ms';
6128            el.style.transitionDuration = '0ms';
6129            dragEl.style.transitionDuration = '0ms';
6130            emit('scrollbarDragMove', e);
6131        }
6132        function onDragEnd(e) {
6133            const params = swiper.params.scrollbar;
6134            const {
6135                scrollbar,
6136                wrapperEl
6137            } = swiper;
6138            const {
6139                el
6140            } = scrollbar;
6141            if (!isTouched) return;
6142            isTouched = false;
6143            if (swiper.params.cssMode) {
6144                swiper.wrapperEl.style['scroll-snap-type'] = '';
6145                wrapperEl.style.transitionDuration = '';
6146            }
6147            if (params.hide) {
6148                clearTimeout(dragTimeout);
6149                dragTimeout = nextTick(() => {
6150                    el.style.opacity = 0;
6151                    el.style.transitionDuration = '400ms';
6152                }, 1000);
6153            }
6154            emit('scrollbarDragEnd', e);
6155            if (params.snapOnRelease) {
6156                swiper.slideToClosest();
6157            }
6158        }
6159        function events(method) {
6160            const {
6161                scrollbar,
6162                params
6163            } = swiper;
6164            const el = scrollbar.el;
6165            if (!el) return;
6166            const target = el;
6167            const activeListener = params.passiveListeners ? {
6168                passive: false,
6169                capture: false
6170            } : false;
6171            const passiveListener = params.passiveListeners ? {
6172                passive: true,
6173                capture: false
6174            } : false;
6175            if (!target) return;
6176            const eventMethod = method === 'on' ? 'addEventListener' : 'removeEventListener';
6177            target[eventMethod]('pointerdown', onDragStart, activeListener);
6178            document[eventMethod]('pointermove', onDragMove, activeListener);
6179            document[eventMethod]('pointerup', onDragEnd, passiveListener);
6180        }
6181        function enableDraggable() {
6182            if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
6183            events('on');
6184        }
6185        function disableDraggable() {
6186            if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
6187            events('off');
6188        }
6189        function init() {
6190            const {
6191                scrollbar,
6192                el: swiperEl
6193            } = swiper;
6194            swiper.params.scrollbar = createElementIfNotDefined(swiper, swiper.originalParams.scrollbar, swiper.params.scrollbar, {
6195                el: 'swiper-scrollbar'
6196            });
6197            const params = swiper.params.scrollbar;
6198            if (!params.el) return;
6199            let el;
6200            if (typeof params.el === 'string' && swiper.isElement) {
6201                el = swiper.el.querySelector(params.el);
6202            }
6203            if (!el && typeof params.el === 'string') {
6204                el = document.querySelectorAll(params.el);
6205                if (!el.length) return;
6206            } else if (!el) {
6207                el = params.el;
6208            }
6209            if (swiper.params.uniqueNavElements && typeof params.el === 'string' && el.length > 1 && swiperEl.querySelectorAll(params.el).length === 1) {
6210                el = swiperEl.querySelector(params.el);
6211            }
6212            if (el.length > 0) el = el[0];
6213            el.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
6214            let dragEl;
6215            if (el) {
6216                dragEl = el.querySelector(classesToSelector(swiper.params.scrollbar.dragClass));
6217                if (!dragEl) {
6218                    dragEl = createElement('div', swiper.params.scrollbar.dragClass);
6219                    el.append(dragEl);
6220                }
6221            }
6222            Object.assign(scrollbar, {
6223                el,
6224                dragEl
6225            });
6226            if (params.draggable) {
6227                enableDraggable();
6228            }
6229            if (el) {
6230                el.classList[swiper.enabled ? 'remove' : 'add'](...classesToTokens(swiper.params.scrollbar.lockClass));
6231            }
6232        }
6233        function destroy() {
6234            const params = swiper.params.scrollbar;
6235            const el = swiper.scrollbar.el;
6236            if (el) {
6237                el.classList.remove(...classesToTokens(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass));
6238            }
6239            disableDraggable();
6240        }
6241        on('changeDirection', () => {
6242            if (!swiper.scrollbar || !swiper.scrollbar.el) return;
6243            const params = swiper.params.scrollbar;
6244            let {
6245                el
6246            } = swiper.scrollbar;
6247            el = makeElementsArray(el);
6248            el.forEach(subEl => {
6249                subEl.classList.remove(params.horizontalClass, params.verticalClass);
6250                subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
6251            });
6252        });
6253        on('init', () => {
6254            if (swiper.params.scrollbar.enabled === false) {
6255                // eslint-disable-next-line
6256                disable();
6257            } else {
6258                init();
6259                updateSize();
6260                setTranslate();
6261            }
6262        });
6263        on('update resize observerUpdate lock unlock changeDirection', () => {
6264            updateSize();
6265        });
6266        on('setTranslate', () => {
6267            setTranslate();
6268        });
6269        on('setTransition', (_s, duration) => {
6270            setTransition(duration);
6271        });
6272        on('enable disable', () => {
6273            const {
6274                el
6275            } = swiper.scrollbar;
6276            if (el) {
6277                el.classList[swiper.enabled ? 'remove' : 'add'](...classesToTokens(swiper.params.scrollbar.lockClass));
6278            }
6279        });
6280        on('destroy', () => {
6281            destroy();
6282        });
6283        const enable = () => {
6284            swiper.el.classList.remove(...classesToTokens(swiper.params.scrollbar.scrollbarDisabledClass));
6285            if (swiper.scrollbar.el) {
6286                swiper.scrollbar.el.classList.remove(...classesToTokens(swiper.params.scrollbar.scrollbarDisabledClass));
6287            }
6288            init();
6289            updateSize();
6290            setTranslate();
6291        };
6292        const disable = () => {
6293            swiper.el.classList.add(...classesToTokens(swiper.params.scrollbar.scrollbarDisabledClass));
6294            if (swiper.scrollbar.el) {
6295                swiper.scrollbar.el.classList.add(...classesToTokens(swiper.params.scrollbar.scrollbarDisabledClass));
6296            }
6297            destroy();
6298        };
6299        Object.assign(swiper.scrollbar, {
6300            enable,
6301            disable,
6302            updateSize,
6303            setTranslate,
6304            init,
6305            destroy
6306        });
6307    }
6308
6309    function Parallax(_ref) {
6310        let {
6311            swiper,
6312            extendParams,
6313            on
6314        } = _ref;
6315        extendParams({
6316            parallax: {
6317                enabled: false
6318            }
6319        });
6320        const elementsSelector = '[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]';
6321        const setTransform = (el, progress) => {
6322            const {
6323                rtl
6324            } = swiper;
6325            const rtlFactor = rtl ? -1 : 1;
6326            const p = el.getAttribute('data-swiper-parallax') || '0';
6327            let x = el.getAttribute('data-swiper-parallax-x');
6328            let y = el.getAttribute('data-swiper-parallax-y');
6329            const scale = el.getAttribute('data-swiper-parallax-scale');
6330            const opacity = el.getAttribute('data-swiper-parallax-opacity');
6331            const rotate = el.getAttribute('data-swiper-parallax-rotate');
6332            if (x || y) {
6333                x = x || '0';
6334                y = y || '0';
6335            } else if (swiper.isHorizontal()) {
6336                x = p;
6337                y = '0';
6338            } else {
6339                y = p;
6340                x = '0';
6341            }
6342            if (x.indexOf('%') >= 0) {
6343                x = `${parseInt(x, 10) * progress * rtlFactor}%`;
6344            } else {
6345                x = `${x * progress * rtlFactor}px`;
6346            }
6347            if (y.indexOf('%') >= 0) {
6348                y = `${parseInt(y, 10) * progress}%`;
6349            } else {
6350                y = `${y * progress}px`;
6351            }
6352            if (typeof opacity !== 'undefined' && opacity !== null) {
6353                const currentOpacity = opacity - (opacity - 1) * (1 - Math.abs(progress));
6354                el.style.opacity = currentOpacity;
6355            }
6356            let transform = `translate3d(${x}, ${y}, 0px)`;
6357            if (typeof scale !== 'undefined' && scale !== null) {
6358                const currentScale = scale - (scale - 1) * (1 - Math.abs(progress));
6359                transform += ` scale(${currentScale})`;
6360            }
6361            if (rotate && typeof rotate !== 'undefined' && rotate !== null) {
6362                const currentRotate = rotate * progress * -1;
6363                transform += ` rotate(${currentRotate}deg)`;
6364            }
6365            el.style.transform = transform;
6366        };
6367        const setTranslate = () => {
6368            const {
6369                el,
6370                slides,
6371                progress,
6372                snapGrid,
6373                isElement
6374            } = swiper;
6375            const elements = elementChildren(el, elementsSelector);
6376            if (swiper.isElement) {
6377                elements.push(...elementChildren(swiper.hostEl, elementsSelector));
6378            }

vendor: 4,842 bytes, lines 6379-6515

6379            elements.forEach(subEl => {
6380                setTransform(subEl, progress);
6381            });
6382            slides.forEach((slideEl, slideIndex) => {
6383                let slideProgress = slideEl.progress;
6384                if (swiper.params.slidesPerGroup > 1 && swiper.params.slidesPerView !== 'auto') {
6385                    slideProgress += Math.ceil(slideIndex / 2) - progress * (snapGrid.length - 1);
6386                }
6387                slideProgress = Math.min(Math.max(slideProgress, -1), 1);
6388                slideEl.querySelectorAll(`${elementsSelector}, [data-swiper-parallax-rotate]`).forEach(subEl => {
6389                    setTransform(subEl, slideProgress);
6390                });
6391            });
6392        };
6393        const setTransition = function (duration) {
6394            if (duration === void 0) {
6395                duration = swiper.params.speed;
6396            }
6397            const {
6398                el,
6399                hostEl
6400            } = swiper;
6401            const elements = [...el.querySelectorAll(elementsSelector)];
6402            if (swiper.isElement) {
6403                elements.push(...hostEl.querySelectorAll(elementsSelector));
6404            }
6405            elements.forEach(parallaxEl => {
6406                let parallaxDuration = parseInt(parallaxEl.getAttribute('data-swiper-parallax-duration'), 10) || duration;
6407                if (duration === 0) parallaxDuration = 0;
6408                parallaxEl.style.transitionDuration = `${parallaxDuration}ms`;
6409            });
6410        };
6411        on('beforeInit', () => {
6412            if (!swiper.params.parallax.enabled) return;
6413            swiper.params.watchSlidesProgress = true;
6414            swiper.originalParams.watchSlidesProgress = true;
6415        });
6416        on('init', () => {
6417            if (!swiper.params.parallax.enabled) return;
6418            setTranslate();
6419        });
6420        on('setTranslate', () => {
6421            if (!swiper.params.parallax.enabled) return;
6422            setTranslate();
6423        });
6424        on('setTransition', (_swiper, duration) => {
6425            if (!swiper.params.parallax.enabled) return;
6426            setTransition(duration);
6427        });
6428    }
6429
6430    function Zoom(_ref) {
6431        let {
6432            swiper,
6433            extendParams,
6434            on,
6435            emit
6436        } = _ref;
6437        const window = getWindow();
6438        extendParams({
6439            zoom: {
6440                enabled: false,
6441                limitToOriginalSize: false,
6442                maxRatio: 3,
6443                minRatio: 1,
6444                panOnMouseMove: false,
6445                toggle: true,
6446                containerClass: 'swiper-zoom-container',
6447                zoomedSlideClass: 'swiper-slide-zoomed'
6448            }
6449        });
6450        swiper.zoom = {
6451            enabled: false
6452        };
6453        let currentScale = 1;
6454        let isScaling = false;
6455        let isPanningWithMouse = false;
6456        let mousePanStart = {
6457            x: 0,
6458            y: 0
6459        };
6460        const mousePanSensitivity = -3; // Negative to invert pan direction
6461        let fakeGestureTouched;
6462        let fakeGestureMoved;
6463        const evCache = [];
6464        const gesture = {
6465            originX: 0,
6466            originY: 0,
6467            slideEl: undefined,
6468            slideWidth: undefined,
6469            slideHeight: undefined,
6470            imageEl: undefined,
6471            imageWrapEl: undefined,
6472            maxRatio: 3
6473        };
6474        const image = {
6475            isTouched: undefined,
6476            isMoved: undefined,
6477            currentX: undefined,
6478            currentY: undefined,
6479            minX: undefined,
6480            minY: undefined,
6481            maxX: undefined,
6482            maxY: undefined,
6483            width: undefined,
6484            height: undefined,
6485            startX: undefined,
6486            startY: undefined,
6487            touchesStart: {},
6488            touchesCurrent: {}
6489        };
6490        const velocity = {
6491            x: undefined,
6492            y: undefined,
6493            prevPositionX: undefined,
6494            prevPositionY: undefined,
6495            prevTime: undefined
6496        };
6497        let scale = 1;
6498        Object.defineProperty(swiper.zoom, 'scale', {
6499            get() {
6500                return scale;
6501            },
6502            set(value) {
6503                if (scale !== value) {
6504                    const imageEl = gesture.imageEl;
6505                    const slideEl = gesture.slideEl;
6506                    emit('zoomChange', value, imageEl, slideEl);
6507                }
6508                scale = value;
6509            }
6510        });
6511        function getDistanceBetweenTouches() {
6512            if (evCache.length < 2) return 1;
6513            const x1 = evCache[0].pageX;
6514            const y1 = evCache[0].pageY;
6515            const x2 = evCache[1].pageX;

vendor: 10,672 bytes, lines 6516-6732

6516            const y2 = evCache[1].pageY;
6517            const distance = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
6518            return distance;
6519        }
6520        function getMaxRatio() {
6521            const params = swiper.params.zoom;
6522            const maxRatio = gesture.imageWrapEl.getAttribute('data-swiper-zoom') || params.maxRatio;
6523            if (params.limitToOriginalSize && gesture.imageEl && gesture.imageEl.naturalWidth) {
6524                const imageMaxRatio = gesture.imageEl.naturalWidth / gesture.imageEl.offsetWidth;
6525                return Math.min(imageMaxRatio, maxRatio);
6526            }
6527            return maxRatio;
6528        }
6529        function getScaleOrigin() {
6530            if (evCache.length < 2) return {
6531                x: null,
6532                y: null
6533            };
6534            const box = gesture.imageEl.getBoundingClientRect();
6535            return [(evCache[0].pageX + (evCache[1].pageX - evCache[0].pageX) / 2 - box.x - window.scrollX) / currentScale, (evCache[0].pageY + (evCache[1].pageY - evCache[0].pageY) / 2 - box.y - window.scrollY) / currentScale];
6536        }
6537        function getSlideSelector() {
6538            return swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
6539        }
6540        function eventWithinSlide(e) {
6541            const slideSelector = getSlideSelector();
6542            if (e.target.matches(slideSelector)) return true;
6543            if (swiper.slides.filter(slideEl => slideEl.contains(e.target)).length > 0) return true;
6544            return false;
6545        }
6546        function eventWithinZoomContainer(e) {
6547            const selector = `.${swiper.params.zoom.containerClass}`;
6548            if (e.target.matches(selector)) return true;
6549            if ([...swiper.hostEl.querySelectorAll(selector)].filter(containerEl => containerEl.contains(e.target)).length > 0) return true;
6550            return false;
6551        }
6552
6553        // Events
6554        function onGestureStart(e) {
6555            if (e.pointerType === 'mouse') {
6556                evCache.splice(0, evCache.length);
6557            }
6558            if (!eventWithinSlide(e)) return;
6559            const params = swiper.params.zoom;
6560            fakeGestureTouched = false;
6561            fakeGestureMoved = false;
6562            evCache.push(e);
6563            if (evCache.length < 2) {
6564                return;
6565            }
6566            fakeGestureTouched = true;
6567            gesture.scaleStart = getDistanceBetweenTouches();
6568            if (!gesture.slideEl) {
6569                gesture.slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
6570                if (!gesture.slideEl) gesture.slideEl = swiper.slides[swiper.activeIndex];
6571                let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);
6572                if (imageEl) {
6573                    imageEl = imageEl.querySelectorAll('picture, img, svg, canvas, .swiper-zoom-target')[0];
6574                }
6575                gesture.imageEl = imageEl;
6576                if (imageEl) {
6577                    gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];
6578                } else {
6579                    gesture.imageWrapEl = undefined;
6580                }
6581                if (!gesture.imageWrapEl) {
6582                    gesture.imageEl = undefined;
6583                    return;
6584                }
6585                gesture.maxRatio = getMaxRatio();
6586            }
6587            if (gesture.imageEl) {
6588                const [originX, originY] = getScaleOrigin();
6589                gesture.originX = originX;
6590                gesture.originY = originY;
6591                gesture.imageEl.style.transitionDuration = '0ms';
6592            }
6593            isScaling = true;
6594        }
6595        function onGestureChange(e) {
6596            if (!eventWithinSlide(e)) return;
6597            const params = swiper.params.zoom;
6598            const zoom = swiper.zoom;
6599            const pointerIndex = evCache.findIndex(cachedEv => cachedEv.pointerId === e.pointerId);
6600            if (pointerIndex >= 0) evCache[pointerIndex] = e;
6601            if (evCache.length < 2) {
6602                return;
6603            }
6604            fakeGestureMoved = true;
6605            gesture.scaleMove = getDistanceBetweenTouches();
6606            if (!gesture.imageEl) {
6607                return;
6608            }
6609            zoom.scale = gesture.scaleMove / gesture.scaleStart * currentScale;
6610            if (zoom.scale > gesture.maxRatio) {
6611                zoom.scale = gesture.maxRatio - 1 + (zoom.scale - gesture.maxRatio + 1) ** 0.5;
6612            }
6613            if (zoom.scale < params.minRatio) {
6614                zoom.scale = params.minRatio + 1 - (params.minRatio - zoom.scale + 1) ** 0.5;
6615            }
6616            gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
6617        }
6618        function onGestureEnd(e) {
6619            if (!eventWithinSlide(e)) return;
6620            if (e.pointerType === 'mouse' && e.type === 'pointerout') return;
6621            const params = swiper.params.zoom;
6622            const zoom = swiper.zoom;
6623            const pointerIndex = evCache.findIndex(cachedEv => cachedEv.pointerId === e.pointerId);
6624            if (pointerIndex >= 0) evCache.splice(pointerIndex, 1);
6625            if (!fakeGestureTouched || !fakeGestureMoved) {
6626                return;
6627            }
6628            fakeGestureTouched = false;
6629            fakeGestureMoved = false;
6630            if (!gesture.imageEl) return;
6631            zoom.scale = Math.max(Math.min(zoom.scale, gesture.maxRatio), params.minRatio);
6632            gesture.imageEl.style.transitionDuration = `${swiper.params.speed}ms`;
6633            gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
6634            currentScale = zoom.scale;
6635            isScaling = false;
6636            if (zoom.scale > 1 && gesture.slideEl) {
6637                gesture.slideEl.classList.add(`${params.zoomedSlideClass}`);
6638            } else if (zoom.scale <= 1 && gesture.slideEl) {
6639                gesture.slideEl.classList.remove(`${params.zoomedSlideClass}`);
6640            }
6641            if (zoom.scale === 1) {
6642                gesture.originX = 0;
6643                gesture.originY = 0;
6644                gesture.slideEl = undefined;
6645            }
6646        }
6647        let allowTouchMoveTimeout;
6648        function allowTouchMove() {
6649            swiper.touchEventsData.preventTouchMoveFromPointerMove = false;
6650        }
6651        function preventTouchMove() {
6652            clearTimeout(allowTouchMoveTimeout);
6653            swiper.touchEventsData.preventTouchMoveFromPointerMove = true;
6654            allowTouchMoveTimeout = setTimeout(() => {
6655                if (swiper.destroyed) return;
6656                allowTouchMove();
6657            });
6658        }
6659        function onTouchStart(e) {
6660            const device = swiper.device;
6661            if (!gesture.imageEl) return;
6662            if (image.isTouched) return;
6663            if (device.android && e.cancelable) e.preventDefault();
6664            image.isTouched = true;
6665            const event = evCache.length > 0 ? evCache[0] : e;
6666            image.touchesStart.x = event.pageX;
6667            image.touchesStart.y = event.pageY;
6668        }
6669        function onTouchMove(e) {
6670            const isMouseEvent = e.pointerType === 'mouse';
6671            const isMousePan = isMouseEvent && swiper.params.zoom.panOnMouseMove;
6672            if (!eventWithinSlide(e) || !eventWithinZoomContainer(e)) {
6673                return;
6674            }
6675            const zoom = swiper.zoom;
6676            if (!gesture.imageEl) {
6677                return;
6678            }
6679            if (!image.isTouched || !gesture.slideEl) {
6680                if (isMousePan) onMouseMove(e);
6681                return;
6682            }
6683            if (isMousePan) {
6684                onMouseMove(e);
6685                return;
6686            }
6687            if (!image.isMoved) {
6688                image.width = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
6689                image.height = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
6690                image.startX = getTranslate(gesture.imageWrapEl, 'x') || 0;
6691                image.startY = getTranslate(gesture.imageWrapEl, 'y') || 0;
6692                gesture.slideWidth = gesture.slideEl.offsetWidth;
6693                gesture.slideHeight = gesture.slideEl.offsetHeight;
6694                gesture.imageWrapEl.style.transitionDuration = '0ms';
6695            }
6696            // Define if we need image drag
6697            const scaledWidth = image.width * zoom.scale;
6698            const scaledHeight = image.height * zoom.scale;
6699            image.minX = Math.min(gesture.slideWidth / 2 - scaledWidth / 2, 0);
6700            image.maxX = -image.minX;
6701            image.minY = Math.min(gesture.slideHeight / 2 - scaledHeight / 2, 0);
6702            image.maxY = -image.minY;
6703            image.touchesCurrent.x = evCache.length > 0 ? evCache[0].pageX : e.pageX;
6704            image.touchesCurrent.y = evCache.length > 0 ? evCache[0].pageY : e.pageY;
6705            const touchesDiff = Math.max(Math.abs(image.touchesCurrent.x - image.touchesStart.x), Math.abs(image.touchesCurrent.y - image.touchesStart.y));
6706            if (touchesDiff > 5) {
6707                swiper.allowClick = false;
6708            }
6709            if (!image.isMoved && !isScaling) {
6710                if (swiper.isHorizontal() && (Math.floor(image.minX) === Math.floor(image.startX) && image.touchesCurrent.x < image.touchesStart.x || Math.floor(image.maxX) === Math.floor(image.startX) && image.touchesCurrent.x > image.touchesStart.x)) {
6711                    image.isTouched = false;
6712                    allowTouchMove();
6713                    return;
6714                }
6715                if (!swiper.isHorizontal() && (Math.floor(image.minY) === Math.floor(image.startY) && image.touchesCurrent.y < image.touchesStart.y || Math.floor(image.maxY) === Math.floor(image.startY) && image.touchesCurrent.y > image.touchesStart.y)) {
6716                    image.isTouched = false;
6717                    allowTouchMove();
6718                    return;
6719                }
6720            }
6721            if (e.cancelable) {
6722                e.preventDefault();
6723            }
6724            e.stopPropagation();
6725            preventTouchMove();
6726            image.isMoved = true;
6727            const scaleRatio = (zoom.scale - currentScale) / (gesture.maxRatio - swiper.params.zoom.minRatio);
6728            const {
6729                originX,
6730                originY
6731            } = gesture;
6732            image.currentX = image.touchesCurrent.x - image.touchesStart.x + image.startX + scaleRatio * (image.

vendor: 4,200 bytes, lines 6732-6803

6732width - originX * 2);
6733            image.currentY = image.touchesCurrent.y - image.touchesStart.y + image.startY + scaleRatio * (image.height - originY * 2);
6734            if (image.currentX < image.minX) {
6735                image.currentX = image.minX + 1 - (image.minX - image.currentX + 1) ** 0.8;
6736            }
6737            if (image.currentX > image.maxX) {
6738                image.currentX = image.maxX - 1 + (image.currentX - image.maxX + 1) ** 0.8;
6739            }
6740            if (image.currentY < image.minY) {
6741                image.currentY = image.minY + 1 - (image.minY - image.currentY + 1) ** 0.8;
6742            }
6743            if (image.currentY > image.maxY) {
6744                image.currentY = image.maxY - 1 + (image.currentY - image.maxY + 1) ** 0.8;
6745            }
6746
6747            // Velocity
6748            if (!velocity.prevPositionX) velocity.prevPositionX = image.touchesCurrent.x;
6749            if (!velocity.prevPositionY) velocity.prevPositionY = image.touchesCurrent.y;
6750            if (!velocity.prevTime) velocity.prevTime = Date.now();
6751            velocity.x = (image.touchesCurrent.x - velocity.prevPositionX) / (Date.now() - velocity.prevTime) / 2;
6752            velocity.y = (image.touchesCurrent.y - velocity.prevPositionY) / (Date.now() - velocity.prevTime) / 2;
6753            if (Math.abs(image.touchesCurrent.x - velocity.prevPositionX) < 2) velocity.x = 0;
6754            if (Math.abs(image.touchesCurrent.y - velocity.prevPositionY) < 2) velocity.y = 0;
6755            velocity.prevPositionX = image.touchesCurrent.x;
6756            velocity.prevPositionY = image.touchesCurrent.y;
6757            velocity.prevTime = Date.now();
6758            gesture.imageWrapEl.style.transform = `translate3d(${image.currentX}px, ${image.currentY}px,0)`;
6759        }
6760        function onTouchEnd() {
6761            const zoom = swiper.zoom;
6762            evCache.length = 0;
6763            if (!gesture.imageEl) return;
6764            if (!image.isTouched || !image.isMoved) {
6765                image.isTouched = false;
6766                image.isMoved = false;
6767                return;
6768            }
6769            image.isTouched = false;
6770            image.isMoved = false;
6771            let momentumDurationX = 300;
6772            let momentumDurationY = 300;
6773            const momentumDistanceX = velocity.x * momentumDurationX;
6774            const newPositionX = image.currentX + momentumDistanceX;
6775            const momentumDistanceY = velocity.y * momentumDurationY;
6776            const newPositionY = image.currentY + momentumDistanceY;
6777
6778            // Fix duration
6779            if (velocity.x !== 0) momentumDurationX = Math.abs((newPositionX - image.currentX) / velocity.x);
6780            if (velocity.y !== 0) momentumDurationY = Math.abs((newPositionY - image.currentY) / velocity.y);
6781            const momentumDuration = Math.max(momentumDurationX, momentumDurationY);
6782            image.currentX = newPositionX;
6783            image.currentY = newPositionY;
6784            // Define if we need image drag
6785            const scaledWidth = image.width * zoom.scale;
6786            const scaledHeight = image.height * zoom.scale;
6787            image.minX = Math.min(gesture.slideWidth / 2 - scaledWidth / 2, 0);
6788            image.maxX = -image.minX;
6789            image.minY = Math.min(gesture.slideHeight / 2 - scaledHeight / 2, 0);
6790            image.maxY = -image.minY;
6791            image.currentX = Math.max(Math.min(image.currentX, image.maxX), image.minX);
6792            image.currentY = Math.max(Math.min(image.currentY, image.maxY), image.minY);
6793            gesture.imageWrapEl.style.transitionDuration = `${momentumDuration}ms`;
6794            gesture.imageWrapEl.style.transform = `translate3d(${image.currentX}px, ${image.currentY}px,0)`;
6795        }
6796        function onTransitionEnd() {
6797            const zoom = swiper.zoom;
6798            if (gesture.slideEl && swiper.activeIndex !== swiper.slides.indexOf(gesture.slideEl)) {
6799                if (gesture.imageEl) {
6800                    gesture.imageEl.style.transform = 'translate3d(0,0,0) scale(1)';
6801                }
6802                if (gesture.imageWrapEl) {
6803                    gesture.imageWrapEl.style.transform = 'translate3d(0,

vendor: 9,771 bytes, lines 6803-7002

68030,0)';
6804                }
6805                gesture.slideEl.classList.remove(`${swiper.params.zoom.zoomedSlideClass}`);
6806                zoom.scale = 1;
6807                currentScale = 1;
6808                gesture.slideEl = undefined;
6809                gesture.imageEl = undefined;
6810                gesture.imageWrapEl = undefined;
6811                gesture.originX = 0;
6812                gesture.originY = 0;
6813            }
6814        }
6815        function onMouseMove(e) {
6816            // Only pan if zoomed in and mouse panning is enabled
6817            if (currentScale <= 1 || !gesture.imageWrapEl) return;
6818            if (!eventWithinSlide(e) || !eventWithinZoomContainer(e)) return;
6819            const currentTransform = window.getComputedStyle(gesture.imageWrapEl).transform;
6820            const matrix = new window.DOMMatrix(currentTransform);
6821            if (!isPanningWithMouse) {
6822                isPanningWithMouse = true;
6823                mousePanStart.x = e.clientX;
6824                mousePanStart.y = e.clientY;
6825                image.startX = matrix.e;
6826                image.startY = matrix.f;
6827                image.width = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
6828                image.height = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
6829                gesture.slideWidth = gesture.slideEl.offsetWidth;
6830                gesture.slideHeight = gesture.slideEl.offsetHeight;
6831                return;
6832            }
6833            const deltaX = (e.clientX - mousePanStart.x) * mousePanSensitivity;
6834            const deltaY = (e.clientY - mousePanStart.y) * mousePanSensitivity;
6835            const scaledWidth = image.width * currentScale;
6836            const scaledHeight = image.height * currentScale;
6837            const slideWidth = gesture.slideWidth;
6838            const slideHeight = gesture.slideHeight;
6839            const minX = Math.min(slideWidth / 2 - scaledWidth / 2, 0);
6840            const maxX = -minX;
6841            const minY = Math.min(slideHeight / 2 - scaledHeight / 2, 0);
6842            const maxY = -minY;
6843            const newX = Math.max(Math.min(image.startX + deltaX, maxX), minX);
6844            const newY = Math.max(Math.min(image.startY + deltaY, maxY), minY);
6845            gesture.imageWrapEl.style.transitionDuration = '0ms';
6846            gesture.imageWrapEl.style.transform = `translate3d(${newX}px, ${newY}px, 0)`;
6847            mousePanStart.x = e.clientX;
6848            mousePanStart.y = e.clientY;
6849            image.startX = newX;
6850            image.startY = newY;
6851            image.currentX = newX;
6852            image.currentY = newY;
6853        }
6854        function zoomIn(e) {
6855            const zoom = swiper.zoom;
6856            const params = swiper.params.zoom;
6857            if (!gesture.slideEl) {
6858                if (e && e.target) {
6859                    gesture.slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
6860                }
6861                if (!gesture.slideEl) {
6862                    if (swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual) {
6863                        gesture.slideEl = elementChildren(swiper.slidesEl, `.${swiper.params.slideActiveClass}`)[0];
6864                    } else {
6865                        gesture.slideEl = swiper.slides[swiper.activeIndex];
6866                    }
6867                }
6868                let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);
6869                if (imageEl) {
6870                    imageEl = imageEl.querySelectorAll('picture, img, svg, canvas, .swiper-zoom-target')[0];
6871                }
6872                gesture.imageEl = imageEl;
6873                if (imageEl) {
6874                    gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];
6875                } else {
6876                    gesture.imageWrapEl = undefined;
6877                }
6878            }
6879            if (!gesture.imageEl || !gesture.imageWrapEl) return;
6880            if (swiper.params.cssMode) {
6881                swiper.wrapperEl.style.overflow = 'hidden';
6882                swiper.wrapperEl.style.touchAction = 'none';
6883            }
6884            gesture.slideEl.classList.add(`${params.zoomedSlideClass}`);
6885            let touchX;
6886            let touchY;
6887            let offsetX;
6888            let offsetY;
6889            let diffX;
6890            let diffY;
6891            let translateX;
6892            let translateY;
6893            let imageWidth;
6894            let imageHeight;
6895            let scaledWidth;
6896            let scaledHeight;
6897            let translateMinX;
6898            let translateMinY;
6899            let translateMaxX;
6900            let translateMaxY;
6901            let slideWidth;
6902            let slideHeight;
6903            if (typeof image.touchesStart.x === 'undefined' && e) {
6904                touchX = e.pageX;
6905                touchY = e.pageY;
6906            } else {
6907                touchX = image.touchesStart.x;
6908                touchY = image.touchesStart.y;
6909            }
6910            const prevScale = currentScale;
6911            const forceZoomRatio = typeof e === 'number' ? e : null;
6912            if (currentScale === 1 && forceZoomRatio) {
6913                touchX = undefined;
6914                touchY = undefined;
6915                image.touchesStart.x = undefined;
6916                image.touchesStart.y = undefined;
6917            }
6918            const maxRatio = getMaxRatio();
6919            zoom.scale = forceZoomRatio || maxRatio;
6920            currentScale = forceZoomRatio || maxRatio;
6921            if (e && !(currentScale === 1 && forceZoomRatio)) {
6922                slideWidth = gesture.slideEl.offsetWidth;
6923                slideHeight = gesture.slideEl.offsetHeight;
6924                offsetX = elementOffset(gesture.slideEl).left + window.scrollX;
6925                offsetY = elementOffset(gesture.slideEl).top + window.scrollY;
6926                diffX = offsetX + slideWidth / 2 - touchX;
6927                diffY = offsetY + slideHeight / 2 - touchY;
6928                imageWidth = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
6929                imageHeight = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
6930                scaledWidth = imageWidth * zoom.scale;
6931                scaledHeight = imageHeight * zoom.scale;
6932                translateMinX = Math.min(slideWidth / 2 - scaledWidth / 2, 0);
6933                translateMinY = Math.min(slideHeight / 2 - scaledHeight / 2, 0);
6934                translateMaxX = -translateMinX;
6935                translateMaxY = -translateMinY;
6936                if (prevScale > 0 && forceZoomRatio && typeof image.currentX === 'number' && typeof image.currentY === 'number') {
6937                    translateX = image.currentX * zoom.scale / prevScale;
6938                    translateY = image.currentY * zoom.scale / prevScale;
6939                } else {
6940                    translateX = diffX * zoom.scale;
6941                    translateY = diffY * zoom.scale;
6942                }
6943                if (translateX < translateMinX) {
6944                    translateX = translateMinX;
6945                }
6946                if (translateX > translateMaxX) {
6947                    translateX = translateMaxX;
6948                }
6949                if (translateY < translateMinY) {
6950                    translateY = translateMinY;
6951                }
6952                if (translateY > translateMaxY) {
6953                    translateY = translateMaxY;
6954                }
6955            } else {
6956                translateX = 0;
6957                translateY = 0;
6958            }
6959            if (forceZoomRatio && zoom.scale === 1) {
6960                gesture.originX = 0;
6961                gesture.originY = 0;
6962            }
6963            image.currentX = translateX;
6964            image.currentY = translateY;
6965            gesture.imageWrapEl.style.transitionDuration = '300ms';
6966            gesture.imageWrapEl.style.transform = `translate3d(${translateX}px, ${translateY}px,0)`;
6967            gesture.imageEl.style.transitionDuration = '300ms';
6968            gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
6969        }
6970        function zoomOut() {
6971            const zoom = swiper.zoom;
6972            const params = swiper.params.zoom;
6973            if (!gesture.slideEl) {
6974                if (swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual) {
6975                    gesture.slideEl = elementChildren(swiper.slidesEl, `.${swiper.params.slideActiveClass}`)[0];
6976                } else {
6977                    gesture.slideEl = swiper.slides[swiper.activeIndex];
6978                }
6979                let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);
6980                if (imageEl) {
6981                    imageEl = imageEl.querySelectorAll('picture, img, svg, canvas, .swiper-zoom-target')[0];
6982                }
6983                gesture.imageEl = imageEl;
6984                if (imageEl) {
6985                    gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];
6986                } else {
6987                    gesture.imageWrapEl = undefined;
6988                }
6989            }
6990            if (!gesture.imageEl || !gesture.imageWrapEl) return;
6991            if (swiper.params.cssMode) {
6992                swiper.wrapperEl.style.overflow = '';
6993                swiper.wrapperEl.style.touchAction = '';
6994            }
6995            zoom.scale = 1;
6996            currentScale = 1;
6997            image.currentX = undefined;
6998            image.currentY = undefined;
6999            image.touchesStart.x = undefined;
7000            image.touchesStart.y = undefined;
7001            gesture.imageWrapEl.style.transitionDuration = '300ms';
7002            gesture.imageWrapEl.style.transform = 'translate3d(0,

vendor: 5,294 bytes, lines 7002-7153

70020,0)';
7003            gesture.imageEl.style.transitionDuration = '300ms';
7004            gesture.imageEl.style.transform = 'translate3d(0,0,0) scale(1)';
7005            gesture.slideEl.classList.remove(`${params.zoomedSlideClass}`);
7006            gesture.slideEl = undefined;
7007            gesture.originX = 0;
7008            gesture.originY = 0;
7009            if (swiper.params.zoom.panOnMouseMove) {
7010                mousePanStart = {
7011                    x: 0,
7012                    y: 0
7013                };
7014                if (isPanningWithMouse) {
7015                    isPanningWithMouse = false;
7016                    image.startX = 0;
7017                    image.startY = 0;
7018                }
7019            }
7020        }
7021
7022        // Toggle Zoom
7023        function zoomToggle(e) {
7024            const zoom = swiper.zoom;
7025            if (zoom.scale && zoom.scale !== 1) {
7026                // Zoom Out
7027                zoomOut();
7028            } else {
7029                // Zoom In
7030                zoomIn(e);
7031            }
7032        }
7033        function getListeners() {
7034            const passiveListener = swiper.params.passiveListeners ? {
7035                passive: true,
7036                capture: false
7037            } : false;
7038            const activeListenerWithCapture = swiper.params.passiveListeners ? {
7039                passive: false,
7040                capture: true
7041            } : true;
7042            return {
7043                passiveListener,
7044                activeListenerWithCapture
7045            };
7046        }
7047
7048        // Attach/Detach Events
7049        function enable() {
7050            const zoom = swiper.zoom;
7051            if (zoom.enabled) return;
7052            zoom.enabled = true;
7053            const {
7054                passiveListener,
7055                activeListenerWithCapture
7056            } = getListeners();
7057
7058            // Scale image
7059            swiper.wrapperEl.addEventListener('pointerdown', onGestureStart, passiveListener);
7060            swiper.wrapperEl.addEventListener('pointermove', onGestureChange, activeListenerWithCapture);
7061            ['pointerup', 'pointercancel', 'pointerout'].forEach(eventName => {
7062                swiper.wrapperEl.addEventListener(eventName, onGestureEnd, passiveListener);
7063            });
7064
7065            // Move image
7066            swiper.wrapperEl.addEventListener('pointermove', onTouchMove, activeListenerWithCapture);
7067        }
7068        function disable() {
7069            const zoom = swiper.zoom;
7070            if (!zoom.enabled) return;
7071            zoom.enabled = false;
7072            const {
7073                passiveListener,
7074                activeListenerWithCapture
7075            } = getListeners();
7076
7077            // Scale image
7078            swiper.wrapperEl.removeEventListener('pointerdown', onGestureStart, passiveListener);
7079            swiper.wrapperEl.removeEventListener('pointermove', onGestureChange, activeListenerWithCapture);
7080            ['pointerup', 'pointercancel', 'pointerout'].forEach(eventName => {
7081                swiper.wrapperEl.removeEventListener(eventName, onGestureEnd, passiveListener);
7082            });
7083
7084            // Move image
7085            swiper.wrapperEl.removeEventListener('pointermove', onTouchMove, activeListenerWithCapture);
7086        }
7087        on('init', () => {
7088            if (swiper.params.zoom.enabled) {
7089                enable();
7090            }
7091        });
7092        on('destroy', () => {
7093            disable();
7094        });
7095        on('touchStart', (_s, e) => {
7096            if (!swiper.zoom.enabled) return;
7097            onTouchStart(e);
7098        });
7099        on('touchEnd', (_s, e) => {
7100            if (!swiper.zoom.enabled) return;
7101            onTouchEnd();
7102        });
7103        on('doubleTap', (_s, e) => {
7104            if (!swiper.animating && swiper.params.zoom.enabled && swiper.zoom.enabled && swiper.params.zoom.toggle) {
7105                zoomToggle(e);
7106            }
7107        });
7108        on('transitionEnd', () => {
7109            if (swiper.zoom.enabled && swiper.params.zoom.enabled) {
7110                onTransitionEnd();
7111            }
7112        });
7113        on('slideChange', () => {
7114            if (swiper.zoom.enabled && swiper.params.zoom.enabled && swiper.params.cssMode) {
7115                onTransitionEnd();
7116            }
7117        });
7118        Object.assign(swiper.zoom, {
7119            enable,
7120            disable,
7121            in: zoomIn,
7122            out: zoomOut,
7123            toggle: zoomToggle
7124        });
7125    }
7126
7127    /* eslint no-bitwise: ["error", { "allow": [">>"] }] */
7128    function Controller(_ref) {
7129        let {
7130            swiper,
7131            extendParams,
7132            on
7133        } = _ref;
7134        extendParams({
7135            controller: {
7136                control: undefined,
7137                inverse: false,
7138                by: 'slide' // or 'container'
7139            }
7140        });
7141
7142        swiper.controller = {
7143            control: undefined
7144        };
7145        function LinearSpline(x, y) {
7146            const binarySearch = function search() {
7147                let maxIndex;
7148                let minIndex;
7149                let guess;
7150                return (array, val) => {
7151                    minIndex = -1;
7152                    maxIndex = array.length;
7153                    while (maxIndex - minIndex > 1) {

vendor: 33,046 bytes, lines 7154-7916

7154                        guess = maxIndex + minIndex >> 1;
7155                        if (array[guess] <= val) {
7156                            minIndex = guess;
7157                        } else {
7158                            maxIndex = guess;
7159                        }
7160                    }
7161                    return maxIndex;
7162                };
7163            }();
7164            this.x = x;
7165            this.y = y;
7166            this.lastIndex = x.length - 1;
7167            // Given an x value (x2), return the expected y2 value:
7168            // (x1,y1) is the known point before given value,
7169            // (x3,y3) is the known point after given value.
7170            let i1;
7171            let i3;
7172            this.interpolate = function interpolate(x2) {
7173                if (!x2) return 0;
7174
7175                // Get the indexes of x1 and x3 (the array indexes before and after given x2):
7176                i3 = binarySearch(this.x, x2);
7177                i1 = i3 - 1;
7178
7179                // We have our indexes i1 & i3, so we can calculate already:
7180                // y2 := ((x2âx1) Ã (y3ây1)) Ã· (x3âx1) + y1
7181                return (x2 - this.x[i1]) * (this.y[i3] - this.y[i1]) / (this.x[i3] - this.x[i1]) + this.y[i1];
7182            };
7183            return this;
7184        }
7185        function getInterpolateFunction(c) {
7186            swiper.controller.spline = swiper.params.loop ? new LinearSpline(swiper.slidesGrid, c.slidesGrid) : new LinearSpline(swiper.snapGrid, c.snapGrid);
7187        }
7188        function setTranslate(_t, byController) {
7189            const controlled = swiper.controller.control;
7190            let multiplier;
7191            let controlledTranslate;
7192            const Swiper = swiper.constructor;
7193            function setControlledTranslate(c) {
7194                if (c.destroyed) return;
7195
7196                // this will create an Interpolate function based on the snapGrids
7197                // x is the Grid of the scrolled scroller and y will be the controlled scroller
7198                // it makes sense to create this only once and recall it for the interpolation
7199                // the function does a lot of value caching for performance
7200                const translate = swiper.rtlTranslate ? -swiper.translate : swiper.translate;
7201                if (swiper.params.controller.by === 'slide') {
7202                    getInterpolateFunction(c);
7203                    // i am not sure why the values have to be multiplicated this way, tried to invert the snapGrid
7204                    // but it did not work out
7205                    controlledTranslate = -swiper.controller.spline.interpolate(-translate);
7206                }
7207                if (!controlledTranslate || swiper.params.controller.by === 'container') {
7208                    multiplier = (c.maxTranslate() - c.minTranslate()) / (swiper.maxTranslate() - swiper.minTranslate());
7209                    if (Number.isNaN(multiplier) || !Number.isFinite(multiplier)) {
7210                        multiplier = 1;
7211                    }
7212                    controlledTranslate = (translate - swiper.minTranslate()) * multiplier + c.minTranslate();
7213                }
7214                if (swiper.params.controller.inverse) {
7215                    controlledTranslate = c.maxTranslate() - controlledTranslate;
7216                }
7217                c.updateProgress(controlledTranslate);
7218                c.setTranslate(controlledTranslate, swiper);
7219                c.updateActiveIndex();
7220                c.updateSlidesClasses();
7221            }
7222            if (Array.isArray(controlled)) {
7223                for (let i = 0; i < controlled.length; i += 1) {
7224                    if (controlled[i] !== byController && controlled[i] instanceof Swiper) {
7225                        setControlledTranslate(controlled[i]);
7226                    }
7227                }
7228            } else if (controlled instanceof Swiper && byController !== controlled) {
7229                setControlledTranslate(controlled);
7230            }
7231        }
7232        function setTransition(duration, byController) {
7233            const Swiper = swiper.constructor;
7234            const controlled = swiper.controller.control;
7235            let i;
7236            function setControlledTransition(c) {
7237                if (c.destroyed) return;
7238                c.setTransition(duration, swiper);
7239                if (duration !== 0) {
7240                    c.transitionStart();
7241                    if (c.params.autoHeight) {
7242                        nextTick(() => {
7243                            c.updateAutoHeight();
7244                        });
7245                    }
7246                    elementTransitionEnd(c.wrapperEl, () => {
7247                        if (!controlled) return;
7248                        c.transitionEnd();
7249                    });
7250                }
7251            }
7252            if (Array.isArray(controlled)) {
7253                for (i = 0; i < controlled.length; i += 1) {
7254                    if (controlled[i] !== byController && controlled[i] instanceof Swiper) {
7255                        setControlledTransition(controlled[i]);
7256                    }
7257                }
7258            } else if (controlled instanceof Swiper && byController !== controlled) {
7259                setControlledTransition(controlled);
7260            }
7261        }
7262        function removeSpline() {
7263            if (!swiper.controller.control) return;
7264            if (swiper.controller.spline) {
7265                swiper.controller.spline = undefined;
7266                delete swiper.controller.spline;
7267            }
7268        }
7269        on('beforeInit', () => {
7270            if (typeof window !== 'undefined' && (
7271                // eslint-disable-line
7272                typeof swiper.params.controller.control === 'string' || swiper.params.controller.control instanceof HTMLElement)) {
7273                const controlElements = typeof swiper.params.controller.control === 'string' ? [...document.querySelectorAll(swiper.params.controller.control)] : [swiper.params.controller.control];
7274                controlElements.forEach(controlElement => {
7275                    if (!swiper.controller.control) swiper.controller.control = [];
7276                    if (controlElement && controlElement.swiper) {
7277                        swiper.controller.control.push(controlElement.swiper);
7278                    } else if (controlElement) {
7279                        const eventName = `${swiper.params.eventsPrefix}init`;
7280                        const onControllerSwiper = e => {
7281                            swiper.controller.control.push(e.detail[0]);
7282                            swiper.update();
7283                            controlElement.removeEventListener(eventName, onControllerSwiper);
7284                        };
7285                        controlElement.addEventListener(eventName, onControllerSwiper);
7286                    }
7287                });
7288                return;
7289            }
7290            swiper.controller.control = swiper.params.controller.control;
7291        });
7292        on('update', () => {
7293            removeSpline();
7294        });
7295        on('resize', () => {
7296            removeSpline();
7297        });
7298        on('observerUpdate', () => {
7299            removeSpline();
7300        });
7301        on('setTranslate', (_s, translate, byController) => {
7302            if (!swiper.controller.control || swiper.controller.control.destroyed) return;
7303            swiper.controller.setTranslate(translate, byController);
7304        });
7305        on('setTransition', (_s, duration, byController) => {
7306            if (!swiper.controller.control || swiper.controller.control.destroyed) return;
7307            swiper.controller.setTransition(duration, byController);
7308        });
7309        Object.assign(swiper.controller, {
7310            setTranslate,
7311            setTransition
7312        });
7313    }
7314
7315    function A11y(_ref) {
7316        let {
7317            swiper,
7318            extendParams,
7319            on
7320        } = _ref;
7321        extendParams({
7322            a11y: {
7323                enabled: true,
7324                notificationClass: 'swiper-notification',
7325                prevSlideMessage: 'Previous slide',
7326                nextSlideMessage: 'Next slide',
7327                firstSlideMessage: 'This is the first slide',
7328                lastSlideMessage: 'This is the last slide',
7329                paginationBulletMessage: 'Go to slide {{index}}',
7330                slideLabelMessage: '{{index}} / {{slidesLength}}',
7331                containerMessage: null,
7332                containerRoleDescriptionMessage: null,
7333                containerRole: null,
7334                itemRoleDescriptionMessage: null,
7335                slideRole: 'group',
7336                id: null,
7337                scrollOnFocus: true
7338            }
7339        });
7340        swiper.a11y = {
7341            clicked: false
7342        };
7343        let liveRegion = null;
7344        let preventFocusHandler;
7345        let focusTargetSlideEl;
7346        let visibilityChangedTimestamp = new Date().getTime();
7347        function notify(message) {
7348            const notification = liveRegion;
7349            if (notification.length === 0) return;
7350            notification.innerHTML = '';
7351            notification.innerHTML = message;
7352        }
7353        function getRandomNumber(size) {
7354            if (size === void 0) {
7355                size = 16;
7356            }
7357            const randomChar = () => Math.round(16 * Math.random()).toString(16);
7358            return 'x'.repeat(size).replace(/x/g, randomChar);
7359        }
7360        function makeElFocusable(el) {
7361            el = makeElementsArray(el);
7362            el.forEach(subEl => {
7363                subEl.setAttribute('tabIndex', '0');
7364            });
7365        }
7366        function makeElNotFocusable(el) {
7367            el = makeElementsArray(el);
7368            el.forEach(subEl => {
7369                subEl.setAttribute('tabIndex', '-1');
7370            });
7371        }
7372        function addElRole(el, role) {
7373            el = makeElementsArray(el);
7374            el.forEach(subEl => {
7375                subEl.setAttribute('role', role);
7376            });
7377        }
7378        function addElRoleDescription(el, description) {
7379            el = makeElementsArray(el);
7380            el.forEach(subEl => {
7381                subEl.setAttribute('aria-roledescription', description);
7382            });
7383        }
7384        function addElControls(el, controls) {
7385            el = makeElementsArray(el);
7386            el.forEach(subEl => {
7387                subEl.setAttribute('aria-controls', controls);
7388            });
7389        }
7390        function addElLabel(el, label) {
7391            el = makeElementsArray(el);
7392            el.forEach(subEl => {
7393                subEl.setAttribute('aria-label', label);
7394            });
7395        }
7396        function addElId(el, id) {
7397            el = makeElementsArray(el);
7398            el.forEach(subEl => {
7399                subEl.setAttribute('id', id);
7400            });
7401        }
7402        function addElLive(el, live) {
7403            el = makeElementsArray(el);
7404            el.forEach(subEl => {
7405                subEl.setAttribute('aria-live', live);
7406            });
7407        }
7408        function disableEl(el) {
7409            el = makeElementsArray(el);
7410            el.forEach(subEl => {
7411                subEl.setAttribute('aria-disabled', true);
7412            });
7413        }
7414        function enableEl(el) {
7415            el = makeElementsArray(el);
7416            el.forEach(subEl => {
7417                subEl.setAttribute('aria-disabled', false);
7418            });
7419        }
7420        function onEnterOrSpaceKey(e) {
7421            if (e.keyCode !== 13 && e.keyCode !== 32) return;
7422            const params = swiper.params.a11y;
7423            const targetEl = e.target;
7424            if (swiper.pagination && swiper.pagination.el && (targetEl === swiper.pagination.el || swiper.pagination.el.contains(e.target))) {
7425                if (!e.target.matches(classesToSelector(swiper.params.pagination.bulletClass))) return;
7426            }
7427            if (swiper.navigation && swiper.navigation.prevEl && swiper.navigation.nextEl) {
7428                const prevEls = makeElementsArray(swiper.navigation.prevEl);
7429                const nextEls = makeElementsArray(swiper.navigation.nextEl);
7430                if (nextEls.includes(targetEl)) {
7431                    if (!(swiper.isEnd && !swiper.params.loop)) {
7432                        swiper.slideNext();
7433                    }
7434                    if (swiper.isEnd) {
7435                        notify(params.lastSlideMessage);
7436                    } else {
7437                        notify(params.nextSlideMessage);
7438                    }
7439                }
7440                if (prevEls.includes(targetEl)) {
7441                    if (!(swiper.isBeginning && !swiper.params.loop)) {
7442                        swiper.slidePrev();
7443                    }
7444                    if (swiper.isBeginning) {
7445                        notify(params.firstSlideMessage);
7446                    } else {
7447                        notify(params.prevSlideMessage);
7448                    }
7449                }
7450            }
7451            if (swiper.pagination && targetEl.matches(classesToSelector(swiper.params.pagination.bulletClass))) {
7452                targetEl.click();
7453            }
7454        }
7455        function updateNavigation() {
7456            if (swiper.params.loop || swiper.params.rewind || !swiper.navigation) return;
7457            const {
7458                nextEl,
7459                prevEl
7460            } = swiper.navigation;
7461            if (prevEl) {
7462                if (swiper.isBeginning) {
7463                    disableEl(prevEl);
7464                    makeElNotFocusable(prevEl);
7465                } else {
7466                    enableEl(prevEl);
7467                    makeElFocusable(prevEl);
7468                }
7469            }
7470            if (nextEl) {
7471                if (swiper.isEnd) {
7472                    disableEl(nextEl);
7473                    makeElNotFocusable(nextEl);
7474                } else {
7475                    enableEl(nextEl);
7476                    makeElFocusable(nextEl);
7477                }
7478            }
7479        }
7480        function hasPagination() {
7481            return swiper.pagination && swiper.pagination.bullets && swiper.pagination.bullets.length;
7482        }
7483        function hasClickablePagination() {
7484            return hasPagination() && swiper.params.pagination.clickable;
7485        }
7486        function updatePagination() {
7487            const params = swiper.params.a11y;
7488            if (!hasPagination()) return;
7489            swiper.pagination.bullets.forEach(bulletEl => {
7490                if (swiper.params.pagination.clickable) {
7491                    makeElFocusable(bulletEl);
7492                    if (!swiper.params.pagination.renderBullet) {
7493                        addElRole(bulletEl, 'button');
7494                        addElLabel(bulletEl, params.paginationBulletMessage.replace(/\{\{index\}\}/, elementIndex(bulletEl) + 1));
7495                    }
7496                }
7497                if (bulletEl.matches(classesToSelector(swiper.params.pagination.bulletActiveClass))) {
7498                    bulletEl.setAttribute('aria-current', 'true');
7499                } else {
7500                    bulletEl.removeAttribute('aria-current');
7501                }
7502            });
7503        }
7504        const initNavEl = (el, wrapperId, message) => {
7505            makeElFocusable(el);
7506            if (el.tagName !== 'BUTTON') {
7507                addElRole(el, 'button');
7508                el.addEventListener('keydown', onEnterOrSpaceKey);
7509            }
7510            addElLabel(el, message);
7511            addElControls(el, wrapperId);
7512        };
7513        const handlePointerDown = e => {
7514            if (focusTargetSlideEl && focusTargetSlideEl !== e.target && !focusTargetSlideEl.contains(e.target)) {
7515                preventFocusHandler = true;
7516            }
7517            swiper.a11y.clicked = true;
7518        };
7519        const handlePointerUp = () => {
7520            preventFocusHandler = false;
7521            requestAnimationFrame(() => {
7522                requestAnimationFrame(() => {
7523                    if (!swiper.destroyed) {
7524                        swiper.a11y.clicked = false;
7525                    }
7526                });
7527            });
7528        };
7529        const onVisibilityChange = e => {
7530            visibilityChangedTimestamp = new Date().getTime();
7531        };
7532        const handleFocus = e => {
7533            if (swiper.a11y.clicked || !swiper.params.a11y.scrollOnFocus) return;
7534            if (new Date().getTime() - visibilityChangedTimestamp < 100) return;
7535            const slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
7536            if (!slideEl || !swiper.slides.includes(slideEl)) return;
7537            focusTargetSlideEl = slideEl;
7538            const isActive = swiper.slides.indexOf(slideEl) === swiper.activeIndex;
7539            const isVisible = swiper.params.watchSlidesProgress && swiper.visibleSlides && swiper.visibleSlides.includes(slideEl);
7540            if (isActive || isVisible) return;
7541            if (e.sourceCapabilities && e.sourceCapabilities.firesTouchEvents) return;
7542            if (swiper.isHorizontal()) {
7543                swiper.el.scrollLeft = 0;
7544            } else {
7545                swiper.el.scrollTop = 0;
7546            }
7547            requestAnimationFrame(() => {
7548                if (preventFocusHandler) return;
7549                if (swiper.params.loop) {
7550                    swiper.slideToLoop(parseInt(slideEl.getAttribute('data-swiper-slide-index')), 0);
7551                } else {
7552                    swiper.slideTo(swiper.slides.indexOf(slideEl), 0);
7553                }
7554                preventFocusHandler = false;
7555            });
7556        };
7557        const initSlides = () => {
7558            const params = swiper.params.a11y;
7559            if (params.itemRoleDescriptionMessage) {
7560                addElRoleDescription(swiper.slides, params.itemRoleDescriptionMessage);
7561            }
7562            if (params.slideRole) {
7563                addElRole(swiper.slides, params.slideRole);
7564            }
7565            const slidesLength = swiper.slides.length;
7566            if (params.slideLabelMessage) {
7567                swiper.slides.forEach((slideEl, index) => {
7568                    const slideIndex = swiper.params.loop ? parseInt(slideEl.getAttribute('data-swiper-slide-index'), 10) : index;
7569                    const ariaLabelMessage = params.slideLabelMessage.replace(/\{\{index\}\}/, slideIndex + 1).replace(/\{\{slidesLength\}\}/, slidesLength);
7570                    addElLabel(slideEl, ariaLabelMessage);
7571                });
7572            }
7573        };
7574        const init = () => {
7575            const params = swiper.params.a11y;
7576            swiper.el.append(liveRegion);
7577
7578            // Container
7579            const containerEl = swiper.el;
7580            if (params.containerRoleDescriptionMessage) {
7581                addElRoleDescription(containerEl, params.containerRoleDescriptionMessage);
7582            }
7583            if (params.containerMessage) {
7584                addElLabel(containerEl, params.containerMessage);
7585            }
7586            if (params.containerRole) {
7587                addElRole(containerEl, params.containerRole);
7588            }
7589
7590            // Wrapper
7591            const wrapperEl = swiper.wrapperEl;
7592            const wrapperId = params.id || wrapperEl.getAttribute('id') || `swiper-wrapper-${getRandomNumber(16)}`;
7593            const live = swiper.params.autoplay && swiper.params.autoplay.enabled ? 'off' : 'polite';
7594            addElId(wrapperEl, wrapperId);
7595            addElLive(wrapperEl, live);
7596
7597            // Slide
7598            initSlides();
7599
7600            // Navigation
7601            let {
7602                nextEl,
7603                prevEl
7604            } = swiper.navigation ? swiper.navigation : {};
7605            nextEl = makeElementsArray(nextEl);
7606            prevEl = makeElementsArray(prevEl);
7607            if (nextEl) {
7608                nextEl.forEach(el => initNavEl(el, wrapperId, params.nextSlideMessage));
7609            }
7610            if (prevEl) {
7611                prevEl.forEach(el => initNavEl(el, wrapperId, params.prevSlideMessage));
7612            }
7613
7614            // Pagination
7615            if (hasClickablePagination()) {
7616                const paginationEl = makeElementsArray(swiper.pagination.el);
7617                paginationEl.forEach(el => {
7618                    el.addEventListener('keydown', onEnterOrSpaceKey);
7619                });
7620            }
7621
7622            // Tab focus
7623            const document = getDocument();
7624            document.addEventListener('visibilitychange', onVisibilityChange);
7625            swiper.el.addEventListener('focus', handleFocus, true);
7626            swiper.el.addEventListener('focus', handleFocus, true);
7627            swiper.el.addEventListener('pointerdown', handlePointerDown, true);
7628            swiper.el.addEventListener('pointerup', handlePointerUp, true);
7629        };
7630        function destroy() {
7631            if (liveRegion) liveRegion.remove();
7632            let {
7633                nextEl,
7634                prevEl
7635            } = swiper.navigation ? swiper.navigation : {};
7636            nextEl = makeElementsArray(nextEl);
7637            prevEl = makeElementsArray(prevEl);
7638            if (nextEl) {
7639                nextEl.forEach(el => el.removeEventListener('keydown', onEnterOrSpaceKey));
7640            }
7641            if (prevEl) {
7642                prevEl.forEach(el => el.removeEventListener('keydown', onEnterOrSpaceKey));
7643            }
7644
7645            // Pagination
7646            if (hasClickablePagination()) {
7647                const paginationEl = makeElementsArray(swiper.pagination.el);
7648                paginationEl.forEach(el => {
7649                    el.removeEventListener('keydown', onEnterOrSpaceKey);
7650                });
7651            }
7652            const document = getDocument();
7653            document.removeEventListener('visibilitychange', onVisibilityChange);
7654            // Tab focus
7655            if (swiper.el && typeof swiper.el !== 'string') {
7656                swiper.el.removeEventListener('focus', handleFocus, true);
7657                swiper.el.removeEventListener('pointerdown', handlePointerDown, true);
7658                swiper.el.removeEventListener('pointerup', handlePointerUp, true);
7659            }
7660        }
7661        on('beforeInit', () => {
7662            liveRegion = createElement('span', swiper.params.a11y.notificationClass);
7663            liveRegion.setAttribute('aria-live', 'assertive');
7664            liveRegion.setAttribute('aria-atomic', 'true');
7665        });
7666        on('afterInit', () => {
7667            if (!swiper.params.a11y.enabled) return;
7668            init();
7669        });
7670        on('slidesLengthChange snapGridLengthChange slidesGridLengthChange', () => {
7671            if (!swiper.params.a11y.enabled) return;
7672            initSlides();
7673        });
7674        on('fromEdge toEdge afterInit lock unlock', () => {
7675            if (!swiper.params.a11y.enabled) return;
7676            updateNavigation();
7677        });
7678        on('paginationUpdate', () => {
7679            if (!swiper.params.a11y.enabled) return;
7680            updatePagination();
7681        });
7682        on('destroy', () => {
7683            if (!swiper.params.a11y.enabled) return;
7684            destroy();
7685        });
7686    }
7687
7688    function History(_ref) {
7689        let {
7690            swiper,
7691            extendParams,
7692            on
7693        } = _ref;
7694        extendParams({
7695            history: {
7696                enabled: false,
7697                root: '',
7698                replaceState: false,
7699                key: 'slides',
7700                keepQuery: false
7701            }
7702        });
7703        let initialized = false;
7704        let paths = {};
7705        const slugify = text => {
7706            return text.toString().replace(/\s+/g, '-').replace(/[^\w-]+/g, '').replace(/--+/g, '-').replace(/^-+/, '').replace(/-+$/, '');
7707        };
7708        const getPathValues = urlOverride => {
7709            const window = getWindow();
7710            let location;
7711            if (urlOverride) {
7712                location = new URL(urlOverride);
7713            } else {
7714                location = window.location;
7715            }
7716            const pathArray = location.pathname.slice(1).split('/').filter(part => part !== '');
7717            const total = pathArray.length;
7718            const key = pathArray[total - 2];
7719            const value = pathArray[total - 1];
7720            return {
7721                key,
7722                value
7723            };
7724        };
7725        const setHistory = (key, index) => {
7726            const window = getWindow();
7727            if (!initialized || !swiper.params.history.enabled) return;
7728            let location;
7729            if (swiper.params.url) {
7730                location = new URL(swiper.params.url);
7731            } else {
7732                location = window.location;
7733            }
7734            const slide = swiper.virtual && swiper.params.virtual.enabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${index}"]`) : swiper.slides[index];
7735            let value = slugify(slide.getAttribute('data-history'));
7736            if (swiper.params.history.root.length > 0) {
7737                let root = swiper.params.history.root;
7738                if (root[root.length - 1] === '/') root = root.slice(0, root.length - 1);
7739                value = `${root}/${key ? `${key}/` : ''}${value}`;
7740            } else if (!location.pathname.includes(key)) {
7741                value = `${key ? `${key}/` : ''}${value}`;
7742            }
7743            if (swiper.params.history.keepQuery) {
7744                value += location.search;
7745            }
7746            const currentState = window.history.state;
7747            if (currentState && currentState.value === value) {
7748                return;
7749            }
7750            if (swiper.params.history.replaceState) {
7751                window.history.replaceState({
7752                    value
7753                }, null, value);
7754            } else {
7755                window.history.pushState({
7756                    value
7757                }, null, value);
7758            }
7759        };
7760        const scrollToSlide = (speed, value, runCallbacks) => {
7761            if (value) {
7762                for (let i = 0, length = swiper.slides.length; i < length; i += 1) {
7763                    const slide = swiper.slides[i];
7764                    const slideHistory = slugify(slide.getAttribute('data-history'));
7765                    if (slideHistory === value) {
7766                        const index = swiper.getSlideIndex(slide);
7767                        swiper.slideTo(index, speed, runCallbacks);
7768                    }
7769                }
7770            } else {
7771                swiper.slideTo(0, speed, runCallbacks);
7772            }
7773        };
7774        const setHistoryPopState = () => {
7775            paths = getPathValues(swiper.params.url);
7776            scrollToSlide(swiper.params.speed, paths.value, false);
7777        };
7778        const init = () => {
7779            const window = getWindow();
7780            if (!swiper.params.history) return;
7781            if (!window.history || !window.history.pushState) {
7782                swiper.params.history.enabled = false;
7783                swiper.params.hashNavigation.enabled = true;
7784                return;
7785            }
7786            initialized = true;
7787            paths = getPathValues(swiper.params.url);
7788            if (!paths.key && !paths.value) {
7789                if (!swiper.params.history.replaceState) {
7790                    window.addEventListener('popstate', setHistoryPopState);
7791                }
7792                return;
7793            }
7794            scrollToSlide(0, paths.value, swiper.params.runCallbacksOnInit);
7795            if (!swiper.params.history.replaceState) {
7796                window.addEventListener('popstate', setHistoryPopState);
7797            }
7798        };
7799        const destroy = () => {
7800            const window = getWindow();
7801            if (!swiper.params.history.replaceState) {
7802                window.removeEventListener('popstate', setHistoryPopState);
7803            }
7804        };
7805        on('init', () => {
7806            if (swiper.params.history.enabled) {
7807                init();
7808            }
7809        });
7810        on('destroy', () => {
7811            if (swiper.params.history.enabled) {
7812                destroy();
7813            }
7814        });
7815        on('transitionEnd _freeModeNoMomentumRelease', () => {
7816            if (initialized) {
7817                setHistory(swiper.params.history.key, swiper.activeIndex);
7818            }
7819        });
7820        on('slideChange', () => {
7821            if (initialized && swiper.params.cssMode) {
7822                setHistory(swiper.params.history.key, swiper.activeIndex);
7823            }
7824        });
7825    }
7826
7827    function HashNavigation(_ref) {
7828        let {
7829            swiper,
7830            extendParams,
7831            emit,
7832            on
7833        } = _ref;
7834        let initialized = false;
7835        const document = getDocument();
7836        const window = getWindow();
7837        extendParams({
7838            hashNavigation: {
7839                enabled: false,
7840                replaceState: false,
7841                watchState: false,
7842                getSlideIndex(_s, hash) {
7843                    if (swiper.virtual && swiper.params.virtual.enabled) {
7844                        const slideWithHash = swiper.slides.find(slideEl => slideEl.getAttribute('data-hash') === hash);
7845                        if (!slideWithHash) return 0;
7846                        const index = parseInt(slideWithHash.getAttribute('data-swiper-slide-index'), 10);
7847                        return index;
7848                    }
7849                    return swiper.getSlideIndex(elementChildren(swiper.slidesEl, `.${swiper.params.slideClass}[data-hash="${hash}"], swiper-slide[data-hash="${hash}"]`)[0]);
7850                }
7851            }
7852        });
7853        const onHashChange = () => {
7854            emit('hashChange');
7855            const newHash = document.location.hash.replace('#', '');
7856            const activeSlideEl = swiper.virtual && swiper.params.virtual.enabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${swiper.activeIndex}"]`) : swiper.slides[swiper.activeIndex];
7857            const activeSlideHash = activeSlideEl ? activeSlideEl.getAttribute('data-hash') : '';
7858            if (newHash !== activeSlideHash) {
7859                const newIndex = swiper.params.hashNavigation.getSlideIndex(swiper, newHash);
7860                if (typeof newIndex === 'undefined' || Number.isNaN(newIndex)) return;
7861                swiper.slideTo(newIndex);
7862            }
7863        };
7864        const setHash = () => {
7865            if (!initialized || !swiper.params.hashNavigation.enabled) return;
7866            const activeSlideEl = swiper.virtual && swiper.params.virtual.enabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${swiper.activeIndex}"]`) : swiper.slides[swiper.activeIndex];
7867            const activeSlideHash = activeSlideEl ? activeSlideEl.getAttribute('data-hash') || activeSlideEl.getAttribute('data-history') : '';
7868            if (swiper.params.hashNavigation.replaceState && window.history && window.history.replaceState) {
7869                window.history.replaceState(null, null, `#${activeSlideHash}` || '');
7870                emit('hashSet');
7871            } else {
7872                document.location.hash = activeSlideHash || '';
7873                emit('hashSet');
7874            }
7875        };
7876        const init = () => {
7877            if (!swiper.params.hashNavigation.enabled || swiper.params.history && swiper.params.history.enabled) return;
7878            initialized = true;
7879            const hash = document.location.hash.replace('#', '');
7880            if (hash) {
7881                const speed = 0;
7882                const index = swiper.params.hashNavigation.getSlideIndex(swiper, hash);
7883                swiper.slideTo(index || 0, speed, swiper.params.runCallbacksOnInit, true);
7884            }
7885            if (swiper.params.hashNavigation.watchState) {
7886                window.addEventListener('hashchange', onHashChange);
7887            }
7888        };
7889        const destroy = () => {
7890            if (swiper.params.hashNavigation.watchState) {
7891                window.removeEventListener('hashchange', onHashChange);
7892            }
7893        };
7894        on('init', () => {
7895            if (swiper.params.hashNavigation.enabled) {
7896                init();
7897            }
7898        });
7899        on('destroy', () => {
7900            if (swiper.params.hashNavigation.enabled) {
7901                destroy();
7902            }
7903        });
7904        on('transitionEnd _freeModeNoMomentumRelease', () => {
7905            if (initialized) {
7906                setHash();
7907            }
7908        });
7909        on('slideChange', () => {
7910            if (initialized && swiper.params.cssMode) {
7911                setHash();
7912            }
7913        });
7914    }
7915
7916    /* eslint no-underscore-dangle: "off" */

vendor: 6,684 bytes, lines 7917-8079

7917    /* eslint no-use-before-define: "off" */
7918    function Autoplay(_ref) {
7919        let {
7920            swiper,
7921            extendParams,
7922            on,
7923            emit,
7924            params
7925        } = _ref;
7926        swiper.autoplay = {
7927            running: false,
7928            paused: false,
7929            timeLeft: 0
7930        };
7931        extendParams({
7932            autoplay: {
7933                enabled: false,
7934                delay: 3000,
7935                waitForTransition: true,
7936                disableOnInteraction: false,
7937                stopOnLastSlide: false,
7938                reverseDirection: false,
7939                pauseOnMouseEnter: false
7940            }
7941        });
7942        let timeout;
7943        let raf;
7944        let autoplayDelayTotal = params && params.autoplay ? params.autoplay.delay : 3000;
7945        let autoplayDelayCurrent = params && params.autoplay ? params.autoplay.delay : 3000;
7946        let autoplayTimeLeft;
7947        let autoplayStartTime = new Date().getTime();
7948        let wasPaused;
7949        let isTouched;
7950        let pausedByTouch;
7951        let touchStartTimeout;
7952        let slideChanged;
7953        let pausedByInteraction;
7954        let pausedByPointerEnter;
7955        function onTransitionEnd(e) {
7956            if (!swiper || swiper.destroyed || !swiper.wrapperEl) return;
7957            if (e.target !== swiper.wrapperEl) return;
7958            swiper.wrapperEl.removeEventListener('transitionend', onTransitionEnd);
7959            if (pausedByPointerEnter || e.detail && e.detail.bySwiperTouchMove) {
7960                return;
7961            }
7962            resume();
7963        }
7964        const calcTimeLeft = () => {
7965            if (swiper.destroyed || !swiper.autoplay.running) return;
7966            if (swiper.autoplay.paused) {
7967                wasPaused = true;
7968            } else if (wasPaused) {
7969                autoplayDelayCurrent = autoplayTimeLeft;
7970                wasPaused = false;
7971            }
7972            const timeLeft = swiper.autoplay.paused ? autoplayTimeLeft : autoplayStartTime + autoplayDelayCurrent - new Date().getTime();
7973            swiper.autoplay.timeLeft = timeLeft;
7974            emit('autoplayTimeLeft', timeLeft, timeLeft / autoplayDelayTotal);
7975            raf = requestAnimationFrame(() => {
7976                calcTimeLeft();
7977            });
7978        };
7979        const getSlideDelay = () => {
7980            let activeSlideEl;
7981            if (swiper.virtual && swiper.params.virtual.enabled) {
7982                activeSlideEl = swiper.slides.find(slideEl => slideEl.classList.contains('swiper-slide-active'));
7983            } else {
7984                activeSlideEl = swiper.slides[swiper.activeIndex];
7985            }
7986            if (!activeSlideEl) return undefined;
7987            const currentSlideDelay = parseInt(activeSlideEl.getAttribute('data-swiper-autoplay'), 10);
7988            return currentSlideDelay;
7989        };
7990        const run = delayForce => {
7991            if (swiper.destroyed || !swiper.autoplay.running) return;
7992            cancelAnimationFrame(raf);
7993            calcTimeLeft();
7994            let delay = typeof delayForce === 'undefined' ? swiper.params.autoplay.delay : delayForce;
7995            autoplayDelayTotal = swiper.params.autoplay.delay;
7996            autoplayDelayCurrent = swiper.params.autoplay.delay;
7997            const currentSlideDelay = getSlideDelay();
7998            if (!Number.isNaN(currentSlideDelay) && currentSlideDelay > 0 && typeof delayForce === 'undefined') {
7999                delay = currentSlideDelay;
8000                autoplayDelayTotal = currentSlideDelay;
8001                autoplayDelayCurrent = currentSlideDelay;
8002            }
8003            autoplayTimeLeft = delay;
8004            const speed = swiper.params.speed;
8005            const proceed = () => {
8006                if (!swiper || swiper.destroyed) return;
8007                if (swiper.params.autoplay.reverseDirection) {
8008                    if (!swiper.isBeginning || swiper.params.loop || swiper.params.rewind) {
8009                        swiper.slidePrev(speed, true, true);
8010                        emit('autoplay');
8011                    } else if (!swiper.params.autoplay.stopOnLastSlide) {
8012                        swiper.slideTo(swiper.slides.length - 1, speed, true, true);
8013                        emit('autoplay');
8014                    }
8015                } else {
8016                    if (!swiper.isEnd || swiper.params.loop || swiper.params.rewind) {
8017                        swiper.slideNext(speed, true, true);
8018                        emit('autoplay');
8019                    } else if (!swiper.params.autoplay.stopOnLastSlide) {
8020                        swiper.slideTo(0, speed, true, true);
8021                        emit('autoplay');
8022                    }
8023                }
8024                if (swiper.params.cssMode) {
8025                    autoplayStartTime = new Date().getTime();
8026                    requestAnimationFrame(() => {
8027                        run();
8028                    });
8029                }
8030            };
8031            if (delay > 0) {
8032                clearTimeout(timeout);
8033                timeout = setTimeout(() => {
8034                    proceed();
8035                }, delay);
8036            } else {
8037                requestAnimationFrame(() => {
8038                    proceed();
8039                });
8040            }
8041
8042            // eslint-disable-next-line
8043            return delay;
8044        };
8045        const start = () => {
8046            autoplayStartTime = new Date().getTime();
8047            swiper.autoplay.running = true;
8048            run();
8049            emit('autoplayStart');
8050        };
8051        const stop = () => {
8052            swiper.autoplay.running = false;
8053            clearTimeout(timeout);
8054            cancelAnimationFrame(raf);
8055            emit('autoplayStop');
8056        };
8057        const pause = (internal, reset) => {
8058            if (swiper.destroyed || !swiper.autoplay.running) return;
8059            clearTimeout(timeout);
8060            if (!internal) {
8061                pausedByInteraction = true;
8062            }
8063            const proceed = () => {
8064                emit('autoplayPause');
8065                if (swiper.params.autoplay.waitForTransition) {
8066                    swiper.wrapperEl.addEventListener('transitionend', onTransitionEnd);
8067                } else {
8068                    resume();
8069                }
8070            };
8071            swiper.autoplay.paused = true;
8072            if (reset) {
8073                if (slideChanged) {
8074                    autoplayTimeLeft = swiper.params.autoplay.delay;
8075                }
8076                slideChanged = false;
8077                proceed();
8078                return;
8079            }

vendor: 25,750 bytes, lines 8080-8655

8080            const delay = autoplayTimeLeft || swiper.params.autoplay.delay;
8081            autoplayTimeLeft = delay - (new Date().getTime() - autoplayStartTime);
8082            if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop) return;
8083            if (autoplayTimeLeft < 0) autoplayTimeLeft = 0;
8084            proceed();
8085        };
8086        const resume = () => {
8087            if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop || swiper.destroyed || !swiper.autoplay.running) return;
8088            autoplayStartTime = new Date().getTime();
8089            if (pausedByInteraction) {
8090                pausedByInteraction = false;
8091                run(autoplayTimeLeft);
8092            } else {
8093                run();
8094            }
8095            swiper.autoplay.paused = false;
8096            emit('autoplayResume');
8097        };
8098        const onVisibilityChange = () => {
8099            if (swiper.destroyed || !swiper.autoplay.running) return;
8100            const document = getDocument();
8101            if (document.visibilityState === 'hidden') {
8102                pausedByInteraction = true;
8103                pause(true);
8104            }
8105            if (document.visibilityState === 'visible') {
8106                resume();
8107            }
8108        };
8109        const onPointerEnter = e => {
8110            if (e.pointerType !== 'mouse') return;
8111            pausedByInteraction = true;
8112            pausedByPointerEnter = true;
8113            if (swiper.animating || swiper.autoplay.paused) return;
8114            pause(true);
8115        };
8116        const onPointerLeave = e => {
8117            if (e.pointerType !== 'mouse') return;
8118            pausedByPointerEnter = false;
8119            if (swiper.autoplay.paused) {
8120                resume();
8121            }
8122        };
8123        const attachMouseEvents = () => {
8124            if (swiper.params.autoplay.pauseOnMouseEnter) {
8125                swiper.el.addEventListener('pointerenter', onPointerEnter);
8126                swiper.el.addEventListener('pointerleave', onPointerLeave);
8127            }
8128        };
8129        const detachMouseEvents = () => {
8130            if (swiper.el && typeof swiper.el !== 'string') {
8131                swiper.el.removeEventListener('pointerenter', onPointerEnter);
8132                swiper.el.removeEventListener('pointerleave', onPointerLeave);
8133            }
8134        };
8135        const attachDocumentEvents = () => {
8136            const document = getDocument();
8137            document.addEventListener('visibilitychange', onVisibilityChange);
8138        };
8139        const detachDocumentEvents = () => {
8140            const document = getDocument();
8141            document.removeEventListener('visibilitychange', onVisibilityChange);
8142        };
8143        on('init', () => {
8144            if (swiper.params.autoplay.enabled) {
8145                attachMouseEvents();
8146                attachDocumentEvents();
8147                start();
8148            }
8149        });
8150        on('destroy', () => {
8151            detachMouseEvents();
8152            detachDocumentEvents();
8153            if (swiper.autoplay.running) {
8154                stop();
8155            }
8156        });
8157        on('_freeModeStaticRelease', () => {
8158            if (pausedByTouch || pausedByInteraction) {
8159                resume();
8160            }
8161        });
8162        on('_freeModeNoMomentumRelease', () => {
8163            if (!swiper.params.autoplay.disableOnInteraction) {
8164                pause(true, true);
8165            } else {
8166                stop();
8167            }
8168        });
8169        on('beforeTransitionStart', (_s, speed, internal) => {
8170            if (swiper.destroyed || !swiper.autoplay.running) return;
8171            if (internal || !swiper.params.autoplay.disableOnInteraction) {
8172                pause(true, true);
8173            } else {
8174                stop();
8175            }
8176        });
8177        on('sliderFirstMove', () => {
8178            if (swiper.destroyed || !swiper.autoplay.running) return;
8179            if (swiper.params.autoplay.disableOnInteraction) {
8180                stop();
8181                return;
8182            }
8183            isTouched = true;
8184            pausedByTouch = false;
8185            pausedByInteraction = false;
8186            touchStartTimeout = setTimeout(() => {
8187                pausedByInteraction = true;
8188                pausedByTouch = true;
8189                pause(true);
8190            }, 200);
8191        });
8192        on('touchEnd', () => {
8193            if (swiper.destroyed || !swiper.autoplay.running || !isTouched) return;
8194            clearTimeout(touchStartTimeout);
8195            clearTimeout(timeout);
8196            if (swiper.params.autoplay.disableOnInteraction) {
8197                pausedByTouch = false;
8198                isTouched = false;
8199                return;
8200            }
8201            if (pausedByTouch && swiper.params.cssMode) resume();
8202            pausedByTouch = false;
8203            isTouched = false;
8204        });
8205        on('slideChange', () => {
8206            if (swiper.destroyed || !swiper.autoplay.running) return;
8207            slideChanged = true;
8208        });
8209        Object.assign(swiper.autoplay, {
8210            start,
8211            stop,
8212            pause,
8213            resume
8214        });
8215    }
8216
8217    function Thumb(_ref) {
8218        let {
8219            swiper,
8220            extendParams,
8221            on
8222        } = _ref;
8223        extendParams({
8224            thumbs: {
8225                swiper: null,
8226                multipleActiveThumbs: true,
8227                autoScrollOffset: 0,
8228                slideThumbActiveClass: 'swiper-slide-thumb-active',
8229                thumbsContainerClass: 'swiper-thumbs'
8230            }
8231        });
8232        let initialized = false;
8233        let swiperCreated = false;
8234        swiper.thumbs = {
8235            swiper: null
8236        };
8237        function onThumbClick() {
8238            const thumbsSwiper = swiper.thumbs.swiper;
8239            if (!thumbsSwiper || thumbsSwiper.destroyed) return;
8240            const clickedIndex = thumbsSwiper.clickedIndex;
8241            const clickedSlide = thumbsSwiper.clickedSlide;
8242            if (clickedSlide && clickedSlide.classList.contains(swiper.params.thumbs.slideThumbActiveClass)) return;
8243            if (typeof clickedIndex === 'undefined' || clickedIndex === null) return;
8244            let slideToIndex;
8245            if (thumbsSwiper.params.loop) {
8246                slideToIndex = parseInt(thumbsSwiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
8247            } else {
8248                slideToIndex = clickedIndex;
8249            }
8250            if (swiper.params.loop) {
8251                swiper.slideToLoop(slideToIndex);
8252            } else {
8253                swiper.slideTo(slideToIndex);
8254            }
8255        }
8256        function init() {
8257            const {
8258                thumbs: thumbsParams
8259            } = swiper.params;
8260            if (initialized) return false;
8261            initialized = true;
8262            const SwiperClass = swiper.constructor;
8263            if (thumbsParams.swiper instanceof SwiperClass) {
8264                if (thumbsParams.swiper.destroyed) {
8265                    initialized = false;
8266                    return false;
8267                }
8268                swiper.thumbs.swiper = thumbsParams.swiper;
8269                Object.assign(swiper.thumbs.swiper.originalParams, {
8270                    watchSlidesProgress: true,
8271                    slideToClickedSlide: false
8272                });
8273                Object.assign(swiper.thumbs.swiper.params, {
8274                    watchSlidesProgress: true,
8275                    slideToClickedSlide: false
8276                });
8277                swiper.thumbs.swiper.update();
8278            } else if (isObject(thumbsParams.swiper)) {
8279                const thumbsSwiperParams = Object.assign({}, thumbsParams.swiper);
8280                Object.assign(thumbsSwiperParams, {
8281                    watchSlidesProgress: true,
8282                    slideToClickedSlide: false
8283                });
8284                swiper.thumbs.swiper = new SwiperClass(thumbsSwiperParams);
8285                swiperCreated = true;
8286            }
8287            swiper.thumbs.swiper.el.classList.add(swiper.params.thumbs.thumbsContainerClass);
8288            swiper.thumbs.swiper.on('tap', onThumbClick);
8289            return true;
8290        }
8291        function update(initial) {
8292            const thumbsSwiper = swiper.thumbs.swiper;
8293            if (!thumbsSwiper || thumbsSwiper.destroyed) return;
8294            const slidesPerView = thumbsSwiper.params.slidesPerView === 'auto' ? thumbsSwiper.slidesPerViewDynamic() : thumbsSwiper.params.slidesPerView;
8295
8296            // Activate thumbs
8297            let thumbsToActivate = 1;
8298            const thumbActiveClass = swiper.params.thumbs.slideThumbActiveClass;
8299            if (swiper.params.slidesPerView > 1 && !swiper.params.centeredSlides) {
8300                thumbsToActivate = swiper.params.slidesPerView;
8301            }
8302            if (!swiper.params.thumbs.multipleActiveThumbs) {
8303                thumbsToActivate = 1;
8304            }
8305            thumbsToActivate = Math.floor(thumbsToActivate);
8306            thumbsSwiper.slides.forEach(slideEl => slideEl.classList.remove(thumbActiveClass));
8307            if (thumbsSwiper.params.loop || thumbsSwiper.params.virtual && thumbsSwiper.params.virtual.enabled) {
8308                for (let i = 0; i < thumbsToActivate; i += 1) {
8309                    elementChildren(thumbsSwiper.slidesEl, `[data-swiper-slide-index="${swiper.realIndex + i}"]`).forEach(slideEl => {
8310                        slideEl.classList.add(thumbActiveClass);
8311                    });
8312                }
8313            } else {
8314                for (let i = 0; i < thumbsToActivate; i += 1) {
8315                    if (thumbsSwiper.slides[swiper.realIndex + i]) {
8316                        thumbsSwiper.slides[swiper.realIndex + i].classList.add(thumbActiveClass);
8317                    }
8318                }
8319            }
8320            const autoScrollOffset = swiper.params.thumbs.autoScrollOffset;
8321            const useOffset = autoScrollOffset && !thumbsSwiper.params.loop;
8322            if (swiper.realIndex !== thumbsSwiper.realIndex || useOffset) {
8323                const currentThumbsIndex = thumbsSwiper.activeIndex;
8324                let newThumbsIndex;
8325                let direction;
8326                if (thumbsSwiper.params.loop) {
8327                    const newThumbsSlide = thumbsSwiper.slides.find(slideEl => slideEl.getAttribute('data-swiper-slide-index') === `${swiper.realIndex}`);
8328                    newThumbsIndex = thumbsSwiper.slides.indexOf(newThumbsSlide);
8329                    direction = swiper.activeIndex > swiper.previousIndex ? 'next' : 'prev';
8330                } else {
8331                    newThumbsIndex = swiper.realIndex;
8332                    direction = newThumbsIndex > swiper.previousIndex ? 'next' : 'prev';
8333                }
8334                if (useOffset) {
8335                    newThumbsIndex += direction === 'next' ? autoScrollOffset : -1 * autoScrollOffset;
8336                }
8337                if (thumbsSwiper.visibleSlidesIndexes && thumbsSwiper.visibleSlidesIndexes.indexOf(newThumbsIndex) < 0) {
8338                    if (thumbsSwiper.params.centeredSlides) {
8339                        if (newThumbsIndex > currentThumbsIndex) {
8340                            newThumbsIndex = newThumbsIndex - Math.floor(slidesPerView / 2) + 1;
8341                        } else {
8342                            newThumbsIndex = newThumbsIndex + Math.floor(slidesPerView / 2) - 1;
8343                        }
8344                    } else if (newThumbsIndex > currentThumbsIndex && thumbsSwiper.params.slidesPerGroup === 1) ;
8345                    thumbsSwiper.slideTo(newThumbsIndex, initial ? 0 : undefined);
8346                }
8347            }
8348        }
8349        on('beforeInit', () => {
8350            const {
8351                thumbs
8352            } = swiper.params;
8353            if (!thumbs || !thumbs.swiper) return;
8354            if (typeof thumbs.swiper === 'string' || thumbs.swiper instanceof HTMLElement) {
8355                const document = getDocument();
8356                const getThumbsElementAndInit = () => {
8357                    const thumbsElement = typeof thumbs.swiper === 'string' ? document.querySelector(thumbs.swiper) : thumbs.swiper;
8358                    if (thumbsElement && thumbsElement.swiper) {
8359                        thumbs.swiper = thumbsElement.swiper;
8360                        init();
8361                        update(true);
8362                    } else if (thumbsElement) {
8363                        const eventName = `${swiper.params.eventsPrefix}init`;
8364                        const onThumbsSwiper = e => {
8365                            thumbs.swiper = e.detail[0];
8366                            thumbsElement.removeEventListener(eventName, onThumbsSwiper);
8367                            init();
8368                            update(true);
8369                            thumbs.swiper.update();
8370                            swiper.update();
8371                        };
8372                        thumbsElement.addEventListener(eventName, onThumbsSwiper);
8373                    }
8374                    return thumbsElement;
8375                };
8376                const watchForThumbsToAppear = () => {
8377                    if (swiper.destroyed) return;
8378                    const thumbsElement = getThumbsElementAndInit();
8379                    if (!thumbsElement) {
8380                        requestAnimationFrame(watchForThumbsToAppear);
8381                    }
8382                };
8383                requestAnimationFrame(watchForThumbsToAppear);
8384            } else {
8385                init();
8386                update(true);
8387            }
8388        });
8389        on('slideChange update resize observerUpdate', () => {
8390            update();
8391        });
8392        on('setTransition', (_s, duration) => {
8393            const thumbsSwiper = swiper.thumbs.swiper;
8394            if (!thumbsSwiper || thumbsSwiper.destroyed) return;
8395            thumbsSwiper.setTransition(duration);
8396        });
8397        on('beforeDestroy', () => {
8398            const thumbsSwiper = swiper.thumbs.swiper;
8399            if (!thumbsSwiper || thumbsSwiper.destroyed) return;
8400            if (swiperCreated) {
8401                thumbsSwiper.destroy();
8402            }
8403        });
8404        Object.assign(swiper.thumbs, {
8405            init,
8406            update
8407        });
8408    }
8409
8410    function freeMode(_ref) {
8411        let {
8412            swiper,
8413            extendParams,
8414            emit,
8415            once
8416        } = _ref;
8417        extendParams({
8418            freeMode: {
8419                enabled: false,
8420                momentum: true,
8421                momentumRatio: 1,
8422                momentumBounce: true,
8423                momentumBounceRatio: 1,
8424                momentumVelocityRatio: 1,
8425                sticky: false,
8426                minimumVelocity: 0.02
8427            }
8428        });
8429        function onTouchStart() {
8430            if (swiper.params.cssMode) return;
8431            const translate = swiper.getTranslate();
8432            swiper.setTranslate(translate);
8433            swiper.setTransition(0);
8434            swiper.touchEventsData.velocities.length = 0;
8435            swiper.freeMode.onTouchEnd({
8436                currentPos: swiper.rtl ? swiper.translate : -swiper.translate
8437            });
8438        }
8439        function onTouchMove() {
8440            if (swiper.params.cssMode) return;
8441            const {
8442                touchEventsData: data,
8443                touches
8444            } = swiper;
8445            // Velocity
8446            if (data.velocities.length === 0) {
8447                data.velocities.push({
8448                    position: touches[swiper.isHorizontal() ? 'startX' : 'startY'],
8449                    time: data.touchStartTime
8450                });
8451            }
8452            data.velocities.push({
8453                position: touches[swiper.isHorizontal() ? 'currentX' : 'currentY'],
8454                time: now()
8455            });
8456        }
8457        function onTouchEnd(_ref2) {
8458            let {
8459                currentPos
8460            } = _ref2;
8461            if (swiper.params.cssMode) return;
8462            const {
8463                params,
8464                wrapperEl,
8465                rtlTranslate: rtl,
8466                snapGrid,
8467                touchEventsData: data
8468            } = swiper;
8469            // Time diff
8470            const touchEndTime = now();
8471            const timeDiff = touchEndTime - data.touchStartTime;
8472            if (currentPos < -swiper.minTranslate()) {
8473                swiper.slideTo(swiper.activeIndex);
8474                return;
8475            }
8476            if (currentPos > -swiper.maxTranslate()) {
8477                if (swiper.slides.length < snapGrid.length) {
8478                    swiper.slideTo(snapGrid.length - 1);
8479                } else {
8480                    swiper.slideTo(swiper.slides.length - 1);
8481                }
8482                return;
8483            }
8484            if (params.freeMode.momentum) {
8485                if (data.velocities.length > 1) {
8486                    const lastMoveEvent = data.velocities.pop();
8487                    const velocityEvent = data.velocities.pop();
8488                    const distance = lastMoveEvent.position - velocityEvent.position;
8489                    const time = lastMoveEvent.time - velocityEvent.time;
8490                    swiper.velocity = distance / time;
8491                    swiper.velocity /= 2;
8492                    if (Math.abs(swiper.velocity) < params.freeMode.minimumVelocity) {
8493                        swiper.velocity = 0;
8494                    }
8495                    // this implies that the user stopped moving a finger then released.
8496                    // There would be no events with distance zero, so the last event is stale.
8497                    if (time > 150 || now() - lastMoveEvent.time > 300) {
8498                        swiper.velocity = 0;
8499                    }
8500                } else {
8501                    swiper.velocity = 0;
8502                }
8503                swiper.velocity *= params.freeMode.momentumVelocityRatio;
8504                data.velocities.length = 0;
8505                let momentumDuration = 1000 * params.freeMode.momentumRatio;
8506                const momentumDistance = swiper.velocity * momentumDuration;
8507                let newPosition = swiper.translate + momentumDistance;
8508                if (rtl) newPosition = -newPosition;
8509                let doBounce = false;
8510                let afterBouncePosition;
8511                const bounceAmount = Math.abs(swiper.velocity) * 20 * params.freeMode.momentumBounceRatio;
8512                let needsLoopFix;
8513                if (newPosition < swiper.maxTranslate()) {
8514                    if (params.freeMode.momentumBounce) {
8515                        if (newPosition + swiper.maxTranslate() < -bounceAmount) {
8516                            newPosition = swiper.maxTranslate() - bounceAmount;
8517                        }
8518                        afterBouncePosition = swiper.maxTranslate();
8519                        doBounce = true;
8520                        data.allowMomentumBounce = true;
8521                    } else {
8522                        newPosition = swiper.maxTranslate();
8523                    }
8524                    if (params.loop && params.centeredSlides) needsLoopFix = true;
8525                } else if (newPosition > swiper.minTranslate()) {
8526                    if (params.freeMode.momentumBounce) {
8527                        if (newPosition - swiper.minTranslate() > bounceAmount) {
8528                            newPosition = swiper.minTranslate() + bounceAmount;
8529                        }
8530                        afterBouncePosition = swiper.minTranslate();
8531                        doBounce = true;
8532                        data.allowMomentumBounce = true;
8533                    } else {
8534                        newPosition = swiper.minTranslate();
8535                    }
8536                    if (params.loop && params.centeredSlides) needsLoopFix = true;
8537                } else if (params.freeMode.sticky) {
8538                    let nextSlide;
8539                    for (let j = 0; j < snapGrid.length; j += 1) {
8540                        if (snapGrid[j] > -newPosition) {
8541                            nextSlide = j;
8542                            break;
8543                        }
8544                    }
8545                    if (Math.abs(snapGrid[nextSlide] - newPosition) < Math.abs(snapGrid[nextSlide - 1] - newPosition) || swiper.swipeDirection === 'next') {
8546                        newPosition = snapGrid[nextSlide];
8547                    } else {
8548                        newPosition = snapGrid[nextSlide - 1];
8549                    }
8550                    newPosition = -newPosition;
8551                }
8552                if (needsLoopFix) {
8553                    once('transitionEnd', () => {
8554                        swiper.loopFix();
8555                    });
8556                }
8557                // Fix duration
8558                if (swiper.velocity !== 0) {
8559                    if (rtl) {
8560                        momentumDuration = Math.abs((-newPosition - swiper.translate) / swiper.velocity);
8561                    } else {
8562                        momentumDuration = Math.abs((newPosition - swiper.translate) / swiper.velocity);
8563                    }
8564                    if (params.freeMode.sticky) {
8565                        // If freeMode.sticky is active and the user ends a swipe with a slow-velocity
8566                        // event, then durations can be 20+ seconds to slide one (or zero!) slides.
8567                        // It's easy to see this when simulating touch with mouse events. To fix this,
8568                        // limit single-slide swipes to the default slide duration. This also has the
8569                        // nice side effect of matching slide speed if the user stopped moving before
8570                        // lifting finger or mouse vs. moving slowly before lifting the finger/mouse.
8571                        // For faster swipes, also apply limits (albeit higher ones).
8572                        const moveDistance = Math.abs((rtl ? -newPosition : newPosition) - swiper.translate);
8573                        const currentSlideSize = swiper.slidesSizesGrid[swiper.activeIndex];
8574                        if (moveDistance < currentSlideSize) {
8575                            momentumDuration = params.speed;
8576                        } else if (moveDistance < 2 * currentSlideSize) {
8577                            momentumDuration = params.speed * 1.5;
8578                        } else {
8579                            momentumDuration = params.speed * 2.5;
8580                        }
8581                    }
8582                } else if (params.freeMode.sticky) {
8583                    swiper.slideToClosest();
8584                    return;
8585                }
8586                if (params.freeMode.momentumBounce && doBounce) {
8587                    swiper.updateProgress(afterBouncePosition);
8588                    swiper.setTransition(momentumDuration);
8589                    swiper.setTranslate(newPosition);
8590                    swiper.transitionStart(true, swiper.swipeDirection);
8591                    swiper.animating = true;
8592                    elementTransitionEnd(wrapperEl, () => {
8593                        if (!swiper || swiper.destroyed || !data.allowMomentumBounce) return;
8594                        emit('momentumBounce');
8595                        swiper.setTransition(params.speed);
8596                        setTimeout(() => {
8597                            swiper.setTranslate(afterBouncePosition);
8598                            elementTransitionEnd(wrapperEl, () => {
8599                                if (!swiper || swiper.destroyed) return;
8600                                swiper.transitionEnd();
8601                            });
8602                        }, 0);
8603                    });
8604                } else if (swiper.velocity) {
8605                    emit('_freeModeNoMomentumRelease');
8606                    swiper.updateProgress(newPosition);
8607                    swiper.setTransition(momentumDuration);
8608                    swiper.setTranslate(newPosition);
8609                    swiper.transitionStart(true, swiper.swipeDirection);
8610                    if (!swiper.animating) {
8611                        swiper.animating = true;
8612                        elementTransitionEnd(wrapperEl, () => {
8613                            if (!swiper || swiper.destroyed) return;
8614                            swiper.transitionEnd();
8615                        });
8616                    }
8617                } else {
8618                    swiper.updateProgress(newPosition);
8619                }
8620                swiper.updateActiveIndex();
8621                swiper.updateSlidesClasses();
8622            } else if (params.freeMode.sticky) {
8623                swiper.slideToClosest();
8624                return;
8625            } else if (params.freeMode) {
8626                emit('_freeModeNoMomentumRelease');
8627            }
8628            if (!params.freeMode.momentum || timeDiff >= params.longSwipesMs) {
8629                emit('_freeModeStaticRelease');
8630                swiper.updateProgress();
8631                swiper.updateActiveIndex();
8632                swiper.updateSlidesClasses();
8633            }
8634        }
8635        Object.assign(swiper, {
8636            freeMode: {
8637                onTouchStart,
8638                onTouchMove,
8639                onTouchEnd
8640            }
8641        });
8642    }
8643
8644    function Grid(_ref) {
8645        let {
8646            swiper,
8647            extendParams,
8648            on
8649        } = _ref;
8650        extendParams({
8651            grid: {
8652                rows: 1,
8653                fill: 'column'
8654            }
8655        });

vendor: 1,569 bytes, lines 8656-8690

8656        let slidesNumberEvenToRows;
8657        let slidesPerRow;
8658        let numFullColumns;
8659        let wasMultiRow;
8660        const getSpaceBetween = () => {
8661            let spaceBetween = swiper.params.spaceBetween;
8662            if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
8663                spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;
8664            } else if (typeof spaceBetween === 'string') {
8665                spaceBetween = parseFloat(spaceBetween);
8666            }
8667            return spaceBetween;
8668        };
8669        const initSlides = slides => {
8670            const {
8671                slidesPerView
8672            } = swiper.params;
8673            const {
8674                rows,
8675                fill
8676            } = swiper.params.grid;
8677            const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : slides.length;
8678            numFullColumns = Math.floor(slidesLength / rows);
8679            if (Math.floor(slidesLength / rows) === slidesLength / rows) {
8680                slidesNumberEvenToRows = slidesLength;
8681            } else {
8682                slidesNumberEvenToRows = Math.ceil(slidesLength / rows) * rows;
8683            }
8684            if (slidesPerView !== 'auto' && fill === 'row') {
8685                slidesNumberEvenToRows = Math.max(slidesNumberEvenToRows, slidesPerView * rows);
8686            }
8687            slidesPerRow = slidesNumberEvenToRows / rows;
8688        };
8689        const unsetSlides = () => {
8690            if (swiper.slides) {

vendor: 48,406 bytes, lines 8691-9821

8691                swiper.slides.forEach(slide => {
8692                    if (slide.swiperSlideGridSet) {
8693                        slide.style.height = '';
8694                        slide.style[swiper.getDirectionLabel('margin-top')] = '';
8695                    }
8696                });
8697            }
8698        };
8699        const updateSlide = (i, slide, slides) => {
8700            const {
8701                slidesPerGroup
8702            } = swiper.params;
8703            const spaceBetween = getSpaceBetween();
8704            const {
8705                rows,
8706                fill
8707            } = swiper.params.grid;
8708            const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : slides.length;
8709            // Set slides order
8710            let newSlideOrderIndex;
8711            let column;
8712            let row;
8713            if (fill === 'row' && slidesPerGroup > 1) {
8714                const groupIndex = Math.floor(i / (slidesPerGroup * rows));
8715                const slideIndexInGroup = i - rows * slidesPerGroup * groupIndex;
8716                const columnsInGroup = groupIndex === 0 ? slidesPerGroup : Math.min(Math.ceil((slidesLength - groupIndex * rows * slidesPerGroup) / rows), slidesPerGroup);
8717                row = Math.floor(slideIndexInGroup / columnsInGroup);
8718                column = slideIndexInGroup - row * columnsInGroup + groupIndex * slidesPerGroup;
8719                newSlideOrderIndex = column + row * slidesNumberEvenToRows / rows;
8720                slide.style.order = newSlideOrderIndex;
8721            } else if (fill === 'column') {
8722                column = Math.floor(i / rows);
8723                row = i - column * rows;
8724                if (column > numFullColumns || column === numFullColumns && row === rows - 1) {
8725                    row += 1;
8726                    if (row >= rows) {
8727                        row = 0;
8728                        column += 1;
8729                    }
8730                }
8731            } else {
8732                row = Math.floor(i / slidesPerRow);
8733                column = i - row * slidesPerRow;
8734            }
8735            slide.row = row;
8736            slide.column = column;
8737            slide.style.height = `calc((100% - ${(rows - 1) * spaceBetween}px) / ${rows})`;
8738            slide.style[swiper.getDirectionLabel('margin-top')] = row !== 0 ? spaceBetween && `${spaceBetween}px` : '';
8739            slide.swiperSlideGridSet = true;
8740        };
8741        const updateWrapperSize = (slideSize, snapGrid) => {
8742            const {
8743                centeredSlides,
8744                roundLengths
8745            } = swiper.params;
8746            const spaceBetween = getSpaceBetween();
8747            const {
8748                rows
8749            } = swiper.params.grid;
8750            swiper.virtualSize = (slideSize + spaceBetween) * slidesNumberEvenToRows;
8751            swiper.virtualSize = Math.ceil(swiper.virtualSize / rows) - spaceBetween;
8752            if (!swiper.params.cssMode) {
8753                swiper.wrapperEl.style[swiper.getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;
8754            }
8755            if (centeredSlides) {
8756                const newSlidesGrid = [];
8757                for (let i = 0; i < snapGrid.length; i += 1) {
8758                    let slidesGridItem = snapGrid[i];
8759                    if (roundLengths) slidesGridItem = Math.floor(slidesGridItem);
8760                    if (snapGrid[i] < swiper.virtualSize + snapGrid[0]) newSlidesGrid.push(slidesGridItem);
8761                }
8762                snapGrid.splice(0, snapGrid.length);
8763                snapGrid.push(...newSlidesGrid);
8764            }
8765        };
8766        const onInit = () => {
8767            wasMultiRow = swiper.params.grid && swiper.params.grid.rows > 1;
8768        };
8769        const onUpdate = () => {
8770            const {
8771                params,
8772                el
8773            } = swiper;
8774            const isMultiRow = params.grid && params.grid.rows > 1;
8775            if (wasMultiRow && !isMultiRow) {
8776                el.classList.remove(`${params.containerModifierClass}grid`, `${params.containerModifierClass}grid-column`);
8777                numFullColumns = 1;
8778                swiper.emitContainerClasses();
8779            } else if (!wasMultiRow && isMultiRow) {
8780                el.classList.add(`${params.containerModifierClass}grid`);
8781                if (params.grid.fill === 'column') {
8782                    el.classList.add(`${params.containerModifierClass}grid-column`);
8783                }
8784                swiper.emitContainerClasses();
8785            }
8786            wasMultiRow = isMultiRow;
8787        };
8788        on('init', onInit);
8789        on('update', onUpdate);
8790        swiper.grid = {
8791            initSlides,
8792            unsetSlides,
8793            updateSlide,
8794            updateWrapperSize
8795        };
8796    }
8797
8798    function appendSlide(slides) {
8799        const swiper = this;
8800        const {
8801            params,
8802            slidesEl
8803        } = swiper;
8804        if (params.loop) {
8805            swiper.loopDestroy();
8806        }
8807        const appendElement = slideEl => {
8808            if (typeof slideEl === 'string') {
8809                const tempDOM = document.createElement('div');
8810                tempDOM.innerHTML = slideEl;
8811                slidesEl.append(tempDOM.children[0]);
8812                tempDOM.innerHTML = '';
8813            } else {
8814                slidesEl.append(slideEl);
8815            }
8816        };
8817        if (typeof slides === 'object' && 'length' in slides) {
8818            for (let i = 0; i < slides.length; i += 1) {
8819                if (slides[i]) appendElement(slides[i]);
8820            }
8821        } else {
8822            appendElement(slides);
8823        }
8824        swiper.recalcSlides();
8825        if (params.loop) {
8826            swiper.loopCreate();
8827        }
8828        if (!params.observer || swiper.isElement) {
8829            swiper.update();
8830        }
8831    }
8832
8833    function prependSlide(slides) {
8834        const swiper = this;
8835        const {
8836            params,
8837            activeIndex,
8838            slidesEl
8839        } = swiper;
8840        if (params.loop) {
8841            swiper.loopDestroy();
8842        }
8843        let newActiveIndex = activeIndex + 1;
8844        const prependElement = slideEl => {
8845            if (typeof slideEl === 'string') {
8846                const tempDOM = document.createElement('div');
8847                tempDOM.innerHTML = slideEl;
8848                slidesEl.prepend(tempDOM.children[0]);
8849                tempDOM.innerHTML = '';
8850            } else {
8851                slidesEl.prepend(slideEl);
8852            }
8853        };
8854        if (typeof slides === 'object' && 'length' in slides) {
8855            for (let i = 0; i < slides.length; i += 1) {
8856                if (slides[i]) prependElement(slides[i]);
8857            }
8858            newActiveIndex = activeIndex + slides.length;
8859        } else {
8860            prependElement(slides);
8861        }
8862        swiper.recalcSlides();
8863        if (params.loop) {
8864            swiper.loopCreate();
8865        }
8866        if (!params.observer || swiper.isElement) {
8867            swiper.update();
8868        }
8869        swiper.slideTo(newActiveIndex, 0, false);
8870    }
8871
8872    function addSlide(index, slides) {
8873        const swiper = this;
8874        const {
8875            params,
8876            activeIndex,
8877            slidesEl
8878        } = swiper;
8879        let activeIndexBuffer = activeIndex;
8880        if (params.loop) {
8881            activeIndexBuffer -= swiper.loopedSlides;
8882            swiper.loopDestroy();
8883            swiper.recalcSlides();
8884        }
8885        const baseLength = swiper.slides.length;
8886        if (index <= 0) {
8887            swiper.prependSlide(slides);
8888            return;
8889        }
8890        if (index >= baseLength) {
8891            swiper.appendSlide(slides);
8892            return;
8893        }
8894        let newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + 1 : activeIndexBuffer;
8895        const slidesBuffer = [];
8896        for (let i = baseLength - 1; i >= index; i -= 1) {
8897            const currentSlide = swiper.slides[i];
8898            currentSlide.remove();
8899            slidesBuffer.unshift(currentSlide);
8900        }
8901        if (typeof slides === 'object' && 'length' in slides) {
8902            for (let i = 0; i < slides.length; i += 1) {
8903                if (slides[i]) slidesEl.append(slides[i]);
8904            }
8905            newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + slides.length : activeIndexBuffer;
8906        } else {
8907            slidesEl.append(slides);
8908        }
8909        for (let i = 0; i < slidesBuffer.length; i += 1) {
8910            slidesEl.append(slidesBuffer[i]);
8911        }
8912        swiper.recalcSlides();
8913        if (params.loop) {
8914            swiper.loopCreate();
8915        }
8916        if (!params.observer || swiper.isElement) {
8917            swiper.update();
8918        }
8919        if (params.loop) {
8920            swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
8921        } else {
8922            swiper.slideTo(newActiveIndex, 0, false);
8923        }
8924    }
8925
8926    function removeSlide(slidesIndexes) {
8927        const swiper = this;
8928        const {
8929            params,
8930            activeIndex
8931        } = swiper;
8932        let activeIndexBuffer = activeIndex;
8933        if (params.loop) {
8934            activeIndexBuffer -= swiper.loopedSlides;
8935            swiper.loopDestroy();
8936        }
8937        let newActiveIndex = activeIndexBuffer;
8938        let indexToRemove;
8939        if (typeof slidesIndexes === 'object' && 'length' in slidesIndexes) {
8940            for (let i = 0; i < slidesIndexes.length; i += 1) {
8941                indexToRemove = slidesIndexes[i];
8942                if (swiper.slides[indexToRemove]) swiper.slides[indexToRemove].remove();
8943                if (indexToRemove < newActiveIndex) newActiveIndex -= 1;
8944            }
8945            newActiveIndex = Math.max(newActiveIndex, 0);
8946        } else {
8947            indexToRemove = slidesIndexes;
8948            if (swiper.slides[indexToRemove]) swiper.slides[indexToRemove].remove();
8949            if (indexToRemove < newActiveIndex) newActiveIndex -= 1;
8950            newActiveIndex = Math.max(newActiveIndex, 0);
8951        }
8952        swiper.recalcSlides();
8953        if (params.loop) {
8954            swiper.loopCreate();
8955        }
8956        if (!params.observer || swiper.isElement) {
8957            swiper.update();
8958        }
8959        if (params.loop) {
8960            swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
8961        } else {
8962            swiper.slideTo(newActiveIndex, 0, false);
8963        }
8964    }
8965
8966    function removeAllSlides() {
8967        const swiper = this;
8968        const slidesIndexes = [];
8969        for (let i = 0; i < swiper.slides.length; i += 1) {
8970            slidesIndexes.push(i);
8971        }
8972        swiper.removeSlide(slidesIndexes);
8973    }
8974
8975    function Manipulation(_ref) {
8976        let {
8977            swiper
8978        } = _ref;
8979        Object.assign(swiper, {
8980            appendSlide: appendSlide.bind(swiper),
8981            prependSlide: prependSlide.bind(swiper),
8982            addSlide: addSlide.bind(swiper),
8983            removeSlide: removeSlide.bind(swiper),
8984            removeAllSlides: removeAllSlides.bind(swiper)
8985        });
8986    }
8987
8988    function effectInit(params) {
8989        const {
8990            effect,
8991            swiper,
8992            on,
8993            setTranslate,
8994            setTransition,
8995            overwriteParams,
8996            perspective,
8997            recreateShadows,
8998            getEffectParams
8999        } = params;
9000        on('beforeInit', () => {
9001            if (swiper.params.effect !== effect) return;
9002            swiper.classNames.push(`${swiper.params.containerModifierClass}${effect}`);
9003            if (perspective && perspective()) {
9004                swiper.classNames.push(`${swiper.params.containerModifierClass}3d`);
9005            }
9006            const overwriteParamsResult = overwriteParams ? overwriteParams() : {};
9007            Object.assign(swiper.params, overwriteParamsResult);
9008            Object.assign(swiper.originalParams, overwriteParamsResult);
9009        });
9010        on('setTranslate', () => {
9011            if (swiper.params.effect !== effect) return;
9012            setTranslate();
9013        });
9014        on('setTransition', (_s, duration) => {
9015            if (swiper.params.effect !== effect) return;
9016            setTransition(duration);
9017        });
9018        on('transitionEnd', () => {
9019            if (swiper.params.effect !== effect) return;
9020            if (recreateShadows) {
9021                if (!getEffectParams || !getEffectParams().slideShadows) return;
9022                // remove shadows
9023                swiper.slides.forEach(slideEl => {
9024                    slideEl.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => shadowEl.remove());
9025                });
9026                // create new one
9027                recreateShadows();
9028            }
9029        });
9030        let requireUpdateOnVirtual;
9031        on('virtualUpdate', () => {
9032            if (swiper.params.effect !== effect) return;
9033            if (!swiper.slides.length) {
9034                requireUpdateOnVirtual = true;
9035            }
9036            requestAnimationFrame(() => {
9037                if (requireUpdateOnVirtual && swiper.slides && swiper.slides.length) {
9038                    setTranslate();
9039                    requireUpdateOnVirtual = false;
9040                }
9041            });
9042        });
9043    }
9044
9045    function effectTarget(effectParams, slideEl) {
9046        const transformEl = getSlideTransformEl(slideEl);
9047        if (transformEl !== slideEl) {
9048            transformEl.style.backfaceVisibility = 'hidden';
9049            transformEl.style['-webkit-backface-visibility'] = 'hidden';
9050        }
9051        return transformEl;
9052    }
9053
9054    function effectVirtualTransitionEnd(_ref) {
9055        let {
9056            swiper,
9057            duration,
9058            transformElements,
9059            allSlides
9060        } = _ref;
9061        const {
9062            activeIndex
9063        } = swiper;
9064        const getSlide = el => {
9065            if (!el.parentElement) {
9066                // assume shadow root
9067                const slide = swiper.slides.find(slideEl => slideEl.shadowRoot && slideEl.shadowRoot === el.parentNode);
9068                return slide;
9069            }
9070            return el.parentElement;
9071        };
9072        if (swiper.params.virtualTranslate && duration !== 0) {
9073            let eventTriggered = false;
9074            let transitionEndTarget;
9075            if (allSlides) {
9076                transitionEndTarget = transformElements;
9077            } else {
9078                transitionEndTarget = transformElements.filter(transformEl => {
9079                    const el = transformEl.classList.contains('swiper-slide-transform') ? getSlide(transformEl) : transformEl;
9080                    return swiper.getSlideIndex(el) === activeIndex;
9081                });
9082            }
9083            transitionEndTarget.forEach(el => {
9084                elementTransitionEnd(el, () => {
9085                    if (eventTriggered) return;
9086                    if (!swiper || swiper.destroyed) return;
9087                    eventTriggered = true;
9088                    swiper.animating = false;
9089                    const evt = new window.CustomEvent('transitionend', {
9090                        bubbles: true,
9091                        cancelable: true
9092                    });
9093                    swiper.wrapperEl.dispatchEvent(evt);
9094                });
9095            });
9096        }
9097    }
9098
9099    function EffectFade(_ref) {
9100        let {
9101            swiper,
9102            extendParams,
9103            on
9104        } = _ref;
9105        extendParams({
9106            fadeEffect: {
9107                crossFade: false
9108            }
9109        });
9110        const setTranslate = () => {
9111            const {
9112                slides
9113            } = swiper;
9114            const params = swiper.params.fadeEffect;
9115            for (let i = 0; i < slides.length; i += 1) {
9116                const slideEl = swiper.slides[i];
9117                const offset = slideEl.swiperSlideOffset;
9118                let tx = -offset;
9119                if (!swiper.params.virtualTranslate) tx -= swiper.translate;
9120                let ty = 0;
9121                if (!swiper.isHorizontal()) {
9122                    ty = tx;
9123                    tx = 0;
9124                }
9125                const slideOpacity = swiper.params.fadeEffect.crossFade ? Math.max(1 - Math.abs(slideEl.progress), 0) : 1 + Math.min(Math.max(slideEl.progress, -1), 0);
9126                const targetEl = effectTarget(params, slideEl);
9127                targetEl.style.opacity = slideOpacity;
9128                targetEl.style.transform = `translate3d(${tx}px, ${ty}px, 0px)`;
9129            }
9130        };
9131        const setTransition = duration => {
9132            const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
9133            transformElements.forEach(el => {
9134                el.style.transitionDuration = `${duration}ms`;
9135            });
9136            effectVirtualTransitionEnd({
9137                swiper,
9138                duration,
9139                transformElements,
9140                allSlides: true
9141            });
9142        };
9143        effectInit({
9144            effect: 'fade',
9145            swiper,
9146            on,
9147            setTranslate,
9148            setTransition,
9149            overwriteParams: () => ({
9150                slidesPerView: 1,
9151                slidesPerGroup: 1,
9152                watchSlidesProgress: true,
9153                spaceBetween: 0,
9154                virtualTranslate: !swiper.params.cssMode
9155            })
9156        });
9157    }
9158
9159    function EffectCube(_ref) {
9160        let {
9161            swiper,
9162            extendParams,
9163            on
9164        } = _ref;
9165        extendParams({
9166            cubeEffect: {
9167                slideShadows: true,
9168                shadow: true,
9169                shadowOffset: 20,
9170                shadowScale: 0.94
9171            }
9172        });
9173        const createSlideShadows = (slideEl, progress, isHorizontal) => {
9174            let shadowBefore = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');
9175            let shadowAfter = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');
9176            if (!shadowBefore) {
9177                shadowBefore = createElement('div', `swiper-slide-shadow-cube swiper-slide-shadow-${isHorizontal ? 'left' : 'top'}`.split(' '));
9178                slideEl.append(shadowBefore);
9179            }
9180            if (!shadowAfter) {
9181                shadowAfter = createElement('div', `swiper-slide-shadow-cube swiper-slide-shadow-${isHorizontal ? 'right' : 'bottom'}`.split(' '));
9182                slideEl.append(shadowAfter);
9183            }
9184            if (shadowBefore) shadowBefore.style.opacity = Math.max(-progress, 0);
9185            if (shadowAfter) shadowAfter.style.opacity = Math.max(progress, 0);
9186        };
9187        const recreateShadows = () => {
9188            // create new ones
9189            const isHorizontal = swiper.isHorizontal();
9190            swiper.slides.forEach(slideEl => {
9191                const progress = Math.max(Math.min(slideEl.progress, 1), -1);
9192                createSlideShadows(slideEl, progress, isHorizontal);
9193            });
9194        };
9195        const setTranslate = () => {
9196            const {
9197                el,
9198                wrapperEl,
9199                slides,
9200                width: swiperWidth,
9201                height: swiperHeight,
9202                rtlTranslate: rtl,
9203                size: swiperSize,
9204                browser
9205            } = swiper;
9206            const r = getRotateFix(swiper);
9207            const params = swiper.params.cubeEffect;
9208            const isHorizontal = swiper.isHorizontal();
9209            const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
9210            let wrapperRotate = 0;
9211            let cubeShadowEl;
9212            if (params.shadow) {
9213                if (isHorizontal) {
9214                    cubeShadowEl = swiper.wrapperEl.querySelector('.swiper-cube-shadow');
9215                    if (!cubeShadowEl) {
9216                        cubeShadowEl = createElement('div', 'swiper-cube-shadow');
9217                        swiper.wrapperEl.append(cubeShadowEl);
9218                    }
9219                    cubeShadowEl.style.height = `${swiperWidth}px`;
9220                } else {
9221                    cubeShadowEl = el.querySelector('.swiper-cube-shadow');
9222                    if (!cubeShadowEl) {
9223                        cubeShadowEl = createElement('div', 'swiper-cube-shadow');
9224                        el.append(cubeShadowEl);
9225                    }
9226                }
9227            }
9228            for (let i = 0; i < slides.length; i += 1) {
9229                const slideEl = slides[i];
9230                let slideIndex = i;
9231                if (isVirtual) {
9232                    slideIndex = parseInt(slideEl.getAttribute('data-swiper-slide-index'), 10);
9233                }
9234                let slideAngle = slideIndex * 90;
9235                let round = Math.floor(slideAngle / 360);
9236                if (rtl) {
9237                    slideAngle = -slideAngle;
9238                    round = Math.floor(-slideAngle / 360);
9239                }
9240                const progress = Math.max(Math.min(slideEl.progress, 1), -1);
9241                let tx = 0;
9242                let ty = 0;
9243                let tz = 0;
9244                if (slideIndex % 4 === 0) {
9245                    tx = -round * 4 * swiperSize;
9246                    tz = 0;
9247                } else if ((slideIndex - 1) % 4 === 0) {
9248                    tx = 0;
9249                    tz = -round * 4 * swiperSize;
9250                } else if ((slideIndex - 2) % 4 === 0) {
9251                    tx = swiperSize + round * 4 * swiperSize;
9252                    tz = swiperSize;
9253                } else if ((slideIndex - 3) % 4 === 0) {
9254                    tx = -swiperSize;
9255                    tz = 3 * swiperSize + swiperSize * 4 * round;
9256                }
9257                if (rtl) {
9258                    tx = -tx;
9259                }
9260                if (!isHorizontal) {
9261                    ty = tx;
9262                    tx = 0;
9263                }
9264                const transform = `rotateX(${r(isHorizontal ? 0 : -slideAngle)}deg) rotateY(${r(isHorizontal ? slideAngle : 0)}deg) translate3d(${tx}px, ${ty}px, ${tz}px)`;
9265                if (progress <= 1 && progress > -1) {
9266                    wrapperRotate = slideIndex * 90 + progress * 90;
9267                    if (rtl) wrapperRotate = -slideIndex * 90 - progress * 90;
9268                }
9269                slideEl.style.transform = transform;
9270                if (params.slideShadows) {
9271                    createSlideShadows(slideEl, progress, isHorizontal);
9272                }
9273            }
9274            wrapperEl.style.transformOrigin = `50% 50% -${swiperSize / 2}px`;
9275            wrapperEl.style['-webkit-transform-origin'] = `50% 50% -${swiperSize / 2}px`;
9276            if (params.shadow) {
9277                if (isHorizontal) {
9278                    cubeShadowEl.style.transform = `translate3d(0px, ${swiperWidth / 2 + params.shadowOffset}px, ${-swiperWidth / 2}px) rotateX(89.99deg) rotateZ(0deg) scale(${params.shadowScale})`;
9279                } else {
9280                    const shadowAngle = Math.abs(wrapperRotate) - Math.floor(Math.abs(wrapperRotate) / 90) * 90;
9281                    const multiplier = 1.5 - (Math.sin(shadowAngle * 2 * Math.PI / 360) / 2 + Math.cos(shadowAngle * 2 * Math.PI / 360) / 2);
9282                    const scale1 = params.shadowScale;
9283                    const scale2 = params.shadowScale / multiplier;
9284                    const offset = params.shadowOffset;
9285                    cubeShadowEl.style.transform = `scale3d(${scale1}, 1, ${scale2}) translate3d(0px, ${swiperHeight / 2 + offset}px, ${-swiperHeight / 2 / scale2}px) rotateX(-89.99deg)`;
9286                }
9287            }
9288            const zFactor = (browser.isSafari || browser.isWebView) && browser.needPerspectiveFix ? -swiperSize / 2 : 0;
9289            wrapperEl.style.transform = `translate3d(0px,0,${zFactor}px) rotateX(${r(swiper.isHorizontal() ? 0 : wrapperRotate)}deg) rotateY(${r(swiper.isHorizontal() ? -wrapperRotate : 0)}deg)`;
9290            wrapperEl.style.setProperty('--swiper-cube-translate-z', `${zFactor}px`);
9291        };
9292        const setTransition = duration => {
9293            const {
9294                el,
9295                slides
9296            } = swiper;
9297            slides.forEach(slideEl => {
9298                slideEl.style.transitionDuration = `${duration}ms`;
9299                slideEl.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(subEl => {
9300                    subEl.style.transitionDuration = `${duration}ms`;
9301                });
9302            });
9303            if (swiper.params.cubeEffect.shadow && !swiper.isHorizontal()) {
9304                const shadowEl = el.querySelector('.swiper-cube-shadow');
9305                if (shadowEl) shadowEl.style.transitionDuration = `${duration}ms`;
9306            }
9307        };
9308        effectInit({
9309            effect: 'cube',
9310            swiper,
9311            on,
9312            setTranslate,
9313            setTransition,
9314            recreateShadows,
9315            getEffectParams: () => swiper.params.cubeEffect,
9316            perspective: () => true,
9317            overwriteParams: () => ({
9318                slidesPerView: 1,
9319                slidesPerGroup: 1,
9320                watchSlidesProgress: true,
9321                resistanceRatio: 0,
9322                spaceBetween: 0,
9323                centeredSlides: false,
9324                virtualTranslate: true
9325            })
9326        });
9327    }
9328
9329    function createShadow(suffix, slideEl, side) {
9330        const shadowClass = `swiper-slide-shadow${side ? `-${side}` : ''}${suffix ? ` swiper-slide-shadow-${suffix}` : ''}`;
9331        const shadowContainer = getSlideTransformEl(slideEl);
9332        let shadowEl = shadowContainer.querySelector(`.${shadowClass.split(' ').join('.')}`);
9333        if (!shadowEl) {
9334            shadowEl = createElement('div', shadowClass.split(' '));
9335            shadowContainer.append(shadowEl);
9336        }
9337        return shadowEl;
9338    }
9339
9340    function EffectFlip(_ref) {
9341        let {
9342            swiper,
9343            extendParams,
9344            on
9345        } = _ref;
9346        extendParams({
9347            flipEffect: {
9348                slideShadows: true,
9349                limitRotation: true
9350            }
9351        });
9352        const createSlideShadows = (slideEl, progress) => {
9353            let shadowBefore = swiper.isHorizontal() ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');
9354            let shadowAfter = swiper.isHorizontal() ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');
9355            if (!shadowBefore) {
9356                shadowBefore = createShadow('flip', slideEl, swiper.isHorizontal() ? 'left' : 'top');
9357            }
9358            if (!shadowAfter) {
9359                shadowAfter = createShadow('flip', slideEl, swiper.isHorizontal() ? 'right' : 'bottom');
9360            }
9361            if (shadowBefore) shadowBefore.style.opacity = Math.max(-progress, 0);
9362            if (shadowAfter) shadowAfter.style.opacity = Math.max(progress, 0);
9363        };
9364        const recreateShadows = () => {
9365            // Set shadows
9366            swiper.params.flipEffect;
9367            swiper.slides.forEach(slideEl => {
9368                let progress = slideEl.progress;
9369                if (swiper.params.flipEffect.limitRotation) {
9370                    progress = Math.max(Math.min(slideEl.progress, 1), -1);
9371                }
9372                createSlideShadows(slideEl, progress);
9373            });
9374        };
9375        const setTranslate = () => {
9376            const {
9377                slides,
9378                rtlTranslate: rtl
9379            } = swiper;
9380            const params = swiper.params.flipEffect;
9381            const rotateFix = getRotateFix(swiper);
9382            for (let i = 0; i < slides.length; i += 1) {
9383                const slideEl = slides[i];
9384                let progress = slideEl.progress;
9385                if (swiper.params.flipEffect.limitRotation) {
9386                    progress = Math.max(Math.min(slideEl.progress, 1), -1);
9387                }
9388                const offset = slideEl.swiperSlideOffset;
9389                const rotate = -180 * progress;
9390                let rotateY = rotate;
9391                let rotateX = 0;
9392                let tx = swiper.params.cssMode ? -offset - swiper.translate : -offset;
9393                let ty = 0;
9394                if (!swiper.isHorizontal()) {
9395                    ty = tx;
9396                    tx = 0;
9397                    rotateX = -rotateY;
9398                    rotateY = 0;
9399                } else if (rtl) {
9400                    rotateY = -rotateY;
9401                }
9402                slideEl.style.zIndex = -Math.abs(Math.round(progress)) + slides.length;
9403                if (params.slideShadows) {
9404                    createSlideShadows(slideEl, progress);
9405                }
9406                const transform = `translate3d(${tx}px, ${ty}px, 0px) rotateX(${rotateFix(rotateX)}deg) rotateY(${rotateFix(rotateY)}deg)`;
9407                const targetEl = effectTarget(params, slideEl);
9408                targetEl.style.transform = transform;
9409            }
9410        };
9411        const setTransition = duration => {
9412            const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
9413            transformElements.forEach(el => {
9414                el.style.transitionDuration = `${duration}ms`;
9415                el.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => {
9416                    shadowEl.style.transitionDuration = `${duration}ms`;
9417                });
9418            });
9419            effectVirtualTransitionEnd({
9420                swiper,
9421                duration,
9422                transformElements
9423            });
9424        };
9425        effectInit({
9426            effect: 'flip',
9427            swiper,
9428            on,
9429            setTranslate,
9430            setTransition,
9431            recreateShadows,
9432            getEffectParams: () => swiper.params.flipEffect,
9433            perspective: () => true,
9434            overwriteParams: () => ({
9435                slidesPerView: 1,
9436                slidesPerGroup: 1,
9437                watchSlidesProgress: true,
9438                spaceBetween: 0,
9439                virtualTranslate: !swiper.params.cssMode
9440            })
9441        });
9442    }
9443
9444    function EffectCoverflow(_ref) {
9445        let {
9446            swiper,
9447            extendParams,
9448            on
9449        } = _ref;
9450        extendParams({
9451            coverflowEffect: {
9452                rotate: 50,
9453                stretch: 0,
9454                depth: 100,
9455                scale: 1,
9456                modifier: 1,
9457                slideShadows: true
9458            }
9459        });
9460        const setTranslate = () => {
9461            const {
9462                width: swiperWidth,
9463                height: swiperHeight,
9464                slides,
9465                slidesSizesGrid
9466            } = swiper;
9467            const params = swiper.params.coverflowEffect;
9468            const isHorizontal = swiper.isHorizontal();
9469            const transform = swiper.translate;
9470            const center = isHorizontal ? -transform + swiperWidth / 2 : -transform + swiperHeight / 2;
9471            const rotate = isHorizontal ? params.rotate : -params.rotate;
9472            const translate = params.depth;
9473            const r = getRotateFix(swiper);
9474            // Each slide offset from center
9475            for (let i = 0, length = slides.length; i < length; i += 1) {
9476                const slideEl = slides[i];
9477                const slideSize = slidesSizesGrid[i];
9478                const slideOffset = slideEl.swiperSlideOffset;
9479                const centerOffset = (center - slideOffset - slideSize / 2) / slideSize;
9480                const offsetMultiplier = typeof params.modifier === 'function' ? params.modifier(centerOffset) : centerOffset * params.modifier;
9481                let rotateY = isHorizontal ? rotate * offsetMultiplier : 0;
9482                let rotateX = isHorizontal ? 0 : rotate * offsetMultiplier;
9483                // var rotateZ = 0
9484                let translateZ = -translate * Math.abs(offsetMultiplier);
9485                let stretch = params.stretch;
9486                // Allow percentage to make a relative stretch for responsive sliders
9487                if (typeof stretch === 'string' && stretch.indexOf('%') !== -1) {
9488                    stretch = parseFloat(params.stretch) / 100 * slideSize;
9489                }
9490                let translateY = isHorizontal ? 0 : stretch * offsetMultiplier;
9491                let translateX = isHorizontal ? stretch * offsetMultiplier : 0;
9492                let scale = 1 - (1 - params.scale) * Math.abs(offsetMultiplier);
9493
9494                // Fix for ultra small values
9495                if (Math.abs(translateX) < 0.001) translateX = 0;
9496                if (Math.abs(translateY) < 0.001) translateY = 0;
9497                if (Math.abs(translateZ) < 0.001) translateZ = 0;
9498                if (Math.abs(rotateY) < 0.001) rotateY = 0;
9499                if (Math.abs(rotateX) < 0.001) rotateX = 0;
9500                if (Math.abs(scale) < 0.001) scale = 0;
9501                const slideTransform = `translate3d(${translateX}px,${translateY}px,${translateZ}px)  rotateX(${r(rotateX)}deg) rotateY(${r(rotateY)}deg) scale(${scale})`;
9502                const targetEl = effectTarget(params, slideEl);
9503                targetEl.style.transform = slideTransform;
9504                slideEl.style.zIndex = -Math.abs(Math.round(offsetMultiplier)) + 1;
9505                if (params.slideShadows) {
9506                    // Set shadows
9507                    let shadowBeforeEl = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');
9508                    let shadowAfterEl = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');
9509                    if (!shadowBeforeEl) {
9510                        shadowBeforeEl = createShadow('coverflow', slideEl, isHorizontal ? 'left' : 'top');
9511                    }
9512                    if (!shadowAfterEl) {
9513                        shadowAfterEl = createShadow('coverflow', slideEl, isHorizontal ? 'right' : 'bottom');
9514                    }
9515                    if (shadowBeforeEl) shadowBeforeEl.style.opacity = offsetMultiplier > 0 ? offsetMultiplier : 0;
9516                    if (shadowAfterEl) shadowAfterEl.style.opacity = -offsetMultiplier > 0 ? -offsetMultiplier : 0;
9517                }
9518            }
9519        };
9520        const setTransition = duration => {
9521            const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
9522            transformElements.forEach(el => {
9523                el.style.transitionDuration = `${duration}ms`;
9524                el.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => {
9525                    shadowEl.style.transitionDuration = `${duration}ms`;
9526                });
9527            });
9528        };
9529        effectInit({
9530            effect: 'coverflow',
9531            swiper,
9532            on,
9533            setTranslate,
9534            setTransition,
9535            perspective: () => true,
9536            overwriteParams: () => ({
9537                watchSlidesProgress: true
9538            })
9539        });
9540    }
9541
9542    function EffectCreative(_ref) {
9543        let {
9544            swiper,
9545            extendParams,
9546            on
9547        } = _ref;
9548        extendParams({
9549            creativeEffect: {
9550                limitProgress: 1,
9551                shadowPerProgress: false,
9552                progressMultiplier: 1,
9553                perspective: true,
9554                prev: {
9555                    translate: [0, 0, 0],
9556                    rotate: [0, 0, 0],
9557                    opacity: 1,
9558                    scale: 1
9559                },
9560                next: {
9561                    translate: [0, 0, 0],
9562                    rotate: [0, 0, 0],
9563                    opacity: 1,
9564                    scale: 1
9565                }
9566            }
9567        });
9568        const getTranslateValue = value => {
9569            if (typeof value === 'string') return value;
9570            return `${value}px`;
9571        };
9572        const setTranslate = () => {
9573            const {
9574                slides,
9575                wrapperEl,
9576                slidesSizesGrid
9577            } = swiper;
9578            const params = swiper.params.creativeEffect;
9579            const {
9580                progressMultiplier: multiplier
9581            } = params;
9582            const isCenteredSlides = swiper.params.centeredSlides;
9583            const rotateFix = getRotateFix(swiper);
9584            if (isCenteredSlides) {
9585                const margin = slidesSizesGrid[0] / 2 - swiper.params.slidesOffsetBefore || 0;
9586                wrapperEl.style.transform = `translateX(calc(50% - ${margin}px))`;
9587            }
9588            for (let i = 0; i < slides.length; i += 1) {
9589                const slideEl = slides[i];
9590                const slideProgress = slideEl.progress;
9591                const progress = Math.min(Math.max(slideEl.progress, -params.limitProgress), params.limitProgress);
9592                let originalProgress = progress;
9593                if (!isCenteredSlides) {
9594                    originalProgress = Math.min(Math.max(slideEl.originalProgress, -params.limitProgress), params.limitProgress);
9595                }
9596                const offset = slideEl.swiperSlideOffset;
9597                const t = [swiper.params.cssMode ? -offset - swiper.translate : -offset, 0, 0];
9598                const r = [0, 0, 0];
9599                let custom = false;
9600                if (!swiper.isHorizontal()) {
9601                    t[1] = t[0];
9602                    t[0] = 0;
9603                }
9604                let data = {
9605                    translate: [0, 0, 0],
9606                    rotate: [0, 0, 0],
9607                    scale: 1,
9608                    opacity: 1
9609                };
9610                if (progress < 0) {
9611                    data = params.next;
9612                    custom = true;
9613                } else if (progress > 0) {
9614                    data = params.prev;
9615                    custom = true;
9616                }
9617                // set translate
9618                t.forEach((value, index) => {
9619                    t[index] = `calc(${value}px + (${getTranslateValue(data.translate[index])} * ${Math.abs(progress * multiplier)}))`;
9620                });
9621                // set rotates
9622                r.forEach((value, index) => {
9623                    let val = data.rotate[index] * Math.abs(progress * multiplier);
9624                    r[index] = val;
9625                });
9626                slideEl.style.zIndex = -Math.abs(Math.round(slideProgress)) + slides.length;
9627                const translateString = t.join(', ');
9628                const rotateString = `rotateX(${rotateFix(r[0])}deg) rotateY(${rotateFix(r[1])}deg) rotateZ(${rotateFix(r[2])}deg)`;
9629                const scaleString = originalProgress < 0 ? `scale(${1 + (1 - data.scale) * originalProgress * multiplier})` : `scale(${1 - (1 - data.scale) * originalProgress * multiplier})`;
9630                const opacityString = originalProgress < 0 ? 1 + (1 - data.opacity) * originalProgress * multiplier : 1 - (1 - data.opacity) * originalProgress * multiplier;
9631                const transform = `translate3d(${translateString}) ${rotateString} ${scaleString}`;
9632
9633                // Set shadows
9634                if (custom && data.shadow || !custom) {
9635                    let shadowEl = slideEl.querySelector('.swiper-slide-shadow');
9636                    if (!shadowEl && data.shadow) {
9637                        shadowEl = createShadow('creative', slideEl);
9638                    }
9639                    if (shadowEl) {
9640                        const shadowOpacity = params.shadowPerProgress ? progress * (1 / params.limitProgress) : progress;
9641                        shadowEl.style.opacity = Math.min(Math.max(Math.abs(shadowOpacity), 0), 1);
9642                    }
9643                }
9644                const targetEl = effectTarget(params, slideEl);
9645                targetEl.style.transform = transform;
9646                targetEl.style.opacity = opacityString;
9647                if (data.origin) {
9648                    targetEl.style.transformOrigin = data.origin;
9649                }
9650            }
9651        };
9652        const setTransition = duration => {
9653            const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
9654            transformElements.forEach(el => {
9655                el.style.transitionDuration = `${duration}ms`;
9656                el.querySelectorAll('.swiper-slide-shadow').forEach(shadowEl => {
9657                    shadowEl.style.transitionDuration = `${duration}ms`;
9658                });
9659            });
9660            effectVirtualTransitionEnd({
9661                swiper,
9662                duration,
9663                transformElements,
9664                allSlides: true
9665            });
9666        };
9667        effectInit({
9668            effect: 'creative',
9669            swiper,
9670            on,
9671            setTranslate,
9672            setTransition,
9673            perspective: () => swiper.params.creativeEffect.perspective,
9674            overwriteParams: () => ({
9675                watchSlidesProgress: true,
9676                virtualTranslate: !swiper.params.cssMode
9677            })
9678        });
9679    }
9680
9681    function EffectCards(_ref) {
9682        let {
9683            swiper,
9684            extendParams,
9685            on
9686        } = _ref;
9687        extendParams({
9688            cardsEffect: {
9689                slideShadows: true,
9690                rotate: true,
9691                perSlideRotate: 2,
9692                perSlideOffset: 8
9693            }
9694        });
9695        const setTranslate = () => {
9696            const {
9697                slides,
9698                activeIndex,
9699                rtlTranslate: rtl
9700            } = swiper;
9701            const params = swiper.params.cardsEffect;
9702            const {
9703                startTranslate,
9704                isTouched
9705            } = swiper.touchEventsData;
9706            const currentTranslate = rtl ? -swiper.translate : swiper.translate;
9707            for (let i = 0; i < slides.length; i += 1) {
9708                const slideEl = slides[i];
9709                const slideProgress = slideEl.progress;
9710                const progress = Math.min(Math.max(slideProgress, -4), 4);
9711                let offset = slideEl.swiperSlideOffset;
9712                if (swiper.params.centeredSlides && !swiper.params.cssMode) {
9713                    swiper.wrapperEl.style.transform = `translateX(${swiper.minTranslate()}px)`;
9714                }
9715                if (swiper.params.centeredSlides && swiper.params.cssMode) {
9716                    offset -= slides[0].swiperSlideOffset;
9717                }
9718                let tX = swiper.params.cssMode ? -offset - swiper.translate : -offset;
9719                let tY = 0;
9720                const tZ = -100 * Math.abs(progress);
9721                let scale = 1;
9722                let rotate = -params.perSlideRotate * progress;
9723                let tXAdd = params.perSlideOffset - Math.abs(progress) * 0.75;
9724                const slideIndex = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.from + i : i;
9725                const isSwipeToNext = (slideIndex === activeIndex || slideIndex === activeIndex - 1) && progress > 0 && progress < 1 && (isTouched || swiper.params.cssMode) && currentTranslate < startTranslate;
9726                const isSwipeToPrev = (slideIndex === activeIndex || slideIndex === activeIndex + 1) && progress < 0 && progress > -1 && (isTouched || swiper.params.cssMode) && currentTranslate > startTranslate;
9727                if (isSwipeToNext || isSwipeToPrev) {
9728                    const subProgress = (1 - Math.abs((Math.abs(progress) - 0.5) / 0.5)) ** 0.5;
9729                    rotate += -28 * progress * subProgress;
9730                    scale += -0.5 * subProgress;
9731                    tXAdd += 96 * subProgress;
9732                    tY = `${-25 * subProgress * Math.abs(progress)}%`;
9733                }
9734                if (progress < 0) {
9735                    // next
9736                    tX = `calc(${tX}px ${rtl ? '-' : '+'} (${tXAdd * Math.abs(progress)}%))`;
9737                } else if (progress > 0) {
9738                    // prev
9739                    tX = `calc(${tX}px ${rtl ? '-' : '+'} (-${tXAdd * Math.abs(progress)}%))`;
9740                } else {
9741                    tX = `${tX}px`;
9742                }
9743                if (!swiper.isHorizontal()) {
9744                    const prevY = tY;
9745                    tY = tX;
9746                    tX = prevY;
9747                }
9748                const scaleString = progress < 0 ? `${1 + (1 - scale) * progress}` : `${1 - (1 - scale) * progress}`;
9749
9750                /* eslint-disable */
9751                const transform = `
9752        translate3d(${tX}, ${tY}, ${tZ}px)
9753        rotateZ(${params.rotate ? rtl ? -rotate : rotate : 0}deg)
9754        scale(${scaleString})
9755      `;
9756                /* eslint-enable */
9757
9758                if (params.slideShadows) {
9759                    // Set shadows
9760                    let shadowEl = slideEl.querySelector('.swiper-slide-shadow');
9761                    if (!shadowEl) {
9762                        shadowEl = createShadow('cards', slideEl);
9763                    }
9764                    if (shadowEl) shadowEl.style.opacity = Math.min(Math.max((Math.abs(progress) - 0.5) / 0.5, 0), 1);
9765                }
9766                slideEl.style.zIndex = -Math.abs(Math.round(slideProgress)) + slides.length;
9767                const targetEl = effectTarget(params, slideEl);
9768                targetEl.style.transform = transform;
9769            }
9770        };
9771        const setTransition = duration => {
9772            const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
9773            transformElements.forEach(el => {
9774                el.style.transitionDuration = `${duration}ms`;
9775                el.querySelectorAll('.swiper-slide-shadow').forEach(shadowEl => {
9776                    shadowEl.style.transitionDuration = `${duration}ms`;
9777                });
9778            });
9779            effectVirtualTransitionEnd({
9780                swiper,
9781                duration,
9782                transformElements
9783            });
9784        };
9785        effectInit({
9786            effect: 'cards',
9787            swiper,
9788            on,
9789            setTranslate,
9790            setTransition,
9791            perspective: () => true,
9792            overwriteParams: () => ({
9793                _loopSwapReset: false,
9794                watchSlidesProgress: true,
9795                loopAdditionalSlides: swiper.params.cardsEffect.rotate ? 3 : 2,
9796                centeredSlides: true,
9797                virtualTranslate: !swiper.params.cssMode
9798            })
9799        });
9800    }
9801
9802    /**
9803     * Swiper 11.2.6
9804     * Most modern mobile touch slider and framework with hardware accelerated transitions
9805     * https://swiperjs.com
9806     *
9807     * Copyright 2014-2025 Vladimir Kharlampidi
9808     *
9809     * Released under the MIT License
9810     *
9811     * Released on: March 19, 2025
9812     */
9813
9814
9815        // Swiper Class
9816    const modules = [Virtual, Keyboard, Mousewheel, Navigation, Pagination, Scrollbar, Parallax, Zoom, Controller, A11y, History, HashNavigation, Autoplay, Thumb, freeMode, Grid, Manipulation, EffectFade, EffectCube, EffectFlip, EffectCoverflow, EffectCreative, EffectCards];
9817    Swiper.use(modules);
9818
9819    return Swiper;
9820
9821})();

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