https://sudoroom.org/wp-content/plugins/templategalaxy/assets/js/swiper-bundle.js?ver=7.1

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

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

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

467    const support = getSupport();
468    const window = getWindow();
469    const platform = window.navigator.platform;
470    const ua = userAgent || window.navigator.userAgent;
471    const device = {
472      ios: false,
473      android: false
474    };
475    const screenWidth = window.screen.width;
476    const screenHeight = window.screen.height;
477    const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
478    let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
479    const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
480    const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
481    const windows = platform === 'Win32';
482    let macos = platform === 'MacIntel';
483
484    // iPadOs 13 fix
485    const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
486    if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
487      ipad = ua.match(/(Version)\/([\d.]+)/);
488      if (!ipad) ipad = [0, 1, '13_0_0'];
489      macos = false;
490    }
491
492    // Android
493    if (android && !windows) {
494      device.os = 'android';
495      device.android = true;
496    }
497    if (ipad || iphone || ipod) {
498      device.os = 'ios';
499      device.ios = true;
500    }
501
502    // Export object
503    return device;
504  }
505  function getDevice(overrides) {
506    if (overrides === void 0) {
507      overrides = {};
508    }
509    if (!deviceCached) {
510      deviceCached = calcDevice(overrides);
511    }
512    return deviceCached;
513  }
514
515  let browser;
516  function calcBrowser() {
517    const window = getWindow();
518    let needPerspectiveFix = false;
519    function isSafari() {
520      const ua = window.navigator.userAgent.toLowerCase();
521      return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
522    }
523    if (isSafari()) {
524      const ua = String(window.navigator.userAgent);
525      if (ua.includes('Version/')) {
526        const [major, minor] = ua.split('Version/')[1].split(' ')[0].split('.').map(num => Number(num));
527        needPerspectiveFix = major < 16 || major === 16 && minor < 2;
528      }
529    }
530    return {
531      isSafari: needPerspectiveFix || isSafari(),
532      needPerspectiveFix,
533      isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)
534    };
535  }
536  function getBrowser() {
537    if (!browser) {
538      browser = calcBrowser();
539    }
540    return browser;
541  }
542
543  function Resize(_ref) {
544    let {
545      swiper,
546      on,
547      emit
548    } = _ref;
549    const window = getWindow();
550    let observer = null;
551    let animationFrame = null;
552    const resizeHandler = () => {
553      if (!swiper || swiper.destroyed || !swiper.initialized) return;
554      emit('beforeResize');
555      emit('resize');
556    };
557    const createObserver = () => {
558      if (!swiper || swiper.destroyed || !swiper.initialized) return;
559      observer = new ResizeObserver(entries => {
560        animationFrame = window.requestAnimationFrame(() => {
561          const {
562            width,
563            height
564          } = swiper;
565          let newWidth = width;
566          let newHeight = height;
567          entries.forEach(_ref2 => {
568            let {
569              contentBoxSize,
570              contentRect,
571              target
572            } = _ref2;
573            if (target && target !== swiper.el) return;
574            newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
575            newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
576          });
577          if (newWidth !== width || newHeight !== height) {
578            resizeHandler();
579          }
580        });
581      });
582      observer.observe(swiper.el);
583    };
584    const removeObserver = () => {
585      if (animationFrame) {
586        window.cancelAnimationFrame(animationFrame);
587      }
588      if (observer && observer.unobserve && swiper.el) {
589        observer.unobserve(swiper.el);
590        observer = null;
591      }
592    };
593    const orientationChangeHandler = () => {
594      if (!swiper || swiper.destroyed || !swiper.initialized) return;
595      emit('orientationchange');
596    };
597    on('init', () => {
598      if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
599        createObserver();
600        return;
601      }
602      window.addEventListener('resize', resizeHandler);
603      window.addEventListener('orientationchange', orientationChangeHandler);
604    });
605    on('destroy', () => {
606      removeObserver();
607      window.removeEventListener('resize', resizeHandler);
608      window.removeEventListener('orientationchange', orientationChangeHandler);
609    });
610  }
611
612  function Observer(_ref) {
613    let {
614      swiper,
615      extendParams,
616      on,
617      emit
618    } = _ref;
619    const observers = [];
620    const window = getWindow();
621    const attach = function (target, options) {
622      if (options === void 0) {
623        options = {};
624      }
625      const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
626      const observer = new ObserverFunc(mutations => {
627        // The observerUpdate event should only be triggered
628        // once despite the number of mutations.  Additional
629        // triggers are redundant and are very costly
630        if (swiper.__preventObserver__) return;
631        if (mutations.length === 1) {
632          emit('observerUpdate', mutations[0]);
633          return;
634        }
635        const observerUpdate = function observerUpdate() {
636          emit('observerUpdate', mutations[0]);
637        };
638        if (window.requestAnimationFrame) {
639          window.requestAnimationFrame(observerUpdate);
640        } else {
641          window.setTimeout(observerUpdate, 0);
642        }
643      });
644      observer.observe(target, {
645        attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
646        childList: typeof options.childList === 'undefined' ? true : options.childList,
647        characterData: typeof options.characterData === 'undefined' ? true : options.characterData
648      });
649      observers.push(observer);
650    };
651    const init = () => {
652      if (!swiper.params.observer) return;
653      if (swiper.params.observeParents) {
654        const containerParents = elementParents(swiper.hostEl);
655        for (let i = 0; i < containerParents.length; i += 1) {
656          attach(containerParents[i]);
657        }
658      }
659      // Observe container
660      attach(swiper.hostEl, {
661        childList: swiper.params.observeSlideChildren
662      });
663
664      // Observe wrapper
665      attach(swiper.wrapperEl, {
666        attributes: false
667      });
668    };
669    const destroy = () => {

670      observers.forEach(observer => {
671        observer.disconnect();
672      });
673      observers.splice(0, observers.length);
674    };
675    extendParams({
676      observer: false,
677      observeParents: false,
678      observeSlideChildren: false
679    });
680    on('init', init);
681    on('destroy', destroy);
682  }
683
684  /* eslint-disable no-underscore-dangle */
685
686  var eventsEmitter = {
687    on(events, handler, priority) {
688      const self = this;
689      if (!self.eventsListeners || self.destroyed) return self;
690      if (typeof handler !== 'function') return self;
691      const method = priority ? 'unshift' : 'push';
692      events.split(' ').forEach(event => {
693        if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
694        self.eventsListeners[event][method](handler);
695      });
696      return self;
697    },
698    once(events, handler, priority) {
699      const self = this;
700      if (!self.eventsListeners || self.destroyed) return self;
701      if (typeof handler !== 'function') return self;
702      function onceHandler() {
703        self.off(events, onceHandler);
704        if (onceHandler.__emitterProxy) {
705          delete onceHandler.__emitterProxy;
706        }
707        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
708          args[_key] = arguments[_key];
709        }
710        handler.apply(self, args);
711      }
712      onceHandler.__emitterProxy = handler;
713      return self.on(events, onceHandler, priority);
714    },
715    onAny(handler, priority) {
716      const self = this;
717      if (!self.eventsListeners || self.destroyed) return self;
718      if (typeof handler !== 'function') return self;
719      const method = priority ? 'unshift' : 'push';
720      if (self.eventsAnyListeners.indexOf(handler) < 0) {
721        self.eventsAnyListeners[method](handler);
722      }
723      return self;
724    },
725    offAny(handler) {
726      const self = this;
727      if (!self.eventsListeners || self.destroyed) return self;
728      if (!self.eventsAnyListeners) return self;
729      const index = self.eventsAnyListeners.indexOf(handler);
730      if (index >= 0) {
731        self.eventsAnyListeners.splice(index, 1);
732      }
733      return self;
734    },
735    off(events, handler) {
736      const self = this;
737      if (!self.eventsListeners || self.destroyed) return self;
738      if (!self.eventsListeners) return self;
739      events.split(' ').forEach(event => {
740        if (typeof handler === 'undefined') {
741          self.eventsListeners[event] = [];
742        } else if (self.eventsListeners[event]) {
743          self.eventsListeners[event].forEach((eventHandler, index) => {
744            if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
745              self.eventsListeners[event].splice(index, 1);
746            }
747          });
748        }
749      });
750      return self;
751    },
752    emit() {
753      const self = this;
754      if (!self.eventsListeners || self.destroyed) return self;
755      if (!self.eventsListeners) return self;
756      let events;
757      let data;
758      let context;
759      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
760        args[_key2] = arguments[_key2];
761      }
762      if (typeof args[0] === 'string' || Array.isArray(args[0])) {
763        events = args[0];
764        data = args.slice(1, args.length);
765        context = self;
766      } else {
767        events = args[0].events;
768        data = args[0].data;
769        context = args[0].context || self;
770      }
771      data.unshift(context);
772      const eventsArray = Array.isArray(events) ? events : events.split(' ');
773      eventsArray.forEach(event => {
774        if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
775          self.eventsAnyListeners.forEach(eventHandler => {
776            eventHandler.apply(context, [event, ...data]);
777          });
778        }
779        if (self.eventsListeners && self.eventsListeners[event]) {
780          self.eventsListeners[event].forEach(eventHandler => {
781            eventHandler.apply(context, data);
782          });
783        }
784      });
785      return self;
786    }
787  };
788
789  function updateSize() {
790    const swiper = this;
791    let width;
792    let height;
793    const el = swiper.el;
794    if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
795      width = swiper.params.width;
796    } else {
797      width = el.clientWidth;
798    }
799    if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
800      height = swiper.params.height;
801    } else {
802      height = el.clientHeight;
803    }
804    if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
805      return;
806    }
807
808    // Subtract paddings
809    width = width - parseInt(elementStyle(el, 'padding-left') || 0, 10) - parseInt(elementStyle(el, 'padding-right') || 0, 10);
810    height = height - parseInt(elementStyle(el, 'padding-top') || 0, 10) - parseInt(elementStyle(el, 'padding-bottom') || 0, 10);
811    if (Number.isNaN(width)) width = 0;
812    if (Number.isNaN(height)) height = 0;

