https://sunrisexp.com/assets/swiper11/swiper-bundle.js

1/**
2 * Swiper 11.0.3
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: October 26, 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

646.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

878(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      }).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 

1032- 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    if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1083      const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1084      const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1085      if (slidesLength <= params.maxBackfaceHiddenSlides) {
1086        if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1087      } else if (hasClassBackfaceClassAdded) {
1088        swiper.el.classList.remove(backFaceHiddenClass);
1089      }
1090    }
1091  }
1092
1093  function updateAutoHeight(speed) {
1094    const swiper = this;
1095    const activeSlides = [];
1096    const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1097    let newHeight = 0;
1098    let i;
1099    if (typeof speed === 'number') {
1100      swiper.setTransition(speed);
1101    } else if (speed === true) {
1102      swiper.setTransition(swiper.params.speed);
1103    }
1104    const getSlideByIndex = index => {
1105      if (isVirtual) {
1106        return swiper.slides[swiper.getSlideIndexByData(index)];
1107      }
1108      return swiper.slides[index];
1109    };
1110    // Find slides currently in view
1111    if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1112      if (swiper.params.centeredSlides) {

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

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

1278    slides.forEach(slideEl => {
1279      slideEl.classList.remove(params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
1280    });
1281    let activeSlide;
1282    let prevSlide;
1283    let nextSlide;
1284    if (isVirtual) {
1285      if (params.loop) {
1286        let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1287        if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1288        if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1289        activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1290      } else {
1291        activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1292      }
1293    } else {
1294      if (gridEnabled) {
1295        activeSlide = slides.filter(slideEl => slideEl.column === activeIndex)[0];
1296        nextSlide = slides.filter(slideEl => slideEl.column === activeIndex + 1)[0];
1297        prevSlide = slides.filter(slideEl => slideEl.column === activeIndex - 1)[0];
1298      } else {
1299        activeSlide = slides[activeIndex];
1300      }
1301    }
1302    if (activeSlide) {
1303      // Active classes
1304      activeSlide.classList.add(params.slideActiveClass);
1305      if (gridEnabled) {
1306        if (nextSlide) {
1307          nextSlide.classList.add(params.slideNextClass);
1308        }
1309        if (prevSlide) {
1310          prevSlide.classList.add(params.slidePrevClass);
1311        }
1312      } else {
1313        // Next Slide
1314        nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1315        if (params.loop && !nextSlide) {
1316          nextSlide = slides[0];
1317        }
1318        if (nextSlide) {
1319          nextSlide.classList.add(params.slideNextClass);
1320        }
1321
1322        // Prev Slide
1323        prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1324        if (params.loop && !prevSlide === 0) {
1325          prevSlide = slides[slides.length - 1];
1326        }
1327        if (prevSlide) {
1328          prevSlide.classList.add(params.slidePrevClass);
1329        }
1330      }
1331    }
1332    swiper.emitSlidesClasses();
1333  }
1334
1335  const processLazyPreloader = (swiper, imageEl) => {
1336    if (!swiper || swiper.destroyed || !swiper.params) return;
1337    const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1338    const slideEl = imageEl.closest(slideSelector());
1339    if (slideEl) {
1340      let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1341      if (!lazyEl && swiper.isElement) {
1342        if (slideEl.shadowRoot) {
1343          lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1344        } else {
1345          // init later
1346          requestAnimationFrame(() => {
1347            if (slideEl.shadowRoot) {
1348              lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1349              if (lazyEl) lazyEl.remove();
1350            }
1351          });
1352        }
1353      }
1354      if (lazyEl) lazyEl.remove();
1355    }
1356  };
1357  const unlazy = (swiper, index) => {
1358    if (!swiper.slides[index]) return;
1359    const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1360    if (imageEl) imageEl.removeAttribute('loading');
1361  };
1362  const preload = swiper => {
1363    if (!swiper || swiper.destroyed || !swiper.params) return;
1364    let amount = swiper.params.lazyPreloadPrevNext;
1365    const len = swiper.slides.length;
1366    if (!len || !amount || amount < 0) return;
1367    amount = Math.min(amount, len);
1368    const slidesPerView = swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1369    const activeIndex = swiper.activeIndex;
1370    if (swiper.params.grid && swiper.params.grid.rows > 1) {
1371      const activeColumn = activeIndex;
1372      const preloadColumns = [activeColumn - amount];
1373      preloadColumns.push(...Array.from({
1374        length: amount
1375      }).map((_, i) => {
1376        return activeColumn + slidesPerView + i;
1377      }));
1378      swiper.slides.forEach((slideEl, i) => {
1379        if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1380      });
1381      return;
1382    }
1383    const slideIndexLastInView = activeIndex + slidesPerView - 1;
1384    if (swiper.params.rewind || swiper.params.loop) {
1385      for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1386        const realIndex = (i % len + len) % len;
1387        if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1388      }
1389    } else {
1390      for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1391        if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1392          unlazy(swiper, i);
1393        }
1394      }
1395    }
1396  };
1397
1398  function getActiveIndexByTranslate(swiper) {
1399    const {
1400      slidesGrid,
1401      params
1402    } = swiper;
1403    const translate = swiper.rtlTranslate ? swiper.translate : -swi

1403per.translate;
1404    let activeIndex;
1405    for (let i = 0; i < slidesGrid.length; i += 1) {
1406      if (typeof slidesGrid[i + 1] !== 'undefined') {
1407        if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1408          activeIndex = i;
1409        } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1410          activeIndex = i + 1;
1411        }
1412      } else if (translate >= slidesGrid[i]) {
1413        activeIndex = i;
1414      }
1415    }
1416    // Normalize slideIndex
1417    if (params.normalizeSlideIndex) {
1418      if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1419    }
1420    return activeIndex;
1421  }
1422  function updateActiveIndex(newActiveIndex) {
1423    const swiper = this;
1424    const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1425    const {
1426      snapGrid,
1427      params,
1428      activeIndex: previousIndex,
1429      realIndex: previousRealIndex,
1430      snapIndex: previousSnapIndex
1431    } = swiper;
1432    let activeIndex = newActiveIndex;
1433    let snapIndex;
1434    const getVirtualRealIndex = aIndex => {
1435      let realIndex = aIndex - swiper.virtual.slidesBefore;
1436      if (realIndex < 0) {
1437        realIndex = swiper.virtual.slides.length + realIndex;
1438      }
1439      if (realIndex >= swiper.virtual.slides.length) {
1440        realIndex -= swiper.virtual.slides.length;
1441      }
1442      return realIndex;
1443    };
1444    if (typeof activeIndex === 'undefined') {
1445      activeIndex = getActiveIndexByTranslate(swiper);
1446    }
1447    if (snapGrid.indexOf(translate) >= 0) {
1448      snapIndex = snapGrid.indexOf(translate);
1449    } else {
1450      const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1451      snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1452    }
1453    if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1454    if (activeIndex === previousIndex && !swiper.params.loop) {
1455      if (snapIndex !== previousSnapIndex) {
1456        swiper.snapIndex = snapIndex;
1457        swiper.emit('snapIndexChange');
1458      }
1459      return;
1460    }
1461    if (activeIndex === previousIndex && swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1462      swiper.realIndex = getVirtualRealIndex(activeIndex);
1463      return;
1464    }
1465    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1466
1467    // Get real index
1468    let realIndex;
1469    if (swiper.virtual && params.virtual.enabled && params.loop) {
1470      realIndex = getVirtualRealIndex(activeIndex);
1471    } else if (gridEnabled) {
1472      const firstSlideInColumn = swiper.slides.filter(slideEl => slideEl.column === activeIndex)[0];
1473      let activeSlideIndex = parseInt(firstSlideInColumn.getAttribute('data-swiper-slide-index'), 10);
1474      if (Number.isNaN(activeSlideIndex)) {
1475        activeSlideIndex = Math.max(swiper.slides.indexOf(firstSlideInColumn), 0);
1476      }
1477      realIndex = Math.floor(activeSlideIndex / params.grid.rows);
1478    } else if (swiper.slides[activeIndex]) {
1479      const slideIndex = swiper.slides[activeIndex].getAttribute('data-swiper-slide-index');
1480      if (slideIndex) {
1481        realIndex = parseInt(slideIndex, 10);
1482      } else {
1483        realIndex = activeIndex;
1484      }
1485    } else {
1486      realIndex = activeIndex;
1487    }
1488    Object.assign(swiper, {
1489      previousSnapIndex,
1490      snapIndex,
1491      previousRealIndex,
1492      realIndex,
1493      previousIndex,
1494      activeIndex
1495    });
1496    if (swiper.initialized) {
1497      preload(swiper);
1498    }
1499    swiper.emit('activeIndexChange');
1500    swiper.emit('snapIndexChange');
1501    if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1502      if (previousRealIndex !== realIndex) {
1503        swiper.emit('realIndexChange');
1504      }
1505      swiper.emit('slideChange');
1506    }
1507  }
1508
1509  function updateClickedSlide(el, path) {
1510    const swiper = this;
1511    const params = swiper.params;
1512    let slide = el.closest(`.${params.slideClass}, swiper-slide`);
1513    if (!slide && swiper.isElement && path && path.length > 1 && path.includes(el)) {

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

1796    if (params.cssMode) return;
1797    swiper.setTransition(0);
1798    transitionEmit({
1799      swiper,
1800      runCallbacks,
1801      direction,
1802      step: 'End'
1803    });
1804  }
1805
1806  var transition = {
1807    setTransition,
1808    transitionStart,
1809    transitionEnd
1810  };
1811
1812  function slideTo(index, speed, runCallbacks, internal, initial) {
1813    if (index === void 0) {
1814      index = 0;
1815    }
1816    if (speed === void 0) {
1817      speed = this.params.speed;
1818    }
1819    if (runCallbacks === void 0) {
1820      runCallbacks = true;
1821    }
1822    if (typeof index === 'string') {
1823      index = parseInt(index, 10);
1824    }
1825    const swiper = this;
1826    let slideIndex = index;
1827    if (slideIndex < 0) slideIndex = 0;
1828    const {
1829      params,
1830      snapGrid,
1831      slidesGrid,
1832      previousIndex,
1833      activeIndex,
1834      rtlTranslate: rtl,
1835      wrapperEl,
1836      enabled
1837    } = swiper;
1838    if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
1839      return false;
1840    }
1841    const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
1842    let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
1843    if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1844    const translate = -snapGrid[snapIndex];
1845    // Normalize slideIndex
1846    if (params.normalizeSlideIndex) {
1847      for (let i = 0; i < slidesGrid.length; i += 1) {
1848        const normalizedTranslate = -Math.floor(translate * 100);
1849        const normalizedGrid = Math.floor(slidesGrid[i] * 100);
1850        const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
1851        if (typeof slidesGrid[i + 1] !== 'undefined') {
1852          if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
1853            slideIndex = i;
1854          } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
1855            slideIndex = i + 1;
1856          }
1857        } else if (normalizedTranslate >= normalizedGrid) {
1858          slideIndex = i;
1859        }
1860      }
1861    }
1862    // Directions locks
1863    if (swiper.initialized && slideIndex !== activeIndex) {
1864      if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) {
1865        return false;
1866      }
1867      if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
1868        if ((activeIndex || 0) !== slideIndex) {
1869          return false;
1870        }
1871      }
1872    }
1873    if (slideIndex !== (previousIndex || 0) && runCallbacks) {
1874      swiper.emit('beforeSlideChangeStart');
1875    }
1876
1877    // Update progress
1878    swiper.updateProgress(translate);
1879    let direction;
1880    if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset';
1881
1882    // Update Index
1883    if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {
1884      swiper.updateActiveIndex(slideIndex);
1885      // Update Height
1886      if (params.autoHeight) {
1887        swiper.updateAutoHeight();
1888      }
1889      swiper.updateSlidesClasses();
1890      if (params.effect !== 'slide') {
1891        swiper.setTranslate(translate);
1892      }
1893      if (direction !== 'reset') {
1894        swiper.transitionStart(runCallbacks, direction);
1895        swiper.transitionEnd(runCallbacks, direction);
1896      }
1897      return false;
1898    }
1899    if (params.cssMode) {
1900      const isH = swiper.isHorizontal();
1901      const t = rtl ? translate : -translate;
1902      if (speed === 0) {
1903        const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1904        if (isVirtual) {
1905          swiper.wrapperEl.style.scrollSnapType = 'none';
1906          swiper._immediateVirtual = true;
1907        }
1908        if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
1909          swiper._cssModeVirtualInitialSet = true;
1910          requestAnimationFrame(() => {
1911            wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1912          });
1913        } else {
1914          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1915        }
1916        if (isVirtual) {
1917          requestAnimationFrame(() => {
1918            swiper.wrapperEl.style.scrollSnapType = '';
1919            swiper._immediateVirtual = false;

1920          });
1921        }
1922      } else {
1923        if (!swiper.support.smoothScroll) {
1924          animateCSSModeScroll({
1925            swiper,
1926            targetPosition: t,
1927            side: isH ? 'left' : 'top'
1928          });
1929          return true;
1930        }
1931        wrapperEl.scrollTo({
1932          [isH ? 'left' : 'top']: t,
1933          behavior: 'smooth'
1934        });
1935      }
1936      return true;
1937    }
1938    swiper.setTransition(speed);
1939    swiper.setTranslate(translate);
1940    swiper.updateActiveIndex(slideIndex);
1941    swiper.updateSlidesClasses();
1942    swiper.emit('beforeTransitionStart', speed, internal);
1943    swiper.transitionStart(runCallbacks, direction);
1944    if (speed === 0) {
1945      swiper.transitionEnd(runCallbacks, direction);
1946    } else if (!swiper.animating) {
1947      swiper.animating = true;
1948      if (!swiper.onSlideToWrapperTransitionEnd) {
1949        swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
1950          if (!swiper || swiper.destroyed) return;
1951          if (e.target !== this) return;
1952          swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1953          swiper.onSlideToWrapperTransitionEnd = null;
1954          delete swiper.onSlideToWrapperTransitionEnd;
1955          swiper.transitionEnd(runCallbacks, direction);
1956        };
1957      }
1958      swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1959    }
1960    return true;
1961  }
1962
1963  function slideToLoop(index, speed, runCallbacks, internal) {
1964    if (index === void 0) {
1965      index = 0;
1966    }
1967    if (speed === void 0) {
1968      speed = this.params.speed;
1969    }
1970    if (runCallbacks === void 0) {
1971      runCallbacks = true;
1972    }
1973    if (typeof index === 'string') {
1974      const indexAsNumber = parseInt(index, 10);
1975      index = indexAsNumber;
1976    }
1977    const swiper = this;
1978    const gridEnabled = swiper.grid && swiper.params.grid && swiper.params.grid.rows > 1;
1979    let newIndex = index;
1980    if (swiper.params.loop) {
1981      if (swiper.virtual && swiper.params.virtual.enabled) {
1982        // eslint-disable-next-line
1983        newIndex = newIndex + swiper.virtual.slidesBefore;
1984      } else {
1985        let targetSlideIndex;
1986        if (gridEnabled) {
1987          const slideIndex = newIndex * swiper.params.grid.rows;
1988          targetSlideIndex = swiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex)[0].column;
1989        } else {
1990          targetSlideIndex = swiper.getSlideIndexByData(newIndex);
1991        }
1992        const cols = gridEnabled ? Math.ceil(swiper.slides.length / swiper.params.grid.rows) : swiper.slides.length;
1993        const {
1994          centeredSlides
1995        } = swiper.params;
1996        let slidesPerView = swiper.params.slidesPerView;
1997        if (slidesPerView === 'auto') {
1998          slidesPerView = swiper.slidesPerViewDynamic();
1999        } else {
2000          slidesPerView = Math.ceil(parseFloat(swiper.params.slidesPerView, 10));
2001          if (centeredSlides && slidesPerView % 2 === 0) {
2002            slidesPerView = slidesPerView + 1;
2003          }
2004        }
2005        let needLoopFix = cols - targetSlideIndex < slidesPerView;
2006        if (centeredSlides) {
2007          needLoopFix = needLoopFix || targetSlideIndex < Math.ceil(slidesPerView / 2);
2008        }
2009        if (needLoopFix) {
2010          const direction = centeredSlides ? targetSlideIndex < swiper.activeIndex ? 'prev' : 'next' : targetSlideIndex - swiper.activeIndex - 1 < swiper.params.slidesPerView ? 'next' : 'prev';
2011          swiper.loopFix({
2012            direction,
2013            slideTo: true,
2014            activeSlideIndex: direction === 'next' ? targetSlideIndex + 1 : targetSlideIndex - cols + 1,
2015            slideRealIndex: direction === 'next' ? swiper.realIndex : undefined
2016          });
2017        }
2018        if (gridEnabled) {
2019          const slideIndex = newIndex * swiper.params.grid.rows;
2020          newIndex = swiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex)[0].column;
2021        } else {
2022          newIndex = swiper.getSlideIndexByData(newIndex);
2023        }
2024      }
2025    }
2026    requestAnimationFrame(() => {
2027      swiper.slideTo(newIndex, speed, runCallbacks, internal);
2028    });
2029    return swiper;
2030  }
2031
2032  /* eslint no-unused-vars: "off" */
2033  function slideNext(speed, runCallbacks, internal) {
2034    if (speed === void 0) {
2035      speed = this.params.speed;
2036    }
2037    if (runCallbacks === void 0) {
2038      runCallbacks = true;
2039    }
2040    const swiper = this;
2041    const {
2042      enabled,
2043      params,
2044      animating
2045    } = swiper;
2046    if (!enabled) return swiper;
2047    let perGroup = params.slidesPerGroup;
2048    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2049      perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
2050    }
2051    const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2052    const isVirtual = swiper.virtual && params.virtual.enabled;
2053    if (params.loop) {
2054      if (animating && !isVirtual && params.loopPreventsSliding) return false;

2055      swiper.loopFix({
2056        direction: 'next'
2057      });
2058      // eslint-disable-next-line
2059      swiper._clientLeft = swiper.wrapperEl.clientLeft;
2060      if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
2061        requestAnimationFrame(() => {
2062          swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2063        });
2064        return true;
2065      }
2066    }
2067    if (params.rewind && swiper.isEnd) {
2068      return swiper.slideTo(0, speed, runCallbacks, internal);
2069    }
2070    return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2071  }
2072
2073  /* eslint no-unused-vars: "off" */
2074  function slidePrev(speed, runCallbacks, internal) {
2075    if (speed === void 0) {
2076      speed = this.params.speed;
2077    }
2078    if (runCallbacks === void 0) {
2079      runCallbacks = true;
2080    }
2081    const swiper = this;
2082    const {
2083      params,
2084      snapGrid,
2085      slidesGrid,
2086      rtlTranslate,
2087      enabled,
2088      animating
2089    } = swiper;
2090    if (!enabled) return swiper;
2091    const isVirtual = swiper.virtual && params.virtual.enabled;
2092    if (params.loop) {
2093      if (animating && !isVirtual && params.loopPreventsSliding) return false;
2094      swiper.loopFix({
2095        direction: 'prev'
2096      });
2097      // eslint-disable-next-line
2098      swiper._clientLeft = swiper.wrapperEl.clientLeft;
2099    }
2100    const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2101    function normalize(val) {
2102      if (val < 0) return -Math.floor(Math.abs(val));
2103      return Math.floor(val);
2104    }
2105    const normalizedTranslate = normalize(translate);
2106    const normalizedSnapGrid = snapGrid.map(val => normalize(val));
2107    let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2108    if (typeof prevSnap === 'undefined' && params.cssMode) {
2109      let prevSnapIndex;
2110      snapGrid.forEach((snap, snapIndex) => {
2111        if (normalizedTranslate >= snap) {
2112          // prevSnap = snap;
2113          prevSnapIndex = snapIndex;
2114        }
2115      });
2116      if (typeof prevSnapIndex !== 'undefined') {
2117        prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2118      }
2119    }
2120    let prevIndex = 0;
2121    if (typeof prevSnap !== 'undefined') {
2122      prevIndex = slidesGrid.indexOf(prevSnap);
2123      if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2124      if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2125        prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2126        prevIndex = Math.max(prevIndex, 0);
2127      }
2128    }
2129    if (params.rewind && swiper.isBeginning) {
2130      const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2131      return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2132    } else if (params.loop && swiper.activeIndex === 0 && params.cssMode) {
2133      requestAnimationFrame(() => {
2134        swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2135      });
2136      return true;
2137    }
2138    return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2139  }
2140
2141  /* eslint no-unused-vars: "off" */
2142  function slideReset(speed, runCallbacks, internal) {
2143    if (speed === void 0) {
2144      speed = this.params.speed;
2145    }
2146    if (runCallbacks === void 0) {
2147      runCallbacks = true;
2148    }
2149    const swiper = this;
2150    return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2151  }
2152
2153  /* eslint no-unused-vars: "off" */
2154  function slideToClosest(speed, runCallbacks, internal, threshold) {
2155    if (speed === void 0) {
2156      speed = this.params.speed;
2157    }
2158    if (runCallbacks === void 0) {
2159      runCallbacks = true;
2160    }
2161    if (threshold === void 0) {
2162      threshold = 0.5;
2163    }
2164    const swiper = this;
2165    let index = swiper.activeIndex;
2166    const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2167    const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2168    const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2169    if (translate >= swiper.snapGrid[snapIndex]) {
2170      // The current translate is on or after the current snap index, so the choice
2171      // is between the current index and the one after it.
2172      const currentSnap = swiper.snapGrid[snapIndex];
2173      const nextSnap = swiper.snapGrid[snapIndex + 1];
2174      if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
2175        index += swiper.params.slidesPerGroup;
2176      }
2177    } else {
2178      // The current translate is before the current snap index, so the choice
2179      // is between the current index and the one before it.
2180      const prevSnap = swiper.snapGrid[snapIndex - 1];
2181      const currentSnap = swiper.snapGrid[snapIndex];
2182      if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
2183        index -= swiper.params.slidesPerGroup;
2184      }
2185    }
2186    index = Math.max(index, 0);
2187    index = Math.min(index, swiper.slidesGrid.length - 1);
2188    return swiper.slideTo(index, speed, runCallbacks, internal);
2189  }
2190
2191  function slideToClickedSlide() {
2192    const swiper = this;
2193    const {
2194      params,
2195      slidesEl
2196    } = swiper;
2197    const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2198    let slideToIndex = swiper.clickedIndex;
2199    let realIndex;
2200    const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2201    if (params.loop) {
2202      if (swiper.animating) return;
2203      realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
2204      if (params.centeredSlides) {
2205        if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2206          swiper.loopFix();
2207          slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2208          nextTick(() => {
2209            swiper.slideTo(slideToIndex);
2210          });
2211        } else {
2212          swiper.slideTo(slideToIndex);
2213        }
2214      } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2215        swiper.loopFix();
2216        slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2217        nextTick(() => {
2218          swiper.slideTo(slideToIndex);
2219        });
2220      } else {
2221        swiper.slideTo(slideToIndex);
2222      }
2223    } else {
2224      swiper.slideTo(slideToIndex);
2225    }
2226  }
2227
2228  var slide = {
2229    slideTo,
2230    slideToLoop,
2231    slideNext,
2232    slidePrev,
2233    slideReset,
2234    slideToClosest,
2235    slideToClickedSlide
2236  };
2237
2238  function loopCreate(slideRealIndex) {
2239    const swiper = this;
2240    const {
2241      params,
2242      slidesEl
2243    } = swiper;
2244    if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2245    const initSlides = () => {
2246      const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
2247      slides.forEach((el, index) => {
2248        el.setAttribute('data-swiper-slide-index', index);
2249      });
2250    };
2251    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2252    const slidesPerGroup = params.slidesPerGroup * (gridEnabled ? params.grid.rows : 1);
2253    const shouldFillGroup = swiper.slides.length % slidesPerGroup !== 0;
2254    const shouldFillGrid = gridEnabled && swiper.slides.length % params.grid.rows !== 0;
2255    const addBlankSlides = amountOfSlides => {
2256      for (let i = 0; i < amountOfSlides; i += 1) {
2257        const slideEl = swiper.isElement ? createElement('swiper-slide', [params.slideBlankClass]) : createElement('div', [params.slideClass, params.slideBlankClass]);
2258        swiper.slidesEl.append(slideEl);
2259      }
2260    };
2261    if (shouldFillGroup) {
2262      if (params.loopAddBlankSlides) {
2263        const slidesToAdd = slidesPerGroup - swiper.slides.length % slidesPerGroup;
2264        addBlankSlides(slidesToAdd);
2265        swiper.recalcSlides();
2266        swiper.updateSlides();
2267      } else {
2268        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)');
2269      }
2270      initSlides();
2271    } else if (shouldFillGrid) {
2272      if (params.loopAddBlankSlides) {
2273        const slidesToAdd = params.grid.rows - swiper.slides.length % params.grid.rows;
2274        addBlankSlides(slidesToAdd);
2275        swiper.recalcSlides();
2276        swiper.updateSlides();
2277      } else {
2278        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)');
2279      }
2280      initSlides();
2281    } else {
2282      initSlides();
2283    }
2284    swiper.loopFix({
2285      slideRealIndex,
2286      direction: params.centeredSlides ? undefined : 'next'
2287    });
2288  }
2289
2290  function loopFix(_temp) {
2291    let {
2292      slideRealIndex,
2293      slideTo = true,
2294      direction,
2295      setTranslate,
2296      activeSlideIndex,
2297      byController,
2298      byMousewheel
2299    } = _temp === void 0 ? {} : _temp;
2300    const swiper = this;
2301    if (!swiper.params.loop) return;
2302    swiper.emit('beforeLoopFix');
2303    const {
2304      slides,
2305      allowSlidePrev,
2306      allowSlideNext,
2307      slidesEl,
2308      params
2309    } = swiper;
2310    const {
2311      centeredSlides
2312    } = params;
2313    swiper.allowSlidePrev = true;
2314    swiper.allowSlideNext = true;
2315    if (swiper.virtual && params.virtual.enabled) {
2316      if (slideTo) {
2317        if (!params.centeredSlides && swiper.snapIndex === 0) {
2318          swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
2319        } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
2320          swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
2321        } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
2322          swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2323        }
2324      }
2325      swiper.allowSlidePrev = allowSlidePrev;
2326      swiper.allowSlideNext = allowSlideNext;
2327      swiper.emit('loopFix');
2328      return;
2329    }
2330    let slidesPerView = params.slidesPerView;
2331    if (slidesPerView === 'auto') {
2332      slidesPerView = swiper.slidesPerViewDynamic();
2333    } else {
2334      slidesPerView = Math.ceil(parseFloat(params.slidesPerView, 10));
2335      if (centeredSlides && slidesPerView % 2 === 0) {
2336        slidesPerView = slidesPerView + 1;
2337      }
2338    }
2339    const slidesPerGroup = params.slidesPerGroupAuto ? slidesPerView : params.slidesPerGroup;
2340    let loopedSlides = slidesPerGroup;
2341    if (loopedSlides % slidesPerGroup !== 0) {
2342      loopedSlides += slidesPerGroup - loopedSlides % slidesPerGroup;
2343    }
2344    loopedSlides += params.loopAdditionalSlides;
2345    swiper.loopedSlides = loopedSlides;
2346    const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2347    if (slides.length < slidesPerView + loopedSlides) {
2348      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');
2349    } else if (gridEnabled && params.grid.fill === 'row') {
2350      showWarning('Swiper Loop Warning: Loop mode is not compatible with grid.fill = `row`');
2351    }
2352    const prependSlidesIndexes = [];
2353    const appendSlidesIndexes = [];
2354    let activeIndex = swiper.activeIndex;
2355    if (typeof activeSlideIndex === 'undefined') {
2356      activeSlideIndex = swiper.getSlideIndex(slides.filter(el => el.classList.contains(params.slideActiveClass))[0]);
2357    } else {
2358      activeIndex = activeSlideIndex;
2359    }
2360    const isNext = direction === 'next' || !direction;
2361    const isPrev = direction === 'prev' || !direction;
2362    let slidesPrepended = 0;
2363    let slidesAppended = 0;
2364    const cols = gridEnabled ? Math.ceil(slides.length / params.grid.rows) : slides.length;
2365    const activeColIndex = gridEnabled ? slides[activeSlideIndex].column : activeSlideIndex;
2366    const activeColIndexWithShift = activeColIndex + (centeredSlides && typeof setTranslate === 'undefined' ? -slidesPerView / 2 + 0.5 : 0);
2367    // prepend last slides before start
2368    if (activeColIndexWithShift < loopedSlides) {
2369      slidesPrepended = Math.max(loopedSlides - activeColIndexWithShift, slidesPerGroup);
2370      for (let i = 0; i < loopedSlides - activeColIndexWithShift; i += 1) {

2371        const index = i - Math.floor(i / cols) * cols;
2372        if (gridEnabled) {
2373          const colIndexToPrepend = cols - index - 1;
2374          for (let i = slides.length - 1; i >= 0; i -= 1) {
2375            if (slides[i].column === colIndexToPrepend) prependSlidesIndexes.push(i);
2376          }
2377          // slides.forEach((slide, slideIndex) => {
2378          //   if (slide.column === colIndexToPrepend) prependSlidesIndexes.push(slideIndex);
2379          // });
2380        } else {
2381          prependSlidesIndexes.push(cols - index - 1);
2382        }
2383      }
2384    } else if (activeColIndexWithShift + slidesPerView > cols - loopedSlides) {
2385      slidesAppended = Math.max(activeColIndexWithShift - (cols - loopedSlides * 2), slidesPerGroup);
2386      for (let i = 0; i < slidesAppended; i += 1) {
2387        const index = i - Math.floor(i / cols) * cols;
2388        if (gridEnabled) {
2389          slides.forEach((slide, slideIndex) => {
2390            if (slide.column === index) appendSlidesIndexes.push(slideIndex);
2391          });
2392        } else {
2393          appendSlidesIndexes.push(index);
2394        }
2395      }
2396    }
2397    swiper.__preventObserver__ = true;
2398    requestAnimationFrame(() => {
2399      swiper.__preventObserver__ = false;
2400    });
2401    if (isPrev) {
2402      prependSlidesIndexes.forEach(index => {
2403        slides[index].swiperLoopMoveDOM = true;
2404        slidesEl.prepend(slides[index]);
2405        slides[index].swiperLoopMoveDOM = false;
2406      });
2407    }
2408    if (isNext) {
2409      appendSlidesIndexes.forEach(index => {
2410        slides[index].swiperLoopMoveDOM = true;
2411        slidesEl.append(slides[index]);
2412        slides[index].swiperLoopMoveDOM = false;
2413      });
2414    }
2415    swiper.recalcSlides();
2416    if (params.slidesPerView === 'auto') {
2417      swiper.updateSlides();
2418    } else if (gridEnabled && (prependSlidesIndexes.length > 0 && isPrev || appendSlidesIndexes.length > 0 && isNext)) {
2419      swiper.slides.forEach((slide, slideIndex) => {
2420        swiper.grid.updateSlide(slideIndex, slide, swiper.slides);
2421      });
2422    }
2423    if (params.watchSlidesProgress) {
2424      swiper.updateSlidesOffset();
2425    }
2426    if (slideTo) {
2427      if (prependSlidesIndexes.length > 0 && isPrev) {
2428        if (typeof slideRealIndex === 'undefined') {
2429          const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2430          const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2431          const diff = newSlideTranslate - currentSlideTranslate;
2432          if (byMousewheel) {
2433            swiper.setTranslate(swiper.translate - diff);
2434          } else {
2435            swiper.slideTo(activeIndex + slidesPrepended, 0, false, true);
2436            if (setTranslate) {
2437              swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2438              swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2439            }
2440          }
2441        } else {
2442          if (setTranslate) {
2443            const shift = gridEnabled ? prependSlidesIndexes.length / params.grid.rows : prependSlidesIndexes.length;
2444            swiper.slideTo(swiper.activeIndex + shift, 0, false, true);
2445            swiper.touchEventsData.currentTranslate = swiper.translate;
2446          }
2447        }
2448      } else if (appendSlidesIndexes.length > 0 && isNext) {
2449        if (typeof slideRealIndex === 'undefined') {
2450          const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2451          const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2452          const diff = newSlideTranslate - currentSlideTranslate;
2453          if (byMousewheel) {
2454            swiper.setTranslate(swiper.translate - diff);
2455          } else {
2456            swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2457            if (setTranslate) {
2458              swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2459              swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2460            }
2461          }
2462        } else {
2463          const shift = gridEnabled ? appendSlidesIndexes.length / params.grid.rows : appendSlidesIndexes.length;
2464          swiper.slideTo(swiper.activeIndex - shift, 0, false, true);
2465        }
2466      }
2467    }
2468    swiper.allowSlidePrev = allowSlidePrev;
2469    swiper.allowSlideNext = allowSlideNext;
2470    if (swiper.controller && swiper.controller.control && !byController) {
2471      const loopParams = {
2472        slideRealIndex,
2473        direction,
2474        setTranslate,
2475        activeSlideIndex,
2476        byController: true
2477      };
2478      if (Array.isArray(swiper.controller.control)) {
2479        swiper.controller.control.forEach(c => {
2480          if (!c.destroyed && c.params.loop) c.loopFix({
2481            ...loopParams,
2482            slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo : false
2483          });
2484        });
2485      } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
2486        swiper.controller.control.loopFix({
2487          ...loopParams,
2488          slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo : false
2489        });
2490      }
2491    }
2492    swiper.emit('loopFix');
2493  }
2494
2495  function loopDestroy() {
2496    const swiper = this;
2497    const {
2498      params,
2499      slidesEl
2500    } = swiper;
2501    if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2502    swiper.recalcSlides();
2503    const newSlidesOrder = [];

2504    swiper.slides.forEach(slideEl => {
2505      const index = typeof slideEl.swiperSlideIndex === 'undefined' ? slideEl.getAttribute('data-swiper-slide-index') * 1 : slideEl.swiperSlideIndex;
2506      newSlidesOrder[index] = slideEl;
2507    });
2508    swiper.slides.forEach(slideEl => {
2509      slideEl.removeAttribute('data-swiper-slide-index');
2510    });
2511    newSlidesOrder.forEach(slideEl => {
2512      slidesEl.append(slideEl);
2513    });
2514    swiper.recalcSlides();
2515    swiper.slideTo(swiper.realIndex, 0);
2516  }
2517
2518  var loop = {
2519    loopCreate,
2520    loopFix,
2521    loopDestroy
2522  };
2523
2524  function setGrabCursor(moving) {
2525    const swiper = this;
2526    if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
2527    const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
2528    if (swiper.isElement) {
2529      swiper.__preventObserver__ = true;
2530    }
2531    el.style.cursor = 'move';
2532    el.style.cursor = moving ? 'grabbing' : 'grab';
2533    if (swiper.isElement) {
2534      requestAnimationFrame(() => {
2535        swiper.__preventObserver__ = false;
2536      });
2537    }
2538  }
2539
2540  function unsetGrabCursor() {
2541    const swiper = this;
2542    if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
2543      return;
2544    }
2545    if (swiper.isElement) {
2546      swiper.__preventObserver__ = true;
2547    }
2548    swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
2549    if (swiper.isElement) {
2550      requestAnimationFrame(() => {
2551        swiper.__preventObserver__ = false;
2552      });
2553    }
2554  }
2555
2556  var grabCursor = {
2557    setGrabCursor,
2558    unsetGrabCursor
2559  };
2560
2561  // Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd
2562  function closestElement(selector, base) {
2563    if (base === void 0) {
2564      base = this;
2565    }
2566    function __closestFrom(el) {
2567      if (!el || el === getDocument() || el === getWindow()) return null;
2568      if (el.assignedSlot) el = el.assignedSlot;
2569      const found = el.closest(selector);
2570      if (!found && !el.getRootNode) {
2571        return null;
2572      }
2573      return found || __closestFrom(el.getRootNode().host);
2574    }
2575    return __closestFrom(base);
2576  }
2577  function preventEdgeSwipe(swiper, event, startX) {
2578    const window = getWindow();
2579    const {
2580      params
2581    } = swiper;
2582    const edgeSwipeDetection = params.edgeSwipeDetection;
2583    const edgeSwipeThreshold = params.edgeSwipeThreshold;
2584    if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
2585      if (edgeSwipeDetection === 'prevent') {
2586        event.preventDefault();
2587        return true;
2588      }
2589      return false;
2590    }
2591    return true;
2592  }
2593  function onTouchStart(event) {
2594    const swiper = this;
2595    const document = getDocument();
2596    let e = event;
2597    if (e.originalEvent) e = e.originalEvent;
2598    const data = swiper.touchEventsData;
2599    if (e.type === 'pointerdown') {
2600      if (data.pointerId !== null && data.pointerId !== e.pointerId) {
2601        return;
2602      }
2603      data.pointerId = e.pointerId;
2604    } else if (e.type === 'touchstart' && e.targetTouches.length === 1) {
2605      data.touchId = e.targetTouches[0].identifier;
2606    }
2607    if (e.type === 'touchstart') {
2608      // don't proceed touch event
2609      preventEdgeSwipe(swiper, e, e.targetTouches[0].pageX);
2610      return;
2611    }
2612    const {
2613      params,
2614      touches,
2615      enabled
2616    } = swiper;
2617    if (!enabled) return;
2618    if (!params.simulateTouch && e.pointerType === 'mouse') return;
2619    if (swiper.animating && params.preventInteractionOnTransition) {
2620      return;
2621    }
2622    if (!swiper.animating && params.cssMode && params.loop) {
2623      swiper.loopFix();
2624    }
2625    let targetEl = e.target;
2626    if (params.touchEventsTarget === 'wrapper') {
2627      if (!swiper.wrapperEl.contains(targetEl)) return;
2628    }
2629    if ('which' in e && e.which === 3) return;
2630    if ('button' in e && e.button > 0) return;
2631    if (data.isTouched && data.isMoved) return;
2632
2633    // change target el for shadow root component
2634    const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';
2635    // eslint-disable-next-line
2636    const eventPath = e.composedPath ? e.composedPath() : e.path;
2637    if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
2638      targetEl = eventPath[0];
2639    }
2640    const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2641    const isTargetShadow = !!(e.target && e.target.shadowRoot);
2642
2643    // use closestElement for shadow root element to get the actual closest for nested shadow root element
2644    if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {
2645      swiper.allowClick = true;
2646      return;
2647    }
2648    if (params.swipeHandler) {
2649      if (!targetEl.closest(params.swipeHandler)) return;
2650    }
2651    touches.currentX = e.pageX;
2652    touches.currentY = e.pageY;
2653    const startX = touches.currentX;
2654    const startY = touches.currentY;
2655
2656    // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
2657
2658    if (!preventEdgeSwipe(swiper, e, startX)) {
2659      return;
2660    }
2661    Object.assign(data, {
2662      isTouched: true,
2663      isMoved: false,
2664      allowTouchCallbacks: true,
2665      isScrolling: undefined,
2666      startMoving: undefined
2667    });
2668    touches.startX = startX;
2669    touches.startY = startY;