https://wjg-nettetal.de/wp-content/plugins/divi-modules-pro/public/js/swiper-11.1.14.min.js?ver=11.1.14

1/**
2 * Swiper 11.1.14
3 * Most modern mobile touch slider and framework with hardware accelerated transitions
4 * https://swiperjs.com
5 *
6 * Copyright 2014-2024 Vladimir Kharlampidi
7 *
8 * Released under the MIT License
9 *
10 * Released on: September 12, 2024
11 */
12
13var Swiper = (function () {
14  'use strict';
15
16  /**
17   * SSR Window 4.0.2
18   * Better handling for window object in SSR environment
19   * https://github.com/nolimits4web/ssr-window
20   *
21   * Copyright 2021, Vladimir Kharlampidi
22   *
23   * Licensed under MIT
24   *
25   * Released on: December 13, 2021
26   */
27  /* eslint-disable no-param-reassign */
28  function isObject$1(obj) {
29    return obj !== null && typeof obj === 'object' && 'constructor' in obj && obj.constructor === Object;
30  }
31  function extend$1(target, src) {
32    if (target === void 0) {
33      target = {};
34    }
35    if (src === void 0) {
36      src = {};
37    }
38    Object.keys(src).forEach(key => {
39      if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject$1(src[key]) && isObject$1(target[key]) && Object.keys(src[key]).length > 0) {
40        extend$1(target[key], src[key]);
41      }
42    });
43  }
44  const hasReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)');
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 children = [...element.children];
346    if (element instanceof HTMLSlotElement) {
347      children.push(...element.assignedElements());
348    }
349    if (!selector) {
350      return children;
351    }
352    return children.filter(el => el.matches(selector));
353  }
354  function elementIsChildOf(el, parent) {
355    const isChild = parent.contains(el);
356    if (!isChild && parent instanceof HTMLSlotElement) {
357      const children = [...parent.assignedElements()];
358      return children.includes(el);
359    }
360    return isChild;
361  }
362  function showWarning(text) {
363    try {
364      console.warn(text);
365      return;
366    } catch (err) {
367      // err
368    }
369  }
370  function createElement(tag, classes) {
371    if (classes === void 0) {
372      classes = [];
373    }
374    const el = document.createElement(tag);

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

494    const support = getSupport();
495    const window = getWindow();
496    const platform = window.navigator.platform;
497    const ua = userAgent || window.navigator.userAgent;
498    const device = {
499      ios: false,
500      android: false
501    };
502    const screenWidth = window.screen.width;
503    const screenHeight = window.screen.height;
504    const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
505    let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
506    const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
507    const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
508    const windows = platform === 'Win32';
509    let macos = platform === 'MacIntel';
510
511    // iPadOs 13 fix
512    const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
513    if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
514      ipad = ua.match(/(Version)\/([\d.]+)/);
515      if (!ipad) ipad = [0, 1, '13_0_0'];
516      macos = false;
517    }
518
519    // Android
520    if (android && !windows) {
521      device.os = 'android';
522      device.android = true;
523    }
524    if (ipad || iphone || ipod) {
525      device.os = 'ios';
526      device.ios = true;
527    }
528
529    // Export object
530    return device;
531  }
532  function getDevice(overrides) {
533    if (overrides === void 0) {
534      overrides = {};
535    }
536    if (!deviceCached) {
537      deviceCached = calcDevice(overrides);
538    }
539    return deviceCached;
540  }
541
542  let browser;
543  function calcBrowser() {
544    const window = getWindow();
545    const device = getDevice();
546    let needPerspectiveFix = false;
547    function isSafari() {
548      const ua = window.navigator.userAgent.toLowerCase();
549      return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
550    }
551    if (isSafari()) {
552      const ua = String(window.navigator.userAgent);
553      if (ua.includes('Version/')) {
554        const [major, minor] = ua.split('Version/')[1].split(' ')[0].split('.').map(num => Number(num));
555        needPerspectiveFix = major < 16 || major === 16 && minor < 2;
556      }
557    }
558    const isWebView = /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent);
559    const isSafariBrowser = isSafari();
560    const need3dFix = isSafariBrowser || isWebView && device.ios;
561    return {
562      isSafari: needPerspectiveFix || isSafariBrowser,
563      needPerspectiveFix,
564      need3dFix,
565      isWebView
566    };
567  }
568  function getBrowser() {
569    if (!browser) {
570      browser = calcBrowser();
571    }
572    return browser;
573  }
574
575  function Resize(_ref) {
576    let {
577      swiper,
578      on,
579      emit
580    } = _ref;
581    const window = getWindow();
582    let observer = null;
583    let animationFrame = null;
584    const resizeHandler = () => {
585      if (!swiper || swiper.destroyed || !swiper.initialized) return;
586      emit('beforeResize');
587      emit('resize');
588    };
589    const createObserver = () => {
590      if (!swiper || swiper.destroyed || !swiper.initialized) return;
591      observer = new ResizeObserver(entries => {
592        animationFrame = window.requestAnimationFrame(() => {
593          const {
594            width,
595            height
596          } = swiper;
597          let newWidth = width;
598          let newHeight = height;
599          entries.forEach(_ref2 => {
600            let {
601              contentBoxSize,
602              contentRect,
603              target
604            } = _ref2;
605            if (target && target !== swiper.el) return;
606            newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
607            newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
608          });
609          if (newWidth !== width || newHeight !== height) {
610            resizeHandler();
611          }
612        });
613      });
614      observer.observe(swiper.el);
615    };
616    const removeObserver = () => {
617      if (animationFrame) {
618        window.cancelAnimationFrame(animationFrame);
619      }
620      if (observer && observer.unobserve && swiper.el) {
621        observer.unobserve(swiper.el);
622        observer = null;
623      }
624    };
625    const orientationChangeHandler = () => {
626      if (!swiper || swiper.destroyed || !swiper.initialized) return;
627      emit('orientationchange');
628    };
629    on('init', () => {
630      if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
631        createObserver();
632        return;
633      }
634      window.addEventListener('resize', resizeHandler);
635      window.addEventListener('orientationchange', orientationChangeHandler);
636    });
637    on('destroy', () => {
638      removeObserver();
639      window.removeEventListener('resize', resizeHandler);
640      window.removeEventListener('orientationchange', orientationChangeHandler);
641    });
642  }
643
644  function Observer(_ref) {
645    let {
646      swiper,
647      extendParams,
648      on,
649      emit
650    } = _ref;
651    const observers = [];
652    const window = getWindow

652();
653    const attach = function (target, options) {
654      if (options === void 0) {
655        options = {};
656      }
657      const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
658      const observer = new ObserverFunc(mutations => {
659        // The observerUpdate event should only be triggered
660        // once despite the number of mutations.  Additional
661        // triggers are redundant and are very costly
662        if (swiper.__preventObserver__) return;
663        if (mutations.length === 1) {
664          emit('observerUpdate', mutations[0]);
665          return;
666        }
667        const observerUpdate = function observerUpdate() {
668          emit('observerUpdate', mutations[0]);
669        };
670        if (window.requestAnimationFrame) {
671          window.requestAnimationFrame(observerUpdate);
672        } else {
673          window.setTimeout(observerUpdate, 0);
674        }
675      });
676      observer.observe(target, {
677        attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
678        childList: swiper.isElement || (typeof options.childList === 'undefined' ? true : options).childList,
679        characterData: typeof options.characterData === 'undefined' ? true : options.characterData
680      });
681      observers.push(observer);
682    };
683    const init = () => {
684      if (!swiper.params.observer) return;
685      if (swiper.params.observeParents) {
686        const containerParents = elementParents(swiper.hostEl);
687        for (let i = 0; i < containerParents.length; i += 1) {
688          attach(containerParents[i]);
689        }
690      }
691      // Observe container
692      attach(swiper.hostEl, {
693        childList: swiper.params.observeSlideChildren
694      });
695
696      // Observe wrapper
697      attach(swiper.wrapperEl, {
698        attributes: false
699      });
700    };
701    const destroy = () => {
702      observers.forEach(observer => {
703        observer.disconnect();
704      });
705      observers.splice(0, observers.length);
706    };
707    extendParams({
708      observer: false,
709      observeParents: false,
710      observeSlideChildren: false
711    });
712    on('init', init);
713    on('destroy', destroy);
714  }
715
716  /* eslint-disable no-underscore-dangle */
717
718  var eventsEmitter = {
719    on(events, handler, priority) {
720      const self = this;
721      if (!self.eventsListeners || self.destroyed) return self;
722      if (typeof handler !== 'function') return self;
723      const method = priority ? 'unshift' : 'push';
724      events.split(' ').forEach(event => {
725        if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
726        self.eventsListeners[event][method](handler);
727      });
728      return self;
729    },
730    once(events, handler, priority) {
731      const self = this;
732      if (!self.eventsListeners || self.destroyed) return self;
733      if (typeof handler !== 'function') return self;
734      function onceHandler() {
735        self.off(events, onceHandler);
736        if (onceHandler.__emitterProxy) {
737          delete onceHandler.__emitterProxy;
738        }
739        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
740          args[_key] = arguments[_key];
741        }
742        handler.apply(self, args);
743      }
744      onceHandler.__emitterProxy = handler;
745      return self.on(events, onceHandler, priority);
746    },
747    onAny(handler, priority) {
748      const self = this;
749      if (!self.eventsListeners || self.destroyed) return self;
750      if (typeof handler !== 'function') return self;
751      const method = priority ? 'unshift' : 'push';
752      if (self.eventsAnyListeners.indexOf(handler) < 0) {
753        self.eventsAnyListeners[method](handler);
754      }
755      return self;
756    },
757    offAny(handler) {
758      const self = this;
759      if (!self.eventsListeners || self.destroyed) return self;
760      if (!self.eventsAnyListeners) return self;
761      const index = self.eventsAnyListeners.indexOf(handler);
762      if (index >= 0) {
763        self.eventsAnyListeners.splice(index, 1);
764      }
765      return self;
766    },
767    off(events, handler) {
768      const self = this;
769      if (!self.eventsListeners || self.destroyed) return self;
770      if (!self.eventsListeners) return self;
771      events.split(' ').forEach(event => {
772        if (typeof handler === 'undefined') {
773          self.eventsListeners[event] = [];
774        } else if (self.eventsListeners[event]) {
775          self.eventsListeners[event].forEach((eventHandler, index) => {
776            if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
777              self.eventsListeners[event].splice(index, 1);
778            }
779          });
780        }
781      });
782      return self;
783    },
784    emit() {
785      const self = this;
786      if (!self.eventsListeners || self.destroyed) return self;
787      if (!self.eventsListeners) return self;
788      let events;
789      let data;
790      let context;
791      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
792        args[_key2] = arguments[_key2];
793      }
794      if (typeof args[0] === 'string' || Array.isArray(args[0])) {
795        events = args[0];
796        data = args.slice(1, args.length);
797        context = self;
798      } else {
799        events = args[0].events;
800        data = args[0].data;
801        context = args[0].context || self;
802      }
803      data.unshift(context);
804      const eventsArray = Array.isArray(events) ? events : events.split(' ');
805      eventsArray.forEach(event => {
806        if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
807          self.eventsAnyListeners.forEach(eventHandler => {
808            eventHandler.apply(context, [event, ...data]);
809          });
810        }
811        if (self.eventsListeners && self.eventsListeners[event]) {
812          self.eventsListeners[event].forEach(eventHandler => {
813            eventHandler.apply(context, data);
814          });
815        }
816      });
817      return self;
818    }
819  };
820
821  function updateSize() {
822    const swiper = this;
823    let width;
824    let height;
825    const el = swiper.el;
826    if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
827      width = swiper.params.width;
828    } else {
829      width = el.clientWidth;
830    }
831    if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
832      height = swiper.params.height;
833    } else {
834      height = el.clientHeight;
835    }
836    if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
837      return;
838    }
839
840    // Subtract paddings
841    width = width - parseInt(elementStyle(el, 'padding-left') || 0, 10) - parseInt(elementStyle(el, 'padding-right') || 0, 10);
842    height = height - parseInt(elementStyle(el, 'padding-top') || 0, 10) - parseInt(elementStyle(el, 'padding-bottom') || 0, 10);
843    if (Number.isNaN(width)) width = 0;
844    if (Number.isNaN(height)) height = 0;
845    Object.assign(swiper, {
846      width,
847      height,
848      size: swiper.isHorizontal() ? width : height
849    });
850  }
851
852  function updateSlides() {
853    const swiper = this;
854    function getDirectionPropertyValue(node, label) {
855      return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
856    }
857    const params = swiper.params;
858    const {
859      wrapperEl,
860      slidesEl,
861      size: swiperSize,
862      rtlTranslate: rtl,
863      wrongRTL
864    } = swiper;
865    const isVirtual = swiper.virtual && params.virtual.enabled;
866    const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
867    const slides = elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
868    const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
869    let snapGrid = [];
870    const slidesGrid = [];
871    const slidesSizesGrid = [];
872    let offsetBefore = params.slidesOffsetBefore;
873    if (typeof offsetBefore === 'function') {
874      offsetBefore = params.slidesOffsetBefore.call(swiper);
875    }
876    let offsetAfter = params.slidesOffsetAfter;
877    if (typeof offsetAfter === 'function') {
878      offsetAfter = params.slidesOffsetAfter.call(swiper);
879    }
880    const previousSnapGridLength = swiper.snapGrid.length;
881    const previousSlidesGridLength = swiper.slidesGrid.length;
882    let spaceBetween = params.spaceBetween;
883    let slidePosition = -offsetBefore;
884    let prevSlideSize = 0;
885    let index = 0;
886    if (typeof swiperSize === 'undefined') {
887      return;
888    }
889    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
890      spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
891    } else if (typeof spaceBetween === 'string') {
892      spaceBetween = parseFloat(spaceBetween);
893    }
894    swiper.virtualSize = -spaceBetween;
895
896    // reset margins
897    slides.forEach(slideEl => {
898      if (rtl) {
899        slideEl.style.marginLeft = '';
900      } else {
901        slideEl.style.marginRight = '';
902      }
903      slideEl.style.marginBottom = '';
904      slideEl.style.marginTop = '';
905    });
906
907    // reset cssMode offsets
908    if (params.centeredSlides && params.cssMode) {
909      setCSSProperty

910(wrapperEl, '--swiper-centered-offset-after', '');
911    }
912    const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
913    if (gridEnabled) {
914      swiper.grid.initSlides(slides);
915    } else if (swiper.grid) {
916      swiper.grid.unsetSlides();
917    }
918
919    // Calc slides
920    let slideSize;
921    const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
922      return typeof params.breakpoints[key].slidesPerView !== 'undefined';
923    }).length > 0;
924    for (let i = 0; i < slidesLength; i += 1) {
925      slideSize = 0;
926      let slide;
927      if (slides[i]) slide = slides[i];
928      if (gridEnabled) {
929        swiper.grid.updateSlide(i, slide, slides);
930      }
931      if (slides[i] && elementStyle(slide, 'display') === 'none') continue; // eslint-disable-line
932
933      if (params.slidesPerView === 'auto') {
934        if (shouldResetSlideSize) {
935          slides[i].style[swiper.getDirectionLabel('width')] = ``;
936        }
937        const slideStyles = getComputedStyle(slide);
938        const currentTransform = slide.style.transform;
939        const currentWebKitTransform = slide.style.webkitTransform;
940        if (currentTransform) {
941          slide.style.transform = 'none';
942        }
943        if (currentWebKitTransform) {
944          slide.style.webkitTransform = 'none';
945        }
946        if (params.roundLengths) {
947          slideSize = swiper.isHorizontal() ? elementOuterSize(slide, 'width', true) : elementOuterSize(slide, 'height', true);
948        } else {
949          // eslint-disable-next-line
950          const width = getDirectionPropertyValue(slideStyles, 'width');
951          const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
952          const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
953          const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
954          const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
955          const boxSizing = slideStyles.getPropertyValue('box-sizing');
956          if (boxSizing && boxSizing === 'border-box') {
957            slideSize = width + marginLeft + marginRight;
958          } else {
959            const {
960              clientWidth,
961              offsetWidth
962            } = slide;
963            slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
964          }
965        }
966        if (currentTransform) {
967          slide.style.transform = currentTransform;
968        }
969        if (currentWebKitTransform) {
970          slide.style.webkitTransform = currentWebKitTransform;
971        }
972        if (params.roundLengths) slideSize = Math.floor(slideSize);
973      } else {
974        slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
975        if (params.roundLengths) slideSize = Math.floor(slideSize);
976        if (slides[i]) {
977          slides[i].style[swiper.getDirectionLabel('width')] = `${slideSize}px`;
978        }
979      }
980      if (slides[i]) {
981        slides[i].swiperSlideSize = slideSize;
982      }
983      slidesSizesGrid.push(slideSize);
984      if (params.centeredSlides) {
985        slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
986        if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
987        if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
988        if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
989        if (params.roundLengths) slidePosition = Math.floor(slidePosition);
990        if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
991        slidesGrid.push(slidePosition);
992      } else {
993        if (params.roundLengths) slidePosition = Math.floor(slidePosition);
994        if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
995        slidesGrid.push(slidePosition);
996        slidePosition = slidePosition + slideSize + spaceBetween;
997      }
998      swiper.virtualSize += slideSize + spaceBetween;
999      prevSlideSize = slideSize;
1000      index += 1;
1001    }
1002    swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1003    if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1004      wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
1005    }
1006    if (params.setWrapperSize) {
1007      wrapperEl.style[swiper.getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;
1008    }
1009    if (gridEnabled) {
1010      swiper.grid.updateWrapperSize(slideSize, snapGrid);
1011    }
1012
1013    // Remove last grid elements depending on width
1014    if (!params.centeredSlides) {
1015      const newSlidesGrid = [];
1016      for (let i = 0; i < snapGrid.length; i += 1) {
1017        let slidesGridItem = snapGrid[i];
1018        if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1019        if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1020          newSlidesGrid.push(slidesGridItem);
1021        }
1022      }
1023      snapGrid = newSlidesGrid;
1024      if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1025        snapGrid.push(swiper.virtualSize - swiperSize);
1026      }
1027    }
1028    if (isVirtual && params.loop) {
1029      const size = slidesSizesGrid[0] + spaceBetween;
1030      if (params.slidesPerGroup > 1) {
1031        const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
1032        const groupSize = size * params.slidesPerGroup;
1033        for (let i = 0; i < groups; i += 1) {
1034          snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1035        }
1036      }
1037      for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1038        if (params.slidesPerGroup === 1) {
1039          snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1040        }
1041        slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1042        swiper.virtualSize += size;
1043      }
1044    }
1045    if (snapGrid.length === 0) snapGrid = [0];
1046    if (spaceBetween !== 0) {
1047      const key = swiper.isHorizontal() && rtl ? 'marginLeft' : swiper.getDirectionLabel('marginRight');
1048      slides.filter((_, slideIndex) => {
1049        if (!params.cssMode || params.loop) return true;
1050        if (slideIndex === slides.length - 1) {
1051          return false;
1052        }
1053        return true;
1054      }).forEach(slideEl => {
1055        slideEl.style[key] = `${spaceBetween}px`;
1056      });
1057    }
1058    if (params.centeredSlides && params.centeredSlidesBounds) {
1059      let allSlidesSize = 0;
1060      slidesSizesGrid.forEach(slideSizeValue => {
1061        allSlidesSize += slideSizeValue + (spaceBetween || 0);
1062      });
1063      allSlidesSize -= spaceBetween;
1064      const maxSnap = allSlidesSize > swiperSize ? allSlidesSize - swiperSize : 0;
1065      snapGrid = snapGrid.map(snap => {
1066        if (snap <= 0) return -offsetBefore;
1067        if (snap > maxSnap) return maxSnap + offsetAfter;
1068        return snap;
1069      });
1070    }
1071    if (params.centerInsufficientSlides) {
1072      let allSlidesSize = 0;
1073      slidesSizesGrid.forEach(slideSizeValue => {
1074        allSlidesSize += slideSizeValue + (spaceBetween || 0);
1075      });
1076      allSlidesSize -= spaceBetween;
1077      const offsetSize = (params.slidesOffsetBefore || 0) + (params.slidesOffsetAfter || 0);
1078      if (allSlidesSize + offsetSize < swiperSize) {
1079        const allSlidesOffset = (swiperSize - allSlidesSize - offsetSize) / 2;
1080        snapGrid.forEach((snap, snapIndex) => {
1081          snapGrid[snapIndex] = snap - allSlidesOffset;
1082        });
1083        slidesGrid.forEach((snap, snapIndex) => {
1084          slidesGrid[snapIndex] = snap + allSlidesOffset;
1085        });
1086      }
1087    }
1088    Object.assign(swiper, {
1089      slides,
1090      snapGrid,
1091      slidesGrid,
1092      slidesSizesGrid
1093    });
1094    if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1095      setCSSProperty