813    Object.assign(swiper, {
814      width,
815      height,
816      size: swiper.isHorizontal() ? width : height
817    });
818  }
819
820  function updateSlides() {
821    const swiper = this;
822    function getDirectionPropertyValue(node, label) {
823      return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
824    }
825    const params = swiper.params;
826    const {
827      wrapperEl,
828      slidesEl,
829      size: swiperSize,
830      rtlTranslate: rtl,
831      wrongRTL
832    } = swiper;
833    const isVirtual = swiper.virtual && params.virtual.enabled;
834    const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
835    const slides = elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
836    const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
837    let snapGrid = [];
838    const slidesGrid = [];
839    const slidesSizesGrid = [];
840    let offsetBefore = params.slidesOffsetBefore;
841    if (typeof offsetBefore === 'function') {
842      offsetBefore = params.slidesOffsetBefore.call(swiper);
843    }
844    let offsetAfter = params.slidesOffsetAfter;
845    if (typeof offsetAfter === 'function') {
846      offsetAfter = params.slidesOffsetAfter.call(swiper);
847    }
848    const previousSnapGridLength = swiper.snapGrid.length;
849    const previousSlidesGridLength = swiper.slidesGrid.length;
850    let spaceBetween = params.spaceBetween;
851    let slidePosition = -offsetBefore;
852    let prevSlideSize = 0;
853    let index = 0;
854    if (typeof swiperSize === 'undefined') {
855      return;
856    }
857    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
858      spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
859    } else if (typeof spaceBetween === 'string') {
860      spaceBetween = parseFloat(spaceBetween);
861    }
862    swiper.virtualSize = -spaceBetween;
863
864    // reset margins
865    slides.forEach(slideEl => {
866      if (rtl) {
867        slideEl.style.marginLeft = '';
868      } else {
869        slideEl.style.marginRight = '';
870      }
871      slideEl.style.marginBottom = '';
872      slideEl.style.marginTop = '';
873    });
874
875    // reset cssMode offsets
876    if (params.centeredSlides && params.cssMode) {
877      setCSSProperty(wrapperEl, '--swiper-centered-offset-before', '');
878      setCSSProperty(wrapperEl, '--swiper-centered-offset-after', '');
879    }
880    const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
881    if (gridEnabled) {
882      swiper.grid.initSlides(slides);
883    } else if (swiper.grid) {
884      swiper.grid.unsetSlides();
885    }
886
887    // Calc slides
888    let slideSize;
889    const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
890      return typeof params.breakpoints[key].slidesPerView !== 'undefined';
891    }).length > 0;
892    for (let i = 0; i < slidesLength; i += 1) {
893      slideSize = 0;
894      let slide;
895      if (slides[i]) slide = slides[i];
896      if (gridEnabled) {
897        swiper.grid.updateSlide(i, slide, slides);
898      }
899      if (slides[i] && elementStyle(slide, 'display') === 'none') continue; // eslint-disable-line
900
901      if (params.slidesPerView === 'auto') {
902        if (shouldResetSlideSize) {
903          slides[i].style[swiper.getDirectionLabel('width')] = ``;
904        }
905        const slideStyles = getComputedStyle(slide);
906        const currentTransform = slide.style.transform;
907        const currentWebKitTransform = slide.style.webkitTransform;
908        if (currentTransform) {
909          slide.style.transform = 'none';
910        }
911        if (currentWebKitTransform) {
912          slide.style.webkitTransform = 'none';
913        }
914        if (params.roundLengths) {
915          slideSize = swiper.isHorizontal() ? elementOuterSize(slide, 'width', true) : elementOuterSize(slide, 'height', true);
916        } else {
917          // eslint-disable-next-line
918          const width = getDirectionPropertyValue(slideStyles, 'width');
919          const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
920          const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
921          const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
922          const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
923          const boxSizing = slideStyles.getPropertyValue('box-sizing');
924          if (boxSizing && boxSizing === 'border-box') {
925            slideSize = width + marginLeft + marginRight;
926          } else {
927            const {
928              clientWidth,
929              offsetWidth
930            } = slide;
931            slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
932          }
933        }
934        if (currentTransform) {
935          slide.style.transform = currentTransform;
936        }
937        if (currentWebKitTransform) {
938          slide.style.webkitTransform = currentWebKitTransform;
939        }
940        if (params.roundLengths) slideSize = Math.floor(slideSize);
941      } else {
942        slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
943        if (params.roundLengths) slideSize = Math.floor(slideSize);
944        if (slides[i]) {
945          slides[i].style[swiper.getDirectionLabel('width')] = `${slideSize}px`;
946        }
947      }
948      if (slides[i]) {
949        slides[i].swiperSlideSize = slideSize;
950      }
951      slidesSizesGrid.push(slideSize);
952      if (params.centeredSlides) {
953        slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
954        if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
955        if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
956        if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
957        if (params.roundLengths) slidePosition = Math.floor(slidePosition);
958        if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
959        slidesGrid.push(slidePosition);
960      } else {
961        if (params.roundLengths) slidePosition = Math.floor(slidePosition);
962        if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
963        slidesGrid.push(slidePosition);
964        slidePosition = slidePosition + slideSize + spaceBetween;
965      }
966      swiper.virtualSize += slideSize + spaceBetween;
967      prevSlideSize = slideSize;
968      index += 1;
969    }
970    swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
971    if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
972      wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
973    }
974    if (params.setWrapperSize) {
975      wrapperEl.style[swiper.getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;
976    }
977    if (gridEnabled) {
978      swiper.grid.updateWrapperSize(slideSize, snapGrid);
979    }
980
981    // Remove last grid elements depending on width
982    if (!params.centeredSlides) {
983      const newSlidesGrid = [];
984      for (let i = 0; i < snapGrid.length; i += 1) {
985        let slidesGridItem = snapGrid[i];
986        if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
987        if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
988          newSlidesGrid.push(slidesGridItem);
989        }
990      }
991      snapGrid = newSlidesGrid;
992      if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
993        snapGrid.push(swiper.virtualSize - swiperSize);
994      }
995    }
996    if (isVirtual && params.loop) {
997      const size = slidesSizesGrid[0] + spaceBetween;
998      if (params.slidesPerGroup > 1) {
999        const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
1000        const groupSize = size * params.slidesPerGroup;
1001        for (let i = 0; i < groups; i += 1) {
1002          snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1003        }
1004      }
1005      for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1006        if (params.slidesPerGroup === 1) {
1007          snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1008        }
1009        slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1010        swiper.virtualSize += size;
1011      }
1012    }
1013    if (snapGrid.length === 0) snapGrid = [0];
1014    if (spaceBetween !== 0) {
1015      const key = swiper.isHorizontal() && rtl ? 'marginLeft' : swiper.getDirectionLabel('marginRight');
1016      slides.filter((_, slideIndex) => {
1017        if (!params.cssMode || params.loop) return true;
1018        if (slideIndex === slides.length - 1) {
1019          return false;
1020        }
1021        return true;
1022      }

1022).forEach(slideEl => {
1023        slideEl.style[key] = `${spaceBetween}px`;
1024      });
1025    }
1026    if (params.centeredSlides && params.centeredSlidesBounds) {
1027      let allSlidesSize = 0;
1028      slidesSizesGrid.forEach(slideSizeValue => {
1029        allSlidesSize += slideSizeValue + (spaceBetween || 0);
1030      });
1031      allSlidesSize -= spaceBetween;
1032      const maxSnap = allSlidesSize - swiperSize;
1033      snapGrid = snapGrid.map(snap => {
1034        if (snap <= 0) return -offsetBefore;
1035        if (snap > maxSnap) return maxSnap + offsetAfter;
1036        return snap;
1037      });
1038    }
1039    if (params.centerInsufficientSlides) {
1040      let allSlidesSize = 0;
1041      slidesSizesGrid.forEach(slideSizeValue => {
1042        allSlidesSize += slideSizeValue + (spaceBetween || 0);
1043      });
1044      allSlidesSize -= spaceBetween;
1045      if (allSlidesSize < swiperSize) {
1046        const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1047        snapGrid.forEach((snap, snapIndex) => {
1048          snapGrid[snapIndex] = snap - allSlidesOffset;
1049        });
1050        slidesGrid.forEach((snap, snapIndex) => {
1051          slidesGrid[snapIndex] = snap + allSlidesOffset;
1052        });
1053      }
1054    }
1055    Object.assign(swiper, {
1056      slides,
1057      snapGrid,
1058      slidesGrid,
1059      slidesSizesGrid
1060    });
1061    if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1062      setCSSProperty(wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
1063      setCSSProperty(wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1064      const addToSnapGrid = -swiper.snapGrid[0];
1065      const addToSlidesGrid = -swiper.slidesGrid[0];
1066      swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1067      swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1068    }
1069    if (slidesLength !== previousSlidesLength) {
1070      swiper.emit('slidesLengthChange');
1071    }
1072    if (snapGrid.length !== previousSnapGridLength) {
1073      if (swiper.params.watchOverflow) swiper.checkOverflow();
1074      swiper.emit('snapGridLengthChange');
1075    }
1076    if (slidesGrid.length !== previousSlidesGridLength) {
1077      swiper.emit('slidesGridLengthChange');
1078    }
1079    if (params.watchSlidesProgress) {
1080      swiper.updateSlidesOffset();
1081    }
1082    swiper.emit('slidesUpdated');
1083    if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1084      const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1085      const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1086      if (slidesLength <= params.maxBackfaceHiddenSlides) {
1087        if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1088      } else if (hasClassBackfaceClassAdded) {
1089        swiper.el.classList.remove(backFaceHiddenClass);
1090      }
1091    }
1092  }
1093
1094  function updateAutoHeight(speed) {
1095    const swiper = this;
1096    const activeSlides = [];
1097    const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1098    let newHeight = 0;
1099    let i;
1100    if (typeof speed === 'number') {
1101      swiper.setTransition(speed);
1102    } else if (speed === true) {
1103      swiper.setTransition(swiper.params.speed);
1104    }
1105    const getSlideByIndex = index => {
1106      if (isVirtual) {
1107        return swiper.slides[swiper.getSlideIndexByData(index)];
1108      }
1109      return swiper.slides[index];
1110    };
1111    // Find slides currently in view
1112    if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1113      if (swiper.params.centeredSlides) {

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

1167    slides.forEach(slideEl => {
1168      slideEl.classList.remove(params.slideVisibleClass, params.slideFullyVisibleClass);
1169    });
1170    swiper.visibleSlidesIndexes = [];
1171    swiper.visibleSlides = [];
1172    let spaceBetween = params.spaceBetween;
1173    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1174      spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;
1175    } else if (typeof spaceBetween === 'string') {
1176      spaceBetween = parseFloat(spaceBetween);
1177    }
1178    for (let i = 0; i < slides.length; i += 1) {
1179      const slide = slides[i];
1180      let slideOffset = slide.swiperSlideOffset;
1181      if (params.cssMode && params.centeredSlides) {
1182        slideOffset -= slides[0].swiperSlideOffset;
1183      }
1184      const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1185      const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1186      const slideBefore = -(offsetCenter - slideOffset);
1187      const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1188      const isFullyVisible = slideBefore >= 0 && slideBefore <= swiper.size - swiper.slidesSizesGrid[i];
1189      const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1190      if (isVisible) {
1191        swiper.visibleSlides.push(slide);
1192        swiper.visibleSlidesIndexes.push(i);
1193        slides[i].classList.add(params.slideVisibleClass);
1194      }
1195      if (isFullyVisible) {
1196        slides[i].classList.add(params.slideFullyVisibleClass);
1197      }
1198      slide.progress = rtl ? -slideProgress : slideProgress;
1199      slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1200    }
1201  }
1202
1203  function updateProgress(translate) {
1204    const swiper = this;
1205    if (typeof translate === 'undefined') {
1206      const multiplier = swiper.rtlTranslate ? -1 : 1;
1207      // eslint-disable-next-line
1208      translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
1209    }
1210    const params = swiper.params;
1211    const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1212    let {
1213      progress,
1214      isBeginning,
1215      isEnd,
1216      progressLoop
1217    } = swiper;
1218    const wasBeginning = isBeginning;
1219    const wasEnd = isEnd;
1220    if (translatesDiff === 0) {
1221      progress = 0;
1222      isBeginning = true;
1223      isEnd = true;
1224    } else {
1225      progress = (translate - swiper.minTranslate()) / translatesDiff;
1226      const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;
1227      const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;
1228      isBeginning = isBeginningRounded || progress <= 0;
1229      isEnd = isEndRounded || progress >= 1;
1230      if (isBeginningRounded) progress = 0;
1231      if (isEndRounded) progress = 1;
1232    }
1233    if (params.loop) {
1234      const firstSlideIndex = swiper.getSlideIndexByData(0);
1235      const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1236      const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1237      const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1238      const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1239      const translateAbs = Math.abs(translate);
1240      if (translateAbs >= firstSlideTranslate) {
1241        progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
1242      } else {
1243        progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1244      }
1245      if (progressLoop > 1) progressLoop -= 1;
1246    }
1247    Object.assign(swiper, {
1248      progress,
1249      progressLoop,
1250      isBeginning,
1251      isEnd
1252    });
1253    if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
1254    if (isBeginning && !wasBeginning) {
1255      swiper.emit('reachBeginning toEdge');
1256    }
1257    if (isEnd && !wasEnd) {
1258      swiper.emit('reachEnd toEdge');
1259    }
1260    if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
1261      swiper.emit('fromEdge');
1262    }
1263    swiper.emit('progress', progress);
1264  }
1265
1266  function updateSlidesClasses() {
1267    const swiper = this;
1268    const {
1269      slides,
1270      params,
1271      slidesEl,
1272      activeIndex
1273    } = swiper;
1274    const isVirtual = swiper.virtual && params.virtual.enabled;
1275    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1276    const getFilteredSlide = selector => {
1277      return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1278    };

1279    slides.forEach(slideEl => {
1280      slideEl.classList.remove(params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
1281    });
1282    let activeSlide;
1283    let prevSlide;
1284    let nextSlide;
1285    if (isVirtual) {
1286      if (params.loop) {
1287        let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1288        if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1289        if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1290        activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1291      } else {
1292        activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1293      }
1294    } else {
1295      if (gridEnabled) {
1296        activeSlide = slides.filter(slideEl => slideEl.column === activeIndex)[0];
1297        nextSlide = slides.filter(slideEl => slideEl.column === activeIndex + 1)[0];
1298        prevSlide = slides.filter(slideEl => slideEl.column === activeIndex - 1)[0];
1299      } else {
1300        activeSlide = slides[activeIndex];
1301      }
1302    }
1303    if (activeSlide) {
1304      // Active classes
1305      activeSlide.classList.add(params.slideActiveClass);
1306      if (gridEnabled) {
1307        if (nextSlide) {
1308          nextSlide.classList.add(params.slideNextClass);
1309        }
1310        if (prevSlide) {
1311          prevSlide.classList.add(params.slidePrevClass);
1312        }
1313      } else {
1314        // Next Slide
1315        nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1316        if (params.loop && !nextSlide) {
1317          nextSlide = slides[0];
1318        }
1319        if (nextSlide) {
1320          nextSlide.classList.add(params.slideNextClass);
1321        }
1322
1323        // Prev Slide
1324        prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1325        if (params.loop && !prevSlide === 0) {
1326          prevSlide = slides[slides.length - 1];
1327        }
1328        if (prevSlide) {
1329          prevSlide.classList.add(params.slidePrevClass);
1330        }
1331      }
1332    }
1333    swiper.emitSlidesClasses();
1334  }
1335
1336  const processLazyPreloader = (swiper, imageEl) => {
1337    if (!swiper || swiper.destroyed || !swiper.params) return;
1338    const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1339    const slideEl = imageEl.closest(slideSelector());
1340    if (slideEl) {
1341      let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1342      if (!lazyEl && swiper.isElement) {
1343        if (slideEl.shadowRoot) {
1344          lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1345        } else {
1346          // init later
1347          requestAnimationFrame(() => {
1348            if (slideEl.shadowRoot) {
1349              lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1350              if (lazyEl) lazyEl.remove();
1351            }
1352          });
1353        }
1354      }
1355      if (lazyEl) lazyEl.remove();
1356    }
1357  };
1358  const unlazy = (swiper, index) => {
1359    if (!swiper.slides[index]) return;
1360    const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1361    if (imageEl) imageEl.removeAttribute('loading');
1362  };
1363  const preload = swiper => {
1364    if (!swiper || swiper.destroyed || !swiper.params) return;
1365    let amount = swiper.params.lazyPreloadPrevNext;
1366    const len = swiper.slides.length;
1367    if (!len || !amount || amount < 0) return;
1368    amount = Math.min(amount, len);
1369    const slidesPerView = swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1370    const activeIndex = swiper.activeIndex;
1371    if (swiper.params.grid && swiper.params.grid.rows > 1) {
1372      const activeColumn = activeIndex;
1373      const preloadColumns = [activeColumn - amount];
1374      preloadColumns.push(...Array.from({
1375        length: amount
1376      }).map((_, i) => {
1377        return activeColumn + slidesPerView + i;
1378      }));
1379      swiper.slides.forEach((slideEl, i) => {
1380        if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1381      });
1382      return;
1383    }
1384    const slideIndexLastInView = activeIndex + slidesPerView - 1;
1385    if (swiper.params.rewind || swiper.params.loop) {
1386      for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1387        const realIndex = (i % len + len) % len;
1388        if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1389      }
1390    } else {
1391      for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1392        if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1393          unlazy(swiper, i);
1394        }
1395      }
1396    }
1397  };
1398
1399  function getActiveIndexByTranslate(swiper) {
1400    const {
1401      slidesGrid,
1402      params
1403    } = swiper;
1404    const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1405    let activeIndex;
1406    for (let i = 0; i < slidesGrid.length; i += 1) {
1407      if (typeof slidesGrid[i + 1] !== 'undefined') {
1408        if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1409          activeIndex = i;
1410        } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1411          activeIndex = i + 1;
1412        }
1413      } else if (translate >= slidesGrid[i]) {
1414        activeIndex = i;
1415      }
1416    }
1417    // Normalize slideIndex
1418    if (params.normalizeSlideIndex) {
1419      if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1420    }
1421    return activeIndex;
1422  }
1423  function updateActiveIndex(newActiveIndex) {
1424    const swiper = this;
1425    const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1426    const {
1427      snapGrid,
1428      params,
1429      activeIndex: previousIndex,
1430      realIndex: previousRealIndex,
1431      snapIndex: previousSnapIndex
1432    } = swiper;
1433    let activeIndex = newActiveIndex;
1434    let snapIndex;
1435    const getVirtualRealIndex = aIndex => {
1436      let realIndex = aIndex - swiper.virtual.slidesBefore;
1437      if (realIndex < 0) {
1438        realIndex = swiper.virtual.slides.length + realIndex;
1439      }
1440      if (realIndex >= swiper.virtual.slides.length) {
1441        realIndex -= swiper.virtual.slides.length;
1442      }
1443      return realIndex;
1444    };
1445    if (typeof activeIndex === 'undefined') {
1446      activeIndex = getActiveIndexByTranslate(swiper);
1447    }
1448    if (snapGrid.indexOf(translate) >= 0) {
1449      snapIndex = snapGrid.indexOf(translate);
1450    } else {
1451      const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1452      snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1453    }
1454    if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1455    if (activeIndex === previousIndex && !swiper.params.loop) {
1456      if (snapIndex !== previousSnapIndex) {
1457        swiper.snapIndex = snapIndex;
1458        swiper.emit('snapIndexChange');
1459      }
1460      return;
1461    }
1462    if (activeIndex === previousIndex && swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1463      swiper.realIndex = getVirtualRealIndex(activeIndex);
1464      return;
1465    }
1466    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1467
1468    // Get real index
1469    let realIndex;
1470    if (swiper.virtual && params.virtual.enabled && params.loop) {
1471      realIndex = getVirtualRealIndex(activeIndex);
1472    } else if (gridEnabled) {
1473      const firstSlideInColumn = swiper.slides.filter(slideEl => slideEl.column === activeIndex)[0];
1474      let activeSlideIndex = parseInt(firstSlideInColumn.getAttribute('data-swiper-slide-index'), 10);
1475      if (Number.isNaN(activeSlideIndex)) {
1476        activeSlideIndex = Math.max(swiper.slides.indexOf(firstSlideInColumn), 0);
1477      }
1478      realIndex = Math.floor(activeSlideIndex / params.grid.rows);
1479    } else if (swiper.slides[activeIndex]) {
1480      const slideIndex = swiper.slides[activeIndex].getAttribute('data-swiper-slide-index');
1481      if (slideIndex) {
1482        realIndex = parseInt(slideIndex, 10);
1483      } else {
1484        realIndex = activeIndex;
1485      }
1486    } else {
1487      realIndex = activeIndex;
1488    }
1489    Object.assign(swiper, {
1490      previousSnapIndex,
1491      snapIndex,
1492      previousRealIndex,
1493      realIndex,
1494      previousIndex,
1495      activeIndex
1496    });
1497    if (swiper.initialized) {
1498      preload(swiper);
1499    }
1500    swiper.emit('activeIndexChange');
1501    swiper.emit('snapIndexChange');
1502    if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1503      if (previousRealIndex !== realIndex) {
1504        swiper.emit('realIndexChange');
1505      }
1506      swiper.emit('slideChange');
1507    }
1508  }
1509
1510  function updateClickedSlide(el, path) {
1511    const swiper = this;
1512    const params = swiper.params;
1513    let slide = el.closest(`.${params.slideClass}, swiper-slide`);
1514    if (!slide && swiper.isElement && path && path.length > 1 && path.includes(el)) {

1515      [...path.slice(path.indexOf(el) + 1, path.length)].forEach(pathEl => {
1516        if (!slide && pathEl.matches && pathEl.matches(`.${params.slideClass}, swiper-slide`)) {
1517          slide = pathEl;
1518        }
1519      });
1520    }
1521    let slideFound = false;
1522    let slideIndex;
1523    if (slide) {
1524      for (let i = 0; i < swiper.slides.length; i += 1) {
1525        if (swiper.slides[i] === slide) {
1526          slideFound = true;
1527          slideIndex = i;
1528          break;
1529        }
1530      }
1531    }
1532    if (slide && slideFound) {
1533      swiper.clickedSlide = slide;
1534      if (swiper.virtual && swiper.params.virtual.enabled) {
1535        swiper.clickedIndex = parseInt(slide.getAttribute('data-swiper-slide-index'), 10);
1536      } else {
1537        swiper.clickedIndex = slideIndex;
1538      }
1539    } else {
1540      swiper.clickedSlide = undefined;
1541      swiper.clickedIndex = undefined;
1542      return;
1543    }
1544    if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1545      swiper.slideToClickedSlide();
1546    }
1547  }
1548
1549  var update = {
1550    updateSize,
1551    updateSlides,
1552    updateAutoHeight,
1553    updateSlidesOffset,
1554    updateSlidesProgress,
1555    updateProgress,
1556    updateSlidesClasses,
1557    updateActiveIndex,
1558    updateClickedSlide
1559  };
1560
1561  function getSwiperTranslate(axis) {
1562    if (axis === void 0) {
1563      axis = this.isHorizontal() ? 'x' : 'y';
1564    }
1565    const swiper = this;
1566    const {
1567      params,
1568      rtlTranslate: rtl,
1569      translate,
1570      wrapperEl
1571    } = swiper;
1572    if (params.virtualTranslate) {
1573      return rtl ? -translate : translate;
1574    }
1575    if (params.cssMode) {
1576      return translate;
1577    }
1578    let currentTranslate = getTranslate(wrapperEl, axis);
1579    currentTranslate += swiper.cssOverflowAdjustment();
1580    if (rtl) currentTranslate = -currentTranslate;
1581    return currentTranslate || 0;
1582  }
1583
1584  function setTranslate(translate, byController) {
1585    const swiper = this;
1586    const {
1587      rtlTranslate: rtl,
1588      params,
1589      wrapperEl,
1590      progress
1591    } = swiper;
1592    let x = 0;
1593    let y = 0;
1594    const z = 0;
1595    if (swiper.isHorizontal()) {
1596      x = rtl ? -translate : translate;
1597    } else {
1598      y = translate;
1599    }
1600    if (params.roundLengths) {
1601      x = Math.floor(x);
1602      y = Math.floor(y);
1603    }
1604    swiper.previousTranslate = swiper.translate;
1605    swiper.translate = swiper.isHorizontal() ? x : y;
1606    if (params.cssMode) {
1607      wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
1608    } else if (!params.virtualTranslate) {
1609      if (swiper.isHorizontal()) {
1610        x -= swiper.cssOverflowAdjustment();
1611      } else {
1612        y -= swiper.cssOverflowAdjustment();
1613      }
1614      wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1615    }
1616
1617    // Check if we need to update progress
1618    let newProgress;
1619    const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1620    if (translatesDiff === 0) {
1621      newProgress = 0;
1622    } else {
1623      newProgress = (translate - swiper.minTranslate()) / translatesDiff;
1624    }
1625    if (newProgress !== progress) {
1626      swiper.updateProgress(translate);
1627    }
1628    swiper.emit('setTranslate', swiper.translate, byController);
1629  }
1630
1631  function minTranslate() {
1632    return -this.snapGrid[0];
1633  }
1634
1635  function maxTranslate() {
1636    return -this.snapGrid[this.snapGrid.length - 1];
1637  }
1638
1639  function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
1640    if (translate === void 0) {
1641      translate = 0;
1642    }
1643    if (speed === void 0) {
1644      speed = this.params.speed;
1645    }
1646    if (runCallbacks === void 0) {
1647      runCallbacks = true;
1648    }
1649    if (translateBounds === void 0) {
1650      translateBounds = true;
1651    }
1652    const swiper = this;
1653    const {
1654      params,
1655      wrapperEl
1656    } = swiper;
1657    if (swiper.animating && params.preventInteractionOnTransition) {
1658      return false;
1659    }
1660    const minTranslate = swiper.minTranslate();
1661    const maxTranslate = swiper.maxTranslate();
1662    let newTranslate;
1663    if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate;
1664
1665    // Update progress
1666    swiper.updateProgress(newTranslate);
1667    if (params.cssMode) {
1668      const isH = swiper.isHorizontal();
1669      if (speed === 0) {
1670        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1671      } else {
1672        if (!swiper.support.smoothScroll) {
1673          animateCSSModeScroll({
1674            swiper,
1675            targetPosition: -newTranslate,
1676            side: isH ? 'left' : 'top'
1677          });
1678          return true;
1679        }
1680        wrapperEl.scrollTo({
1681          [isH ? 'left' : 'top']: -newTranslate,
1682          behavior: 'smooth'
1683        });
1684      }
1685      return true;
1686    }
1687    if (speed === 0) {
1688      swiper.setTransition(0);
1689      swiper.setTranslate(newTranslate);
1690      if (runCallbacks) {
1691        swiper.emit('beforeTransitionStart', speed, internal);
1692        swiper.emit('transitionEnd');
1693      }
1694    } else {
1695      swiper.setTransition(speed);
1696      swiper.setTranslate(newTranslate);
1697      if (runCallbacks) {
1698        swiper.emit('beforeTransitionStart', speed, internal);
1699        swiper.emit('transitionStart');
1700      }
1701      if (!swiper.animating) {
1702        swiper.animating = true;
1703        if (!swiper.onTranslateToWrapperTransitionEnd) {
1704          swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1705            if (!swiper || swiper.destroyed) return;
1706            if (e.target !== this) return;
1707            swiper.wrapperEl.removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1708            swiper.onTranslateToWrapperTransitionEnd = null;
1709            delete swiper.onTranslateToWrapperTransitionEnd;
1710            if (runCallbacks) {
1711              swiper.emit('transitionEnd');
1712            }
1713          };
1714        }
1715        swiper.wrapperEl.addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1716      }
1717    }
1718    return true;
1719  }
1720
1721  var translate = {
1722    getTranslate: getSwiperTranslate,
1723    setTranslate,
1724    minTranslate,
1725    maxTranslate,
1726    translateTo
1727  };
1728
1729  function setTransition(duration, byController) {
1730    const swiper = this;
1731    if (!swiper.params.cssMode) {
1732      swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
1733      swiper.wrapperEl.style.transitionDelay = duration === 0 ? `0ms` : '';
1734    }
1735    swiper.emit('setTransition', duration, byController);
1736  }
1737
1738  function transitionEmit(_ref) {
1739    let {
1740      swiper,
1741      runCallbacks,
1742      direction,
1743      step
1744    } = _ref;
1745    const {
1746      activeIndex,
1747      previousIndex
1748    } = swiper;
1749    let dir = direction;
1750    if (!dir) {
1751      if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
1752    }
1753    swiper.emit(`transition${step}`);
1754    if (runCallbacks && activeIndex !== previousIndex) {
1755      if (dir === 'reset') {
1756        swiper.emit(`slideResetTransition${step}`);
1757        return;
1758      }
1759      swiper.emit(`slideChangeTransition${step}`);
1760      if (dir === 'next') {
1761        swiper.emit(`slideNextTransition${step}`);
1762      } else {
1763        swiper.emit(`slidePrevTransition${step}`);
1764      }
1765    }
1766  }
1767
1768  function transitionStart(runCallbacks, direction) {
1769    if (runCallbacks === void 0) {
1770      runCallbacks = true;
1771    }
1772    const swiper = this;
1773    const {
1774      params
1775    } = swiper;
1776    if (params.cssMode) return;
1777    if (params.autoHeight) {
1778      swiper.updateAutoHeight();
1779    }
1780    transitionEmit({
1781      swiper,
1782      runCallbacks,
1783      direction,
1784      step: 'Start'
1785    });
1786  }
1787
1788  function transitionEnd(runCallbacks, direction) {
1789    if (runCallbacks === void 0) {
1790      runCallbacks = true;
1791    }
1792    const swiper = this;
1793    const {
1794      params
1795    } = swiper;
1796    swiper.animating = false;
1797    if (params.cssMode) return;
1798    swiper.setTransition(0);
1799    transitionEmit({
1800      swiper,
1801      runCallbacks,
1802      direction,
1803      step: 'End'
1804    });
1805  }
1806
1807  var transition = {
1808    setTransition,
1809    transitionStart,
1810    transitionEnd
1811  };
1812
1813  function slideTo(index, speed, runCallbacks, internal, initial) {
1814    if (index === void 0) {
1815      index = 0;
1816    }
1817    if (speed === void 0) {
1818      speed = this.params.speed;
1819    }
1820    if (runCallbacks === void 0) {
1821      runCallbacks = true;
1822    }
1823    if (typeof index === 'string') {
1824      index = parseInt(index, 10);
1825    }
1826    const swiper = this;
1827    let slideIndex = index;
1828    if (slideIndex < 0) slideIndex = 0;
1829    const {
1830      params,
1831      snapGrid,
1832      slidesGrid,
1833      previousIndex,
1834      activeIndex,
1835      rtlTranslate: rtl,
1836      wrapperEl,
1837      enabled
1838    } = swiper;
1839    if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
1840      return false;
1841    }
1842    const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
1843    let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
1844    if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1845    const translate = -snapGrid[snapIndex];
1846    // Normalize slideIndex
1847    if (params.normalizeSlideIndex) {
1848      for (let i = 0; i < slidesGrid.length; i += 1) {
1849        const normalizedTranslate = -Math.floor(translate * 100);
1850        const normalizedGrid = Math.floor(slidesGrid[i] * 100);
1851        const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
1852        if (typeof slidesGrid[i + 1] !== 'undefined') {
1853          if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
1854            slideIndex = i;
1855          } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
1856            slideIndex = i + 1;
1857          }
1858        } else if (normalizedTranslate >= normalizedGrid) {
1859          slideIndex = i;
1860        }
1861      }
1862    }
1863    // Directions locks
1864    if (swiper.initialized && slideIndex !== activeIndex) {
1865      if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) {
1866        return false;
1867      }
1868      if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
1869        if ((activeIndex || 0) !== slideIndex) {
1870          return false;
1871        }
1872      }
1873    }
1874    if (slideIndex !== (previousIndex || 0) && runCallbacks) {
1875      swiper.emit('beforeSlideChangeStart');
1876    }
1877
1878    // Update progress
1879    swiper.updateProgress(translate);
1880    let direction;
1881    if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset';
1882
1883    // Update Index
1884    if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {
1885      swiper.updateActiveIndex(slideIndex);
1886      // Update Height
1887      if (params.autoHeight) {
1888        swiper.updateAutoHeight();
1889      }
1890      swiper.updateSlidesClasses();
1891      if (params.effect !== 'slide') {
1892        swiper.setTranslate(translate);
1893      }
1894      if (direction !== 'reset') {
1895        swiper.transitionStart(runCallbacks, direction);
1896        swiper.transitionEnd(runCallbacks, direction);
1897      }
1898      return false;
1899    }
1900    if (params.cssMode) {
1901      const isH = swiper.isHorizontal();
1902      const t = rtl ? translate : -translate;
1903      if (speed === 0) {
1904        const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1905        if (isVirtual) {
1906          swiper.wrapperEl.style.scrollSnapType = 'none';
1907          swiper._immediateVirtual = true;
1908        }
1909        if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
1910          swiper._cssModeVirtualInitialSet = true;
1911          requestAnimationFrame(() => {
1912            wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1913          });
1914        } else {
1915          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1916        }
1917        if (isVirtual) {
1918          requestAnimationFrame(() => {
1919            swiper.wrapperEl.style.scrollSnapType = '';
1920            swiper._immediateVirtual = false;
1921          });
1922        }
1923      } else {
1924        if (!swiper.support.smoothScroll) {
1925          animateCSSModeScroll({
1926            swiper,
1927            targetPosition: t,
1928            side: isH ? 'left' : 'top'
1929          });
1930          return true;
1931        }
1932        wrapperEl.scrollTo({
1933          [isH ? 'left' : 'top']: t,
1934          behavior: 'smooth'
1935        });
1936      }
1937      return true;
1938    }
1939    swiper.setTransition(speed);
1940    swiper.setTranslate(translate);
1941    swiper.updateActiveIndex(slideIndex);
1942    swiper.updateSlidesClasses();
1943    swiper.emit('beforeTransitionStart', speed, internal);
1944    swiper.transitionStart(runCallbacks, direction);
1945    if (speed === 0) {
1946      swiper.transitionEnd(runCallbacks, direction);
1947    } else if (!swiper.animating) {
1948      swiper.animating = true;
1949      if (!swiper.onSlideToWrapperTransitionEnd) {
1950        swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
1951          if (!swiper || swiper.destroyed) return;
1952          if (e.target !== this) return;
1953          swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1954          swiper.onSlideToWrapperTransitionEnd = null;
1955          delete swiper.onSlideToWrapperTransitionEnd;
1956          swiper.transitionEnd(runCallbacks, direction);
1957        };
1958      }
1959      swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1960    }
1961    return true;
1962  }
1963
1964  function slideToLoop(index, speed, runCallbacks, internal) {
1965    if (index === void 0) {
1966      index = 0;
1967    }
1968    if (speed === void 0) {
1969      speed = this.params.speed;
1970    }
1971    if (runCallbacks === void 0) {
1972      runCallbacks = true;
1973    }
1974    if (typeof index === 'string') {
1975      const indexAsNumber = parseInt(index, 10);
1976      index = indexAsNumber;
1977    }
1978    const swiper = this;
1979    const gridEnabled = swiper.grid && swiper.params.grid && swiper.params.grid.rows > 1;
1980    let newIndex = index;
1981    if (swiper.params.loop) {
1982      if (swiper.virtual && swiper.params.virtual.enabled) {
1983        // eslint-disable-next-line
1984        newIndex = newIndex + swiper.virtual.slidesBefore;
1985      } else {
1986        let targetSlideIndex;
1987        if (gridEnabled) {
1988          const slideIndex = newIndex * swiper.params.grid.rows;
1989          targetSlideIndex = swiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex)[0].column;
1990        } else {
1991          targetSlideIndex = swiper.getSlideIndexByData(newIndex);
1992        }
1993        const cols = gridEnabled ? Math.ceil(swiper.slides.length / swiper.params.grid.rows) : swiper.slides.length;
1994        const {
1995          centeredSlides
1996        } = swiper.params;
1997        let slidesPerView = swiper.params.slidesPerView;
1998        if (slidesPerView === 'auto') {
1999          slidesPerView = swiper.slidesPerViewDynamic();
2000        } else {
2001          slidesPerView = Math.ceil(parseFloat(swiper.params.slidesPerView, 10));
2002          if (centeredSlides && slidesPerView % 2 === 0) {
2003            slidesPerView = slidesPerView + 1;
2004          }
2005        }
2006        let needLoopFix = cols - targetSlideIndex < slidesPerView;
2007        if (centeredSlides) {
2008          needLoopFix = needLoopFix || targetSlideIndex < Math.ceil(slidesPerView / 2);
2009        }
2010        if (needLoopFix) {
2011          const direction = centeredSlides ? targetSlideIndex < swiper.activeIndex ? 'prev' : 'next' : targetSlideIndex - swiper.activeIndex - 1 < swiper.params.slidesPerView ? 'next' : 'prev';
2012          swiper.loopFix({
2013            direction,
2014            slideTo: true,
2015            activeSlideIndex: direction === 'next' ? targetSlideIndex + 1 : targetSlideIndex - cols + 1,
2016            slideRealIndex: direction === 'next' ? swiper.realIndex : undefined
2017          });
2018        }
2019        if (gridEnabled) {
2020          const slideIndex = newIndex * swiper.params.grid.rows;
2021          newIndex = swiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex)[0].column;
2022        } else {
2023          newIndex = swiper.getSlideIndexByData(newIndex);
2024        }
2025      }
2026    }
2027    requestAnimationFrame(() => {
2028      swiper.slideTo(newIndex, speed, runCallbacks, internal);
2029    });
2030    return swiper;
2031  }
2032
2033  /* eslint no-unused-vars: "off" */
2034  function slideNext(speed, runCallbacks, internal) {
2035    if (speed === void 0) {
2036      speed = this.params.speed;
2037    }
2038    if (runCallbacks === void 0) {
2039      runCallbacks = true;
2040    }
2041    const swiper = this;
2042    const {
2043      enabled,
2044      params,
2045      animating
2046    } = swiper;
2047    if (!enabled) return swiper;
2048    let perGroup = params.slidesPerGroup;
2049    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2050      perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
2051    }
2052    const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2053    const isVirtual = swiper.virtual && params.virtual.enabled;
2054    if (params.loop) {
2055      if (animating && !isVirtual && params.loopPreventsSliding) return false;
2056      swiper.loopFix({
2057        direction: 'next'
2058      });
2059      // eslint-disable-next-line
2060      swiper._clientLeft = swiper.wrapperEl.clientLeft;
2061      if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
2062        requestAnimationFrame(() => {
2063          swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2064        });
2065        return true;
2066      }
2067    }
2068    if (params.rewind && swiper.isEnd) {
2069      return swiper.slideTo(0, speed, runCallbacks, internal);
2070    }
2071    return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2072  }
2073
2074  /* eslint no-unused-vars: "off" */
2075  function slidePrev(speed, runCallbacks, internal) {
2076    if (speed === void 0) {
2077      speed = this.params.speed;
2078    }
2079    if (runCallbacks === void 0) {
2080      runCallbacks = true;
2081    }
2082    const swiper = this;
2083    const {
2084      params,
2085      snapGrid,
2086      slidesGrid,
2087      rtlTranslate,
2088      enabled,
2089      animating
2090    } = swiper;
2091    if (!enabled) return swiper;
2092    const isVirtual = swiper.virtual && params.virtual.enabled;
2093    if (params.loop) {
2094      if (animating && !isVirtual && params.loopPreventsSliding) return false;
2095      swiper.loopFix({
2096        direction: 'prev'
2097      });
2098      // eslint-disable-next-line
2099      swiper._clientLeft = swiper.wrapperEl.clientLeft;
2100    }
2101    const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2102    function normalize(val) {
2103      if (val < 0) return -Math.floor(Math.abs(val));
2104      return Math.floor(val);
2105    }
2106    const normalizedTranslate = normalize(translate);
2107    const normalizedSnapGrid = snapGrid.map(val => normalize(val));
2108    let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2109    if (typeof prevSnap === 'undefined' && params.cssMode) {
2110      let prevSnapIndex;
2111      snapGrid.forEach((snap, snapIndex) => {
2112        if (normalizedTranslate >= snap) {
2113          // prevSnap = snap;
2114          prevSnapIndex = snapIndex;
2115        }
2116      });
2117      if (typeof prevSnapIndex !== 'undefined') {
2118        prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2119      }
2120    }
2121    let prevIndex = 0;
2122    if (typeof prevSnap !== 'undefined') {
2123      prevIndex = slidesGrid.indexOf(prevSnap);
2124      if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2125      if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2126        prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2127        prevIndex = Math.max(prevIndex, 0);
2128      }
2129    }
2130    if (params.rewind && swiper.isBeginning) {
2131      const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2132      return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2133    } else if (params.loop && swiper.activeIndex === 0 && params.cssMode) {
2134      requestAnimationFrame(() => {
2135        swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2136      });
2137      return true;
2138    }
2139    return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2140  }
2141
2142  /* eslint no-unused-vars: "off" */
2143  function slideReset(speed, runCallbacks, internal) {
2144    if (speed === void 0) {
2145      speed = this.params.speed;
2146    }
2147    if (runCallbacks === void 0) {
2148      runCallbacks = true;
2149    }
2150    const swiper = this;
2151    return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2152  }
2153
2154  /* eslint no-unused-vars: "off" */
2155  function slideToClosest(speed, runCallbacks, internal, threshold) {
2156    if (speed === void 0) {
2157      speed = this.params.speed;
2158    }
2159    if (runCallbacks === void 0) {
2160      runCallbacks = true;
2161    }
2162    if (threshold === void 0) {
2163      threshold = 0.5;
2164    }
2165    const swiper = this;
2166    let index = swiper.activeIndex;
2167    const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2168    const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2169    const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2170    if (translate >= swiper.snapGrid[snapIndex]) {
2171      // The current translate is on or after the current snap index, so the choice
2172      // is between the current index and the one after it.
2173      const currentSnap = swiper.snapGrid[snapIndex];
2174      const nextSnap = swiper.snapGrid[snapIndex + 1];
2175      if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
2176        index += swiper.params.slidesPerGroup;
2177      }
2178    } else {
2179      // The current translate is before the current snap index, so the choice
2180      // is between the current index and the one before it.
2181      const prevSnap = swiper.snapGrid[snapIndex - 1];
2182      const currentSnap = swiper.snapGrid[snapIndex];
2183      if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
2184        index -= swiper.params.slidesPerGroup;
2185      }
2186    }
2187    index = Math.max(index, 0);
2188    index = Math.min(index, swiper.slidesGrid.length - 1);
2189    return swiper.slideTo(index, speed, runCallbacks, internal);
2190  }
2191
2192  function slideToClickedSlide() {
2193    const swiper = this;
2194    const {
2195      params,
2196      slidesEl
2197    } = swiper;
2198    const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2199    let slideToIndex = swiper.clickedIndex;
2200    let realIndex;
2201    const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2202    if (params.loop) {
2203      if (swiper.animating) return;
2204      realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
2205      if (params.centeredSlides) {
2206        if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2207          swiper.loopFix();
2208          slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2209          nextTick(() => {
2210            swiper.slideTo(slideToIndex);
2211          });
2212        } else {
2213          swiper.slideTo(slideToIndex);
2214        }
2215      } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2216        swiper.loopFix();
2217        slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2218        nextTick(() => {
2219          swiper.slideTo(slideToIndex);
2220        });
2221      } else {
2222        swiper.slideTo(slideToIndex);
2223      }
2224    } else {
2225      swiper.slideTo(slideToIndex);
2226    }
2227  }
2228
2229  var slide = {
2230    slideTo,
2231    slideToLoop,
2232    slideNext,
2233    slidePrev,
2234    slideReset,
2235    slideToClosest,
2236    slideToClickedSlide
2237  };
2238
2239  function loopCreate(slideRealIndex) {
2240    const swiper = this;
2241    const {
2242      params,
2243      slidesEl
2244    } = swiper;
2245    if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2246    const initSlides = () => {
2247      const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
2248      slides.forEach((el, index) => {
2249        el.setAttribute('data-swiper-slide-index', index);
2250      });
2251    };
2252    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2253    const slidesPerGroup = params.slidesPerGroup * (gridEnabled ? params.grid.rows : 1);
2254    const shouldFillGroup = swiper.slides.length % slidesPerGroup !== 0;
2255    const shouldFillGrid = gridEnabled && swiper.slides.length % params.grid.rows !== 0;
2256    const addBlankSlides = amountOfSlides => {
2257      for (let i = 0; i < amountOfSlides; i += 1) {
2258        const slideEl = swiper.isElement ? createElement('swiper-slide', [params.slideBlankClass]) : createElement('div', [params.slideClass, params.slideBlankClass]);
2259        swiper.slidesEl.append(slideEl);
2260      }
2261    };
2262    if (shouldFillGroup) {
2263      if (params.loopAddBlankSlides) {
2264        const slidesToAdd = slidesPerGroup - swiper.slides.length % slidesPerGroup;
2265        addBlankSlides(slidesToAdd);
2266        swiper.recalcSlides();
2267        swiper.updateSlides();
2268      } else {
2269        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)');
2270      }
2271      initSlides();
2272    } else if (shouldFillGrid) {
2273      if (params.loopAddBlankSlides) {
2274        const slidesToAdd = params.grid.rows - swiper.slides.length % params.grid.rows;
2275        addBlankSlides(slidesToAdd);
2276        swiper.recalcSlides();
2277        swiper.updateSlides();
2278      } else {
2279        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)');
2280      }
2281      initSlides();
2282    } else {
2283      initSlides();
2284    }
2285    swiper.loopFix({
2286      slideRealIndex,
2287      direction: params.centeredSlides ? undefined : 'next'
2288    });
2289  }
2290
2291  function loopFix(_temp) {
2292    let {
2293      slideRealIndex,
2294      slideTo = true,
2295      direction,
2296      setTranslate,
2297      activeSlideIndex,
2298      byController,
2299      byMousewheel
2300    } = _temp === void 0 ? {} : _temp;
2301    const swiper = this;
2302    if (!swiper.params.loop) return;
2303    swiper.emit('beforeLoopFix');
2304    const {
2305      slides,
2306      allowSlidePrev,
2307      allowSlideNext,
2308      slidesEl,
2309      params
2310    } = swiper;
2311    const {
2312      centeredSlides
2313    } = params;
2314    swiper.allowSlidePrev = true;
2315    swiper.allowSlideNext = true;
2316    if (swiper.virtual && params.virtual.enabled) {
2317      if (slideTo) {
2318        if (!params.centeredSlides && swiper.snapIndex === 0) {
2319          swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
2320        } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
2321          swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
2322        } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
2323          swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2324        }
2325      }
2326      swiper.allowSlidePrev = allowSlidePrev;
2327      swiper.allowSlideNext = allowSlideNext;
2328      swiper.emit('loopFix');
2329      return;
2330    }
2331    let slidesPerView = params.slidesPerView;
2332    if (slidesPerView === 'auto') {
2333      slidesPerView = swiper.slidesPerViewDynamic();
2334    } else {
2335      slidesPerView = Math.ceil(parseFloat(params.slidesPerView, 10));
2336      if (centeredSlides && slidesPerView % 2 === 0) {
2337        slidesPerView = slidesPerView + 1;
2338      }
2339    }
2340    const slidesPerGroup = params.slidesPerGroupAuto ? slidesPerView : params.slidesPerGroup;
2341    let loopedSlides = slidesPerGroup;
2342    if (loopedSlides % slidesPerGroup !== 0) {
2343      loopedSlides += slidesPerGroup - loopedSlides % slidesPerGroup;
2344    }
2345    loopedSlides += params.loopAdditionalSlides;
2346    swiper.loopedSlides = loopedSlides;
2347    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2348    if (slides.length < slidesPerView + loopedSlides) {
2349      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');
2350    } else if (gridEnabled && params.grid.fill === 'row') {
2351      showWarning('Swiper Loop Warning: Loop mode is not compatible with grid.fill = `row`');
2352    }
2353    const prependSlidesIndexes = [];
2354    const appendSlidesIndexes = [];
2355    let activeIndex = swiper.activeIndex;
2356    if (typeof activeSlideIndex === 'undefined') {
2357      activeSlideIndex = swiper.getSlideIndex(slides.filter(el => el.classList.contains(params.slideActiveClass))[0]);
2358    } else {
2359      activeIndex = activeSlideIndex;
2360    }
2361    const isNext = direction === 'next' || !direction;
2362    const isPrev = direction === 'prev' || !direction;
2363    let slidesPrepended = 0;
2364    let slidesAppended = 0;
2365    const cols = gridEnabled ? Math.ceil(slides.length / params.grid.rows) : slides.length;
2366    const activeColIndex = gridEnabled ? slides[activeSlideIndex].column : activeSlideIndex;
2367    const activeColIndexWithShift = activeColIndex + (centeredSlides && typeof setTranslate === 'undefined' ? -slidesPerView / 2 + 0.5 : 0);
2368    // prepend last slides before start
2369    if (activeColIndexWithShift < loopedSlides) {
2370      slidesPrepended = Math.max(loopedSlides - activeColIndexWithShift, slidesPerGroup);
2371      for (let i = 0; i < loopedSlides - activeColIndexWithShift; i += 1) {

2372        const index = i - Math.floor(i / cols) * cols;
2373        if (gridEnabled) {
2374          const colIndexToPrepend = cols - index - 1;
2375          for (let i = slides.length - 1; i >= 0; i -= 1) {
2376            if (slides[i].column === colIndexToPrepend) prependSlidesIndexes.push(i);
2377          }
2378          // slides.forEach((slide, slideIndex) => {
2379          //   if (slide.column === colIndexToPrepend) prependSlidesIndexes.push(slideIndex);
2380          // });
2381        } else {
2382          prependSlidesIndexes.push(cols - index - 1);
2383        }
2384      }
2385    } else if (activeColIndexWithShift + slidesPerView > cols - loopedSlides) {
2386      slidesAppended = Math.max(activeColIndexWithShift - (cols - loopedSlides * 2), slidesPerGroup);
2387      for (let i = 0; i < slidesAppended; i += 1) {
2388        const index = i - Math.floor(i / cols) * cols;
2389        if (gridEnabled) {
2390          slides.forEach((slide, slideIndex) => {
2391            if (slide.column === index) appendSlidesIndexes.push(slideIndex);
2392          });
2393        } else {
2394          appendSlidesIndexes.push(index);
2395        }
2396      }
2397    }
2398    swiper.__preventObserver__ = true;
2399    requestAnimationFrame(() => {
2400      swiper.__preventObserver__ = false;
2401    });
2402    if (isPrev) {
2403      prependSlidesIndexes.forEach(index => {
2404        slides[index].swiperLoopMoveDOM = true;
2405        slidesEl.prepend(slides[index]);
2406        slides[index].swiperLoopMoveDOM = false;
2407      });
2408    }
2409    if (isNext) {
2410      appendSlidesIndexes.forEach(index => {
2411        slides[index].swiperLoopMoveDOM = true;
2412        slidesEl.append(slides[index]);
2413        slides[index].swiperLoopMoveDOM = false;
2414      });
2415    }
2416    swiper.recalcSlides();
2417    if (params.slidesPerView === 'auto') {
2418      swiper.updateSlides();
2419    } else if (gridEnabled && (prependSlidesIndexes.length > 0 && isPrev || appendSlidesIndexes.length > 0 && isNext)) {
2420      swiper.slides.forEach((slide, slideIndex) => {
2421        swiper.grid.updateSlide(slideIndex, slide, swiper.slides);
2422      });
2423    }
2424    if (params.watchSlidesProgress) {
2425      swiper.updateSlidesOffset();
2426    }
2427    if (slideTo) {
2428      if (prependSlidesIndexes.length > 0 && isPrev) {
2429        if (typeof slideRealIndex === 'undefined') {
2430          const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2431          const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2432          const diff = newSlideTranslate - currentSlideTranslate;
2433          if (byMousewheel) {
2434            swiper.setTranslate(swiper.translate - diff);
2435          } else {
2436            swiper.slideTo(activeIndex + slidesPrepended, 0, false, true);
2437            if (setTranslate) {
2438              swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2439              swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2440            }
2441          }
2442        } else {
2443          if (setTranslate) {
2444            const shift = gridEnabled ? prependSlidesIndexes.length / params.grid.rows : prependSlidesIndexes.length;
2445            swiper.slideTo(swiper.activeIndex + shift, 0, false, true);
2446            swiper.touchEventsData.currentTranslate = swiper.translate;
2447          }
2448        }
2449      } else if (appendSlidesIndexes.length > 0 && isNext) {
2450        if (typeof slideRealIndex === 'undefined') {
2451          const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2452          const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2453          const diff = newSlideTranslate - currentSlideTranslate;
2454          if (byMousewheel) {
2455            swiper.setTranslate(swiper.translate - diff);
2456          } else {
2457            swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2458            if (setTranslate) {
2459              swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2460              swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2461            }
2462          }
2463        } else {
2464          const shift = gridEnabled ? appendSlidesIndexes.length / params.grid.rows : appendSlidesIndexes.length;
2465          swiper.slideTo(swiper.activeIndex - shift, 0, false, true);
2466        }
2467      }
2468    }
2469    swiper.allowSlidePrev = allowSlidePrev;
2470    swiper.allowSlideNext = allowSlideNext;
2471    if (swiper.controller && swiper.controller.control && !byController) {
2472      const loopParams = {
2473        slideRealIndex,
2474        direction,
2475        setTranslate,
2476        activeSlideIndex,
2477        byController: true
2478      };
2479      if (Array.isArray(swiper.controller.control)) {
2480        swiper.controller.control.forEach(c => {
2481          if (!c.destroyed && c.params.loop) c.loopFix({
2482            ...loopParams,
2483            slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo : false
2484          });
2485        });
2486      } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
2487        swiper.controller.control.loopFix({
2488          ...loopParams,
2489          slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo : false
2490        });
2491      }
2492    }
2493    swiper.emit('loopFix');
2494  }
2495
2496  function loopDestroy() {
2497    const swiper = this;
2498    const {
2499      params,
2500      slidesEl
2501    } = swiper;
2502    if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2503    swiper.recalcSlides();
2504    const newSlidesOrder = [];
2505    swiper.slides.forEach(slideEl => {
2506      const index = typeof slideEl.swiperSlideIndex === 'undefined' ? slideEl.getAttribute('data-swiper-slide-index') * 1 : slideEl.swiperSlideIndex;
2507      newSlidesOrder[index] = slideEl;
2508    });
2509    swiper.slides.forEach(slideEl => {
2510      slideEl.removeAttribute('data-swiper-slide-index');
2511    });
2512    newSlidesOrder.forEach(slideEl => {
2513      slidesEl.append(slideEl);
2514    });
2515    swiper.recalcSlides();
2516    swiper.slideTo(swiper.realIndex, 0);
2517  }
2518
2519  var loop = {
2520    loopCreate,
2521    loopFix,
2522    loopDestroy
2523  };
2524
2525  function setGrabCursor(moving) {
2526    const swiper = this;
2527    if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
2528    const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
2529    if (swiper.isElement) {
2530      swiper.__preventObserver__ = true;
2531    }
2532    el.style.cursor = 'move';
2533    el.style.cursor = moving ? 'grabbing' : 'grab';
2534    if (swiper.isElement) {
2535      requestAnimationFrame(() => {
2536        swiper.__preventObserver__ = false;
2537      });
2538    }
2539  }
2540
2541  function unsetGrabCursor() {
2542    const swiper = this;
2543    if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
2544      return;
2545    }
2546    if (swiper.isElement) {
2547      swiper.__preventObserver__ = true;
2548    }
2549    swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
2550    if (swiper.isElement) {
2551      requestAnimationFrame(() => {
2552        swiper.__preventObserver__ = false;
2553      });
2554    }
2555  }
2556
2557  var grabCursor = {
2558    setGrabCursor,
2559    unsetGrabCursor
2560  };
2561
2562  // Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd
2563  function closestElement(selector, base) {
2564    if (base === void 0) {
2565      base = this;
2566    }
2567    function __closestFrom(el) {
2568      if (!el || el === getDocument() || el === getWindow()) return null;
2569      if (el.assignedSlot) el = el.assignedSlot;
2570      const found = el.closest(selector);
2571      if (!found && !el.getRootNode) {
2572        return null;
2573      }
2574      return found || __closestFrom(el.getRootNode().host);
2575    }
2576    return __closestFrom(base);
2577  }
2578  function preventEdgeSwipe(swiper, event, startX) {
2579    const window = getWindow();
2580    const {
2581      params
2582    } = swiper;
2583    const edgeSwipeDetection = params.edgeSwipeDetection;
2584    const edgeSwipeThreshold = params.edgeSwipeThreshold;
2585    if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
2586      if (edgeSwipeDetection === 'prevent') {
2587        event.preventDefault();
2588        return true;
2589      }
2590      return false;
2591    }
2592    return true;
2593  }
2594  function onTouchStart(event) {
2595    const swiper = this;
2596    const document = getDocument();
2597    let e = event;
2598    if (e.originalEvent) e = e.originalEvent;
2599    const data = swiper.touchEventsData;
2600    if (e.type === 'pointerdown') {
2601      if (data.pointerId !== null && data.pointerId !== e.pointerId) {
2602        return;
2603      }
2604      data.pointerId = e.pointerId;
2605    } else if (e.type === 'touchstart' && e.targetTouches.length === 1) {
2606      data.touchId = e.targetTouches[0].identifier;
2607    }
2608    if (e.type === 'touchstart') {
2609      // don't proceed touch event
2610      preventEdgeSwipe(swiper, e, e.targetTouches[0].pageX);
2611      return;
2612    }
2613    const {
2614      params,
2615      touches,
2616      enabled
2617    } = swiper;
2618    if (!enabled) return;
2619    if (!params.simulateTouch && e.pointerType === 'mouse') return;
2620    if (swiper.animating && params.preventInteractionOnTransition) {
2621      return;
2622    }
2623    if (!swiper.animating && params.cssMode && params.loop) {
2624      swiper.loopFix();
2625    }
2626    let targetEl = e.target;
2627    if (params.touchEventsTarget === 'wrapper') {
2628      if (!swiper.wrapperEl.contains(targetEl)) return;
2629    }
2630    if ('which' in e && e.which === 3) return;
2631    if ('button' in e && e.button > 0) return;
2632    if (data.isTouched && data.isMoved) return;
2633
2634    // change target el for shadow root component
2635    const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';
2636    // eslint-disable-next-line
2637    const eventPath = e.composedPath ? e.composedPath() : e.path;
2638    if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
2639      targetEl = eventPath[0];
2640    }
2641    const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2642    const isTargetShadow = !!(e.target && e.target.shadowRoot);
2643
2644    // use closestElement for shadow root element to get the actual closest for nested shadow root element
2645    if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {
2646      swiper.allowClick = true;
2647      return;
2648    }
2649    if (params.swipeHandler) {
2650      if (!targetEl.closest(params.swipeHandler)) return;
2651    }
2652    touches.currentX = e.pageX;
2653    touches.currentY = e.pageY;
2654    const startX = touches.currentX;
2655    const startY = touches.currentY;
2656
2657    // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
2658
2659    if (!preventEdgeSwipe(swiper, e, startX)) {
2660      return;
2661    }
2662    Object.assign(data, {
2663      isTouched: true,
2664      isMoved: false,
2665      allowTouchCallbacks: true,
2666      isScrolling: undefined,
2667      startMoving: undefined
2668    });
2669    touches.startX = startX;
2670    touches.startY = startY;