https://newfalconherald.com/wp-content/plugins/directorist/assets/vendor-js/swiper.js?ver=1790904648

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  
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);
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    }
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 ? {}

509 : _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;
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        }

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        }

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      }

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 : -swiper.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 : -swi

2227per.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 

2328not 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) {

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 = [];

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;