1096(wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1097      const addToSnapGrid = -swiper.snapGrid[0];
1098      const addToSlidesGrid = -swiper.slidesGrid[0];
1099      swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1100      swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1101    }
1102    if (slidesLength !== previousSlidesLength) {
1103      swiper.emit('slidesLengthChange');
1104    }
1105    if (snapGrid.length !== previousSnapGridLength) {
1106      if (swiper.params.watchOverflow) swiper.checkOverflow();
1107      swiper.emit('snapGridLengthChange');
1108    }
1109    if (slidesGrid.length !== previousSlidesGridLength) {
1110      swiper.emit('slidesGridLengthChange');
1111    }
1112    if (params.watchSlidesProgress) {
1113      swiper.updateSlidesOffset();
1114    }
1115    swiper.emit('slidesUpdated');
1116    if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1117      const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1118      const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1119      if (slidesLength <= params.maxBackfaceHiddenSlides) {
1120        if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1121      } else if (hasClassBackfaceClassAdded) {
1122        swiper.el.classList.remove(backFaceHiddenClass);
1123      }
1124    }
1125  }
1126
1127  function updateAutoHeight(speed) {
1128    const swiper = this;
1129    const activeSlides = [];
1130    const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1131    let newHeight = 0;
1132    let i;
1133    if (typeof speed === 'number') {
1134      swiper.setTransition(speed);
1135    } else if (speed === true) {
1136      swiper.setTransition(swiper.params.speed);
1137    }
1138    const getSlideByIndex = index => {
1139      if (isVirtual) {
1140        return swiper.slides[swiper.getSlideIndexByData(index)];
1141      }
1142      return swiper.slides[index];
1143    };
1144    // Find slides currently in view
1145    if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1146      if (swiper.params.centeredSlides) {
1147        (swiper.visibleSlides || []).forEach(slide => {
1148          activeSlides.push(slide);
1149        });
1150      } else {
1151        for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1152          const index = swiper.activeIndex + i;
1153          if (index > swiper.slides.length && !isVirtual) break;
1154          activeSlides.push(getSlideByIndex(index));
1155        }
1156      }
1157    } else {
1158      activeSlides.push(getSlideByIndex(swiper.activeIndex));
1159    }
1160
1161    // Find new height from highest slide in view
1162    for (i = 0; i < activeSlides.length; i += 1) {
1163      if (typeof activeSlides[i] !== 'undefined') {
1164        const height = activeSlides[i].offsetHeight;
1165        newHeight = height > newHeight ? height : newHeight;
1166      }
1167    }
1168
1169    // Update Height
1170    if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;
1171  }
1172
1173  function updateSlidesOffset() {
1174    const swiper = this;
1175    const slides = swiper.slides;
1176    // eslint-disable-next-line
1177    const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;
1178    for (let i = 0; i < slides.length; i += 1) {
1179      slides[i].swiperSlideOffset = (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) - minusOffset - swiper.cssOverflowAdjustment();
1180    }
1181  }
1182
1183  const toggleSlideClasses$1 = (slideEl, condition, className) => {
1184    if (condition && !slideEl.classList.contains(className)) {
1185      slideEl.classList.add(className);
1186    } else if (!condition && slideEl.classList.contains(className)) {
1187      slideEl.classList.remove(className);
1188    }
1189  };
1190  function updateSlidesProgress(translate) {
1191    if (translate === void 0) {
1192      translate = this && this.translate || 0;
1193    }
1194    const swiper = this;
1195    const params = swiper.params;
1196    const {
1197      slides,
1198      rtlTranslate: rtl,
1199      snapGrid
1200    } = swiper;
1201    if (slides.length === 0) return;
1202    if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
1203    let offsetCenter = -translate;
1204    if (rtl) offsetCenter = translate;
1205    swiper.visibleSlidesIndexes = [];
1206    swiper.visibleSlides = [];
1207    let spaceBetween = params.spaceBetween;
1208    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1209      spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;
1210    } else if (typeof spaceBetween === 'string') {
1211      spaceBetween = parseFloat(spaceBetween);
1212    }
1213    for (let i = 0; i < slides.length; i += 1) {
1214      const slide = slides[i];
1215      let slideOffset = slide.swiperSlideOffset;
1216      if (params.cssMode && params.centeredSlides) {
1217        slideOffset -= slides[0].swiperSlideOffset;
1218      }
1219      const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1220      const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1221      const slideBefore = -(offsetCenter - slideOffset);
1222      const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1223      const isFullyVisible = slideBefore >= 0 && slideBefore <= swiper.size - swiper.slidesSizesGrid[i];
1224      const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1225      if (isVisible) {
1226        swiper.visibleSlides.push(slide);
1227        swiper.visibleSlidesIndexes.push(i);
1228      }
1229      toggleSlideClasses$1(slide, isVisible, params.slideVisibleClass);
1230      toggleSlideClasses$1(slide, isFullyVisible, params.slideFullyVisibleClass);
1231      slide.progress = rtl ? -slideProgress : slideProgress;
1232      slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1233    }
1234  }
1235
1236  function updateProgress(translate) {
1237    const swiper = this;
1238    if (typeof translate === 'undefined') {
1239      const multiplier = swiper.rtlTranslate ? -1 : 1;
1240      // eslint-disable-next-line
1241      translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
1242    }
1243    const params = swiper.params;
1244    const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1245    let {
1246      progress,
1247      isBeginning,
1248      isEnd,
1249      progressLoop
1250    } = swiper;
1251    const wasBeginning = isBeginning;
1252    const wasEnd = isEnd;
1253    if (translatesDiff === 0) {
1254      progress = 0;
1255      isBeginning = true;
1256      isEnd = true;
1257    } else {
1258      progress = (translate - swiper.minTranslate()) / translatesDiff;
1259      const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;
1260      const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;
1261      isBeginning = isBeginningRounded || progress <= 0;
1262      isEnd = isEndRounded || progress >= 1;
1263      if (isBeginningRounded) progress = 0;
1264      if (isEndRounded) progress = 1;
1265    }
1266    if (params.loop) {
1267      const firstSlideIndex = swiper.getSlideIndexByData(0);
1268      const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1269      const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1270      const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1271      const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1272      const translateAbs = Math.abs(translate);
1273      if (translateAbs >= firstSlideTranslate) {
1274        progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
1275      } else {
1276        progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1277      }
1278      if (progressLoop > 1) progressLoop -= 1;
1279    }
1280    Object.assign(swiper, {
1281      progress,
1282      progressLoop,
1283      isBeginning,
1284      isEnd
1285    });
1286    if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
1287    if (isBeginning && !wasBeginning) {
1288      swiper.emit('reachBeginning toEdge');
1289    }
1290    if (isEnd && !wasEnd) {
1291      swiper.emit('reachEnd toEdge');
1292    }
1293    if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
1294      swiper.emit('fromEdge');
1295    }
1296    swiper.emit('progress', progress);
1297  }
1298
1299  const toggleSlideClasses = (slideEl, condition, className) => {
1300    if (condition && !slideEl.classList.contains(className)) {
1301      slideEl.classList.add(className);
1302    } else if (!condition && slideEl.classList.contains(className)) {
1303      slideEl.classList.remove(className);
1304    }
1305  };
1306  function updateSlidesClasses() {
1307    const swiper = this;
1308    const {
1309      slides,
1310      params,
1311      slidesEl,
1312      activeIndex
1313    } = swiper;
1314    const isVirtual = swiper.virtual && params.virtual.enabled;
1315    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1316    const getFilteredSlide = selector => {
1317      return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1318    };
1319    let activeSlide;
1320    let prevSlide;
1321    let nextSlide;
1322    if (isVirtual) {
1323      if (params.loop) {
1324        let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1325        if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1326        if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1327        activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1328      } else {
1329        activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1330      }
1331    } else {
1332      if (gridEnabled) {
1333        activeSlide = slides.fi

1335;
1336      } else {
1337        activeSlide = slides[activeIndex];
1338      }
1339    }
1340    if (activeSlide) {
1341      if (!gridEnabled) {
1342        // Next Slide
1343        nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1344        if (params.loop && !nextSlide) {
1345          nextSlide = slides[0];
1346        }
1347
1348        // Prev Slide
1349        prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1350        if (params.loop && !prevSlide === 0) {
1351          prevSlide = slides[slides.length - 1];
1352        }
1353      }
1354    }
1355    slides.forEach(slideEl => {
1356      toggleSlideClasses(slideEl, slideEl === activeSlide, params.slideActiveClass);
1357      toggleSlideClasses(slideEl, slideEl === nextSlide, params.slideNextClass);
1358      toggleSlideClasses(slideEl, slideEl === prevSlide, params.slidePrevClass);
1359    });
1360    swiper.emitSlidesClasses();
1361  }
1362
1363  const processLazyPreloader = (swiper, imageEl) => {
1364    if (!swiper || swiper.destroyed || !swiper.params) return;
1365    const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1366    const slideEl = imageEl.closest(slideSelector());
1367    if (slideEl) {
1368      let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1369      if (!lazyEl && swiper.isElement) {
1370        if (slideEl.shadowRoot) {
1371          lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1372        } else {
1373          // init later
1374          requestAnimationFrame(() => {
1375            if (slideEl.shadowRoot) {
1376              lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1377              if (lazyEl) lazyEl.remove();
1378            }
1379          });
1380        }
1381      }
1382      if (lazyEl) lazyEl.remove();
1383    }
1384  };
1385  const unlazy = (swiper, index) => {
1386    if (!swiper.slides[index]) return;
1387    const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1388    if (imageEl) imageEl.removeAttribute('loading');
1389  };
1390  const preload = swiper => {
1391    if (!swiper || swiper.destroyed || !swiper.params) return;
1392    let amount = swiper.params.lazyPreloadPrevNext;
1393    const len = swiper.slides.length;
1394    if (!len || !amount || amount < 0) return;
1395    amount = Math.min(amount, len);
1396    const slidesPerView = swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1397    const activeIndex = swiper.activeIndex;
1398    if (swiper.params.grid && swiper.params.grid.rows > 1) {
1399      const activeColumn = activeIndex;
1400      const preloadColumns = [activeColumn - amount];
1401      preloadColumns.push(...Array.from({
1402        length: amount
1403      }).map((_, i) => {
1404        return activeColumn + slidesPerView + i;
1405      }));
1406      swiper.slides.forEach((slideEl, i) => {
1407        if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1408      });
1409      return;
1410    }
1411    const slideIndexLastInView = activeIndex + slidesPerView - 1;
1412    if (swiper.params.rewind || swiper.params.loop) {
1413      for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1414        const realIndex = (i % len + len) % len;
1415        if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1416      }
1417    } else {
1418      for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1419        if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1420          unlazy(swiper, i);
1421        }
1422      }
1423    }
1424  };
1425
1426  function getActiveIndexByTranslate(swiper) {
1427    const {
1428      slidesGrid,
1429      params
1430    } = swiper;
1431    const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1432    let activeIndex;
1433    for (let i = 0; i < slidesGrid.length; i += 1) {
1434      if (typeof slidesGrid[i + 1] !== 'undefined') {
1435        if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1436          activeIndex = i;
1437        } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1438          activeIndex = i + 1;
1439        }
1440      } else if (translate >= slidesGrid[i]) {
1441        activeIndex = i;
1442      }
1443    }
1444    // Normalize slideIndex
1445    if (params.normalizeSlideIndex) {
1446      if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1447    }
1448    return activeIndex;
1449  }
1450  function updateActiveIndex(newActiveIndex) {
1451    const swiper = this;
1452    const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1453    const {
1454      snapGrid,
1455      params,
1456      activeIndex: previousIndex,
1457      realIndex: previousRealIndex,
1458      snapIndex: previousSnapIndex
1459    } = swiper;
1460    let activeIndex = newActiveIndex;
1461    let snapIndex;
1462    const getVirtualRealIndex = aIndex => {
1463      let realIndex = aIndex - swiper.virtual.slidesBefore;
1464      if (realIndex < 0) {
1465        realIndex = swiper.virtual.slides.length + realIndex;
1466      }
1467      if (realIndex >= swiper.virtual.slides.length) {
1468        realIndex -= swiper.virtual.slides.length;
1469      }
1470      return realIndex;
1471    };
1472    if (typeof activeIndex === 'undefined') {
1473      activeIndex = getActiveIndexByTranslate(swiper);
1474    }
1475    if (snapGrid.indexOf(translate) >= 0) {
1476      snapIndex = snapGrid.indexOf(translate);
1477    } else {
1478      const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1479      snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1480    }
1481    if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1482    if (activeIndex === previousIndex && !swiper.params.loop) {
1483      if (snapIndex !== previousSnapIndex) {
1484        swiper.snapIndex = snapIndex;
1485        swiper.emit('snapIndexChange');
1486      }
1487      return;
1488    }
1489    if (activeIndex === previousIndex && swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1490      swiper.realIndex = getVirtualRealIndex(activeIndex);
1491      return;
1492    }
1493    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1494
1495    // Get real index
1496    let realIndex;
1497    if (swiper.virtual && params.virtual.enabled && params.loop) {
1498      realIndex = getVirtualRealIndex(activeIndex);
1499    } else if (gridEnabled) {
1500      const firstSlideInColumn = swiper.slides.fi

1500;
1501      let activeSlideIndex = parseInt(firstSlideInColumn.getAttribute('data-swiper-slide-index'), 10);
1502      if (Number.isNaN(activeSlideIndex)) {
1503        activeSlideIndex = Math.max(swiper.slides.indexOf(firstSlideInColumn), 0);
1504      }
1505      realIndex = Math.floor(activeSlideIndex / params.grid.rows);
1506    } else if (swiper.slides[activeIndex]) {
1507      const slideIndex = swiper.slides[activeIndex].getAttribute('data-swiper-slide-index');
1508      if (slideIndex) {
1509        realIndex = parseInt(slideIndex, 10);
1510      } else {
1511        realIndex = activeIndex;
1512      }
1513    } else {
1514      realIndex = activeIndex;
1515    }
1516    Object.assign(swiper, {
1517      previousSnapIndex,
1518      snapIndex,
1519      previousRealIndex,
1520      realIndex,
1521      previousIndex,
1522      activeIndex
1523    });
1524    if (swiper.initialized) {
1525      preload(swiper);
1526    }
1527    swiper.emit('activeIndexChange');
1528    swiper.emit('snapIndexChange');
1529    if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1530      if (previousRealIndex !== realIndex) {
1531        swiper.emit('realIndexChange');
1532      }
1533      swiper.emit('slideChange');
1534    }
1535  }
1536
1537  function updateClickedSlide(el, path) {
1538    const swiper = this;
1539    const params = swiper.params;
1540    let slide = el.closest(`.${params.slideClass}, swiper-slide`);
1541    if (!slide && swiper.isElement && path && path.length > 1 && path.includes(el)) {
1542      [...path.slice(path.indexOf(el) + 1, path.length)].forEach(pathEl => {
1543        if (!slide && pathEl.matches && pathEl.matches(`.${params.slideClass}, swiper-slide`)) {
1544          slide = pathEl;
1545        }
1546      });
1547    }
1548    let slideFound = false;
1549    let slideIndex;
1550    if (slide) {
1551      for (let i = 0; i < swiper.slides.length; i += 1) {
1552        if (swiper.slides[i] === slide) {
1553          slideFound = true;
1554          slideIndex = i;
1555          break;
1556        }
1557      }
1558    }
1559    if (slide && slideFound) {
1560      swiper.clickedSlide = slide;
1561      if (swiper.virtual && swiper.params.virtual.enabled) {
1562        swiper.clickedIndex = parseInt(slide.getAttribute('data-swiper-slide-index'), 10);
1563      } else {
1564        swiper.clickedIndex = slideIndex;
1565      }
1566    } else {
1567      swiper.clickedSlide = undefined;
1568      swiper.clickedIndex = undefined;
1569      return;
1570    }
1571    if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1572      swiper.slideToClickedSlide();
1573    }
1574  }
1575
1576  var update = {
1577    updateSize,
1578    updateSlides,
1579    updateAutoHeight,
1580    updateSlidesOffset,
1581    updateSlidesProgress,
1582    updateProgress,
1583    updateSlidesClasses,
1584    updateActiveIndex,
1585    updateClickedSlide
1586  };
1587
1588  function getSwiperTranslate(axis) {
1589    if (axis === void 0) {
1590      axis = this.isHorizontal() ? 'x' : 'y';
1591    }
1592    const swiper = this;
1593    const {
1594      params,
1595      rtlTranslate: rtl,
1596      translate,
1597      wrapperEl
1598    } = swiper;
1599    if (params.virtualTranslate) {
1600      return rtl ? -translate : translate;
1601    }
1602    if (params.cssMode) {
1603      return translate;
1604    }
1605    let currentTranslate = getTranslate(wrapperEl, axis);
1606    currentTranslate += swiper.cssOverflowAdjustment();
1607    if (rtl) currentTranslate = -currentTranslate;
1608    return currentTranslate || 0;
1609  }
1610
1611  function setTranslate(translate, byController) {
1612    const swiper = this;
1613    const {
1614      rtlTranslate: rtl,
1615      params,
1616      wrapperEl,
1617      progress
1618    } = swiper;
1619    let x = 0;
1620    let y = 0;
1621    const z = 0;
1622    if (swiper.isHorizontal()) {
1623      x = rtl ? -translate : translate;
1624    } else {
1625      y = translate;
1626    }
1627    if (params.roundLengths) {
1628      x = Math.floor(x);
1629      y = Math.floor(y);
1630    }
1631    swiper.previousTranslate = swiper.translate;
1632    swiper.translate = swiper.isHorizontal() ? x : y;
1633    if (params.cssMode) {
1634      wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
1635    } else if (!params.virtualTranslate) {
1636      if (swiper.isHorizontal()) {
1637        x -= swiper.cssOverflowAdjustment();
1638      } else {
1639        y -= swiper.cssOverflowAdjustment();
1640      }
1641      wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1642    }
1643
1644    // Check if we need to update progress
1645    let newProgress;
1646    const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1647    if (translatesDiff === 0) {
1648      newProgress = 0;
1649    } else {
1650      newProgress = (translate - swiper.minTranslate()) / translatesDiff;
1651    }
1652    if (newProgress !== progress) {
1653      swiper.updateProgress(translate);
1654    }
1655    swiper.emit('setTranslate', swiper.translate, byController);
1656  }
1657
1658  function minTranslate() {
1659    return -this.snapGrid[0];
1660  }
1661
1662  function maxTranslate() {
1663    return -this.snapGrid[this.snapGrid.length - 1];
1664  }
1665
1666  function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
1667    if (translate === void 0) {
1668      translate = 0;
1669    }
1670    if (speed === void 0) {
1671      speed = this.params.speed;
1672    }
1673    if (runCallbacks === void 0) {
1674      runCallbacks = true;
1675    }
1676    if (translateBounds === void 0) {
1677      translateBounds = true;
1678    }
1679    const swiper = this;
1680    const {
1681      params,
1682      wrapperEl
1683    } = swiper;
1684    if (swiper.animating && params.preventInteractionOnTransition) {
1685      return false;
1686    }
1687    const minTranslate = swiper.minTranslate();
1688    const maxTranslate = swiper.maxTranslate();
1689    let newTranslate;
1690    if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate;
1691
1692    // Update progress
1693    swiper.updateProgress(newTranslate);
1694    if (params.cssMode) {
1695      const isH = swiper.isHorizontal();
1696      if (speed === 0) {
1697        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1698      } else {
1699        if (!swiper.support.smoothScroll) {
1700          animateCSSModeScroll({
1701            swiper,
1702            targetPosition: -newTranslate,
1703            side: isH ? 'left' : 'top'
1704          });
1705          return true;
1706        }
1707        wrapperEl.scrollTo({
1708          [isH ? 'left' : 'top']: -newTranslate,
1709          behavior: 'smooth'
1710        });
1711      }
1712      return true;
1713    }
1714    if (speed === 0) {
1715      swiper.setTransition(0);
1716      swiper.setTranslate(newTranslate);
1717      if (runCallbacks) {
1718        swiper.emit('beforeTransitionStart', speed, internal);
1719        swiper.emit('transitionEnd');
1720      }
1721    } else {
1722      swiper.setTransition(speed);
1723      swiper.setTranslate(newTranslate);
1724      if (runCallbacks) {
1725        swiper.emit('beforeTransitionStart', speed, internal);
1726        swiper.emit('transitionStart');
1727      }
1728      if (!swiper.animating) {
1729        swiper.animating = true;
1730        if (!swiper.onTranslateToWrapperTransitionEnd) {
1731          swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1732            if (!swiper || swiper.destroyed) return;
1733            if (e.target !== this) return;
1734            swiper.wrapperEl.removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1735            swiper.onTranslateToWrapperTransitionEnd = null;
1736            delete swiper.onTranslateToWrapperTransitionEnd;
1737            swiper.animating = false;
1738            if (runCallbacks) {
1739              swiper.emit('transitionEnd');
1740            }
1741          };
1742        }
1743        swiper.wrapperEl.addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1744      }
1745    }
1746    return true;
1747  }
1748
1749  var translate = {
1750    getTranslate: getSwiperTranslate,
1751    setTranslate,
1752    minTranslate,
1753    maxTranslate,
1754    translateTo
1755  };
1756
1757  function setTransition(duration, byController) {
1758    const swiper = this;
1759    if (!swiper.params.cssMode) {
1760      swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
1761      swiper.wrapperEl.style.transitionDelay = duration === 0 ? `0ms` : '';
1762    }
1763    swiper.emit('setTransition', duration, byController);
1764  }
1765
1766  function transitionEmit(_ref) {
1767    let {
1768      swiper,
1769      runCallbacks,
1770      direction,
1771      step
1772    } = _ref;
1773    const {
1774      activeIndex,
1775      previousIndex
1776    } = swiper;
1777    let dir = direction;
1778    if (!dir) {
1779      if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
1780    }
1781    swiper.emit(`transition${step}`);
1782    if (runCallbacks && 

1782activeIndex !== previousIndex) {
1783      if (dir === 'reset') {
1784        swiper.emit(`slideResetTransition${step}`);
1785        return;
1786      }
1787      swiper.emit(`slideChangeTransition${step}`);
1788      if (dir === 'next') {
1789        swiper.emit(`slideNextTransition${step}`);
1790      } else {
1791        swiper.emit(`slidePrevTransition${step}`);
1792      }
1793    }
1794  }
1795
1796  function transitionStart(runCallbacks, direction) {
1797    if (runCallbacks === void 0) {
1798      runCallbacks = true;
1799    }
1800    const swiper = this;
1801    const {
1802      params
1803    } = swiper;
1804    if (params.cssMode) return;
1805    if (params.autoHeight) {
1806      swiper.updateAutoHeight();
1807    }
1808    transitionEmit({
1809      swiper,
1810      runCallbacks,
1811      direction,
1812      step: 'Start'
1813    });
1814  }
1815
1816  function transitionEnd(runCallbacks, direction) {
1817    if (runCallbacks === void 0) {
1818      runCallbacks = true;
1819    }
1820    const swiper = this;
1821    const {
1822      params
1823    } = swiper;
1824    swiper.animating = false;
1825    if (params.cssMode) return;
1826    swiper.setTransition(0);
1827    transitionEmit({
1828      swiper,
1829      runCallbacks,
1830      direction,
1831      step: 'End'
1832    });
1833  }
1834
1835  var transition = {
1836    setTransition,
1837    transitionStart,
1838    transitionEnd
1839  };
1840
1841  function slideTo(index, speed, runCallbacks, internal, initial) {
1842    if (index === void 0) {
1843      index = 0;
1844    }
1845    if (runCallbacks === void 0) {
1846      runCallbacks = true;
1847    }
1848    if (typeof index === 'string') {
1849      index = parseInt(index, 10);
1850    }
1851    const swiper = this;
1852    let slideIndex = index;
1853    if (slideIndex < 0) slideIndex = 0;
1854    const {
1855      params,
1856      snapGrid,
1857      slidesGrid,
1858      previousIndex,
1859      activeIndex,
1860      rtlTranslate: rtl,
1861      wrapperEl,
1862      enabled
1863    } = swiper;
1864    if (!enabled && !internal && !initial || swiper.destroyed || swiper.animating && params.preventInteractionOnTransition) {
1865      return false;
1866    }
1867    if ( typeof swiper.params === 'undefined' ) { 
1868      return false;
1869    }
1870    if (typeof speed === 'undefined') {
1871      speed = swiper.params.speed;
1872    }
1873    const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
1874    let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
1875    if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1876    const translate = -snapGrid[snapIndex];
1877    // Normalize slideIndex
1878    if (params.normalizeSlideIndex) {
1879      for (let i = 0; i < slidesGrid.length; i += 1) {
1880        const normalizedTranslate = -Math.floor(translate * 100);
1881        const normalizedGrid = Math.floor(slidesGrid[i] * 100);
1882        const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
1883        if (typeof slidesGrid[i + 1] !== 'undefined') {
1884          if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
1885            slideIndex = i;
1886          } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
1887            slideIndex = i + 1;
1888          }
1889        } else if (normalizedTranslate >= normalizedGrid) {
1890          slideIndex = i;
1891        }
1892      }
1893    }
1894    // Directions locks
1895    if (swiper.initialized && slideIndex !== activeIndex) {
1896      if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) {
1897        return false;

1898      }
1899      if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
1900        if ((activeIndex || 0) !== slideIndex) {
1901          return false;
1902        }
1903      }
1904    }
1905    if (slideIndex !== (previousIndex || 0) && runCallbacks) {
1906      swiper.emit('beforeSlideChangeStart');
1907    }
1908
1909    // Update progress
1910    swiper.updateProgress(translate);
1911    let direction;
1912    if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset';
1913
1914    // initial virtual
1915    const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1916    const isInitialVirtual = isVirtual && initial;
1917    // Update Index
1918    if (!isInitialVirtual && (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate)) {
1919      swiper.updateActiveIndex(slideIndex);
1920      // Update Height
1921      if (params.autoHeight) {
1922        swiper.updateAutoHeight();
1923      }
1924      swiper.updateSlidesClasses();
1925      if (params.effect !== 'slide') {
1926        swiper.setTranslate(translate);
1927      }
1928      if (direction !== 'reset') {
1929        swiper.transitionStart(runCallbacks, direction);
1930        swiper.transitionEnd(runCallbacks, direction);
1931      }
1932      return false;
1933    }
1934    if (params.cssMode) {
1935      const isH = swiper.isHorizontal();
1936      const t = rtl ? translate : -translate;
1937      if (speed === 0) {
1938        if (isVirtual) {
1939          swiper.wrapperEl.style.scrollSnapType = 'none';
1940          swiper._immediateVirtual = true;
1941        }
1942        if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
1943          swiper._cssModeVirtualInitialSet = true;
1944          requestAnimationFrame(() => {
1945            wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1946          });
1947        } else {
1948          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1949        }
1950        if (isVirtual) {
1951          requestAnimationFrame(() => {
1952            swiper.wrapperEl.style.scrollSnapType = '';
1953            swiper._immediateVirtual = false;
1954          });
1955        }
1956      } else {
1957        if (!swiper.support.smoothScroll) {
1958          animateCSSModeScroll({
1959            swiper,
1960            targetPosition: t,
1961            side: isH ? 'left' : 'top'
1962          });
1963          return true;
1964        }
1965        wrapperEl.scrollTo({
1966          [isH ? 'left' : 'top']: t,
1967          behavior: 'smooth'
1968        });
1969      }
1970      return true;
1971    }
1972    swiper.setTransition(speed);
1973    swiper.setTranslate(translate);
1974    swiper.updateActiveIndex(slideIndex);
1975    swiper.updateSlidesClasses();
1976    swiper.emit('beforeTransitionStart', speed, internal);
1977    swiper.transitionStart(runCallbacks, direction);
1978    if (speed === 0) {
1979      swiper.transitionEnd(runCallbacks, direction);
1980    } else if (!swiper.animating) {
1981      swiper.animating = true;
1982      if (!swiper.onSlideToWrapperTransitionEnd) {
1983        swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
1984          if (!swiper || swiper.destroyed) return;
1985          if (e.target !== this) return;
1986          swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1987          swiper.onSlideToWrapperTransitionEnd = null;
1988          delete swiper.onSlideToWrapperTransitionEnd;
1989          swiper.transitionEnd(runCallbacks, direction);
1990        };
1991      }
1992      swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1993    }
1994    return true;
1995  }
1996
1997  function slideToLoop(index, speed, runCallbacks, internal) {
1998    if (index === void 0) {
1999      index = 0;
2000    }
2001    if (runCallbacks === void 0) {
2002      runCallbacks = true;
2003    }
2004    if (typeof index === 'string') {
2005      const indexAsNumber = parseInt(index, 10);
2006      index = indexAsNumber;
2007    }
2008    const swiper = this;
2009    if (swiper.destroyed) return;
2010    if (typeof speed === 'undefined') {
2011      speed = swiper.params.speed;
2012    }
2013    const gridEnabled = swiper.grid && swiper.params.grid && swiper.params.grid.rows > 1;
2014    let newIndex = index;
2015    if (swiper.params.loop) {
2016      if (swiper.virtual && swiper.params.virtual.enabled) {
2017        // eslint-disable-next-line
2018        newIndex = newIndex + swiper.virtual.slidesBefore;
2019      } else {
2020        let targetSlideIndex;
2021        if (gridEnabled) {
2022          const slideIndex = newIndex * swiper.params.grid.rows;
2023          targetSlideIndex = swiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex)[0].column;
2024        } else {
2025          targetSlideIndex = swiper.getSlideIndexByData(newIndex);
2026        }
2027        const cols = gridEnabled ? Math.ceil(swiper.slides.length / swiper.params.grid.rows) : swiper.slides.length;
2028        const {
2029          centeredSlides
2030        } = swiper.params;
2031        let slidesPerView = swiper.params.slidesPerView;
2032        if (slidesPerView === 'auto') {
2033          slidesPerView = swiper.slidesPerViewDynamic();
2034        } else {
2035          slidesPerView = Math.ceil(parseFloat(swiper.params.slidesPerView, 10));
2036          if (centeredSlides && slidesPerView % 2 === 0) {
2037            slidesPerView = slidesPerView + 1;
2038          }
2039        }
2040        let needLoopFix = cols - targetSlideIndex < slidesPerView;
2041        if (centeredSlides) {
2042          needLoopFix = needLoopFix || targetSlideIndex < Math.ceil(slidesPerView / 2);
2043        }
2044        if (internal && centeredSlides && swiper.params.slidesPerView !== 'auto' && !gridEnabled) {
2045          needLoopFix = false;
2046        }
2047        if (needLoopFix) {
2048          const direction = centeredSlides ? targetSlideIndex < swiper.activeIndex ? 'prev' : 'next' : targetSlideIndex - swiper.activeIndex - 1 < swiper.params.slidesPerView ? 'next' : 'prev';
2049          swiper.loopFix({
2050            direction,
2051            slideTo: true,
2052            activeSlideIndex: direction === 'next' ? targetSlideIndex + 1 : targetSlideIndex - cols + 1,
2053            slideRealIndex: direction === 'next' ? swiper.realIndex : undefined
2054          });
2055        }
2056        if (gridEnabled) {
2057          const slideIndex = newIndex * swiper.params.grid.rows;
2058          newIndex = swiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex)[0].column;
2059        } else {
2060          newIndex = swiper.getSlideIndexByData(newIndex);
2061        }
2062      }
2063    }
2064    requestAnimationFrame(() => {
2065      swiper.slideTo(newIndex, speed, runCallbacks, internal);
2066    });
2067    return swiper;
2068  }
2069
2070  /* eslint no-unused-vars: "off" */
2071  function slideNext(speed, runCallbacks, internal) {
2072    if (runCallbacks === void 0) {
2073      runCallbacks = true;
2074    }
2075    const swiper = this;
2076    const {
2077      enabled,
2078      params,
2079      animating
2080    } = swiper;
2081    if (!enabled || swiper.destroyed) return swiper;
2082    if (typeof speed === 'undefined') {
2083      speed = swiper.params.speed;
2084    }
2085    let perGroup = params.slidesPerGroup;
2086    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2087      perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
2088    }
2089    const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2090    const isVirtual = swiper.virtual && params.virtual.enabled;
2091    if (params.loop) {
2092      if (animating && !isVirtual && params.loopPreventsSliding) return false;
2093      swiper.loopFix({
2094        direction: 'next'
2095      });
2096      // eslint-disable-next-line
2097      swiper._clientLeft = swiper.wrapperEl.clientLeft;
2098      if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
2099        requestAnimationFrame(() => {
2100          swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2101        });
2102        return true;
2103      }
2104    }
2105    if (params.rewind && swiper.isEnd) {
2106      return swiper.slideTo(0, speed, runCallbacks, internal);
2107    }
2108    return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2109  }
2110
2111  /* eslint no-unused-vars: "off" */
2112  function slidePrev(speed, runCallbacks, internal) {
2113    if (runCallbacks === void 0) {
2114      runCallbacks = true;
2115    }
2116    const swiper = this;
2117    const {
2118      params,
2119      snapGrid,
2120      slidesGrid,
2121      rtlTranslate,
2122      enabled,
2123      animating
2124    } = swiper;
2125    if (!enabled || swiper.destroyed) return swiper;
2126    if (typeof speed === 'undefined') {
2127      speed = swiper.params.speed;
2128    }
2129    const isVirtual = swiper.virtual && params.virtual.enabled;
2130    if (params.loop) {
2131      if (animating && !isVirtual && params.loopPreventsSliding) return false;
2132      swiper.loopFix({
2133        direction: 'prev'
2134      });
2135      // eslint-disable-next-line
2136      swiper._clientLeft = swiper.wrapperEl.clientLeft;
2137    }

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

2412        const index = i - Math.floor(i / cols) * cols;
2413        if (gridEnabled) {
2414          const colIndexToPrepend = cols - index - 1;
2415          for (let i = slides.length - 1; i >= 0; i -= 1) {
2416            if (slides[i].column === colIndexToPrepend) prependSlidesIndexes.push(i);
2417          }
2418          // slides.forEach((slide, slideIndex) => {
2419          //   if (slide.column === colIndexToPrepend) prependSlidesIndexes.push(slideIndex);
2420          // });
2421        } else {
2422          prependSlidesIndexes.push(cols - index - 1);
2423        }
2424      }
2425    } else if (activeColIndexWithShift + slidesPerView > cols - loopedSlides) {
2426      slidesAppended = Math.max(activeColIndexWithShift - (cols - loopedSlides * 2), slidesPerGroup);
2427      for (let i = 0; i < slidesAppended; i += 1) {
2428        const index = i - Math.floor(i / cols) * cols;
2429        if (gridEnabled) {
2430          slides.forEach((slide, slideIndex) => {
2431            if (slide.column === index) appendSlidesIndexes.push(slideIndex);
2432          });
2433        } else {
2434          appendSlidesIndexes.push(index);
2435        }
2436      }
2437    }
2438    swiper.__preventObserver__ = true;
2439    requestAnimationFrame(() => {
2440      swiper.__preventObserver__ = false;
2441    });
2442    if (isPrev) {
2443      prependSlidesIndexes.forEach(index => {
2444        slides[index].swiperLoopMoveDOM = true;
2445        slidesEl.prepend(slides[index]);
2446        slides[index].swiperLoopMoveDOM = false;
2447      });
2448    }
2449    if (isNext) {
2450      appendSlidesIndexes.forEach(index => {
2451        slides[index].swiperLoopMoveDOM = true;
2452        slidesEl.append(slides[index]);
2453        slides[index].swiperLoopMoveDOM = false;
2454      });
2455    }
2456    swiper.recalcSlides();
2457    if (params.slidesPerView === 'auto') {
2458      swiper.updateSlides();
2459    } else if (gridEnabled && (prependSlidesIndexes.length > 0 && isPrev || appendSlidesIndexes.length > 0 && isNext)) {
2460      swiper.slides.forEach((slide, slideIndex) => {
2461        swiper.grid.updateSlide(slideIndex, slide, swiper.slides);
2462      });
2463    }
2464    if (params.watchSlidesProgress) {
2465      swiper.updateSlidesOffset();
2466    }
2467    if (slideTo) {
2468      if (prependSlidesIndexes.length > 0 && isPrev) {
2469        if (typeof slideRealIndex === 'undefined') {
2470          const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2471          const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2472          const diff = newSlideTranslate - currentSlideTranslate;
2473          if (byMousewheel) {
2474            swiper.setTranslate(swiper.translate - diff);
2475          } else {
2476            swiper.slideTo(activeIndex + Math.ceil(slidesPrepended), 0, false, true);
2477            if (setTranslate) {
2478              swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2479              swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2480            }
2481          }
2482        } else {
2483          if (setTranslate) {
2484            const shift = gridEnabled ? prependSlidesIndexes.length / params.grid.rows : prependSlidesIndexes.length;
2485            swiper.slideTo(swiper.activeIndex + shift, 0, false, true);
2486            swiper.touchEventsData.currentTranslate = swiper.translate;
2487          }
2488        }
2489      } else if (appendSlidesIndexes.length > 0 && isNext) {
2490        if (typeof slideRealIndex === 'undefined') {
2491          const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2492          const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2493          const diff = newSlideTranslate - currentSlideTranslate;
2494          if (byMousewheel) {
2495            swiper.setTranslate(swiper.translate - diff);
2496          } else {
2497            swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2498            if (setTranslate) {
2499              swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2500              swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2501            }
2502          }
2503        } else {
2504          const shift = gridEnabled ? appendSlidesIndexes.length / params.grid.rows : appendSlidesIndexes.length;
2505          swiper.slideTo(swiper.activeIndex - shift, 0, false, true);
2506        }
2507      }
2508    }
2509    swiper.allowSlidePrev = allowSlidePrev;
2510    swiper.allowSlideNext = allowSlideNext;
2511    if (swiper.controller && swiper.controller.control && !byController) {
2512      const loopParams = {
2513        slideRealIndex,
2514        direction,
2515        setTranslate,
2516        activeSlideIndex,
2517        byController: true
2518      };
2519      if (Array.isArray(swiper.controller.control)) {
2520        swiper.controller.control.forEach(c => {
2521          if (!c.destroyed && c.params.loop) c.loopFix({
2522            ...loopParams,
2523            slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo : false
2524          });
2525        });
2526      } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
2527        swiper.controller.control.loopFix({
2528          ...loopParams,
2529          slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo : false
2530        });
2531      }
2532    }
2533    swiper.emit('loopFix');
2534  }
2535
2536  function loopDestroy() {
2537    const swiper = this;
2538    const {
2539      params,
2540      slidesEl
2541    } = swiper;
2542    if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2543    swiper.recalcSlides();
2544    const newSlidesOrder = [];

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