https://www.cht.com.tw/home/web/js/assets/home.1.js?v=39

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

190    delay = 0;
191  }
192  return setTimeout(callback, delay);
193}
194function now() {
195  return Date.now();
196}
197function getComputedStyle$1(el) {
198  const window = getWindow();
199  let style;
200  if (window.getComputedStyle) {
201    style = window.getComputedStyle(el, null);
202  }
203  if (!style && el.currentStyle) {
204    style = el.currentStyle;
205  }
206  if (!style) {
207    style = el.style;
208  }
209  return style;
210}
211function getTranslate(el, axis) {
212  if (axis === void 0) {
213    axis = 'x';
214  }
215  const window = getWindow();
216  let matrix;
217  let curTransform;
218  let transformMatrix;
219  const curStyle = getComputedStyle$1(el);
220  if (window.WebKitCSSMatrix) {
221    curTransform = curStyle.transform || curStyle.webkitTransform;
222    if (curTransform.split(',').length > 6) {
223      curTransform = curTransform
224        .split(', ')
225        .map((a) => a.replace(',', '.'))
226        .join(', ');
227    }
228    // Some old versions of Webkit choke when 'none' is passed; pass
229    // empty string instead in this case
230    transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
231  } else {
232    transformMatrix =
233      curStyle.MozTransform ||
234      curStyle.OTransform ||
235      curStyle.MsTransform ||
236      curStyle.msTransform ||
237      curStyle.transform ||
238      curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
239    matrix = transformMatrix.toString().split(',');
240  }
241  if (axis === 'x') {
242    // Latest Chrome and webkits Fix
243    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41;
244    // Crazy IE10 Matrix
245    else if (matrix.length === 16) curTransform = parseFloat(matrix[12]);
246    // Normal Browsers
247    else curTransform = parseFloat(matrix[4]);
248  }
249  if (axis === 'y') {
250    // Latest Chrome and webkits Fix
251    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42;
252    // Crazy IE10 Matrix
253    else if (matrix.length === 16) curTransform = parseFloat(matrix[13]);
254    // Normal Browsers
255    else curTransform = parseFloat(matrix[5]);
256  }
257  return curTransform || 0;
258}
259function isObject(o) {
260  return (
261    typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object'
262  );
263}
264function isNode(node) {
265  // eslint-disable-next-line
266  if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
267    return node instanceof HTMLElement;
268  }
269  return node && (node.nodeType === 1 || node.nodeType === 11);
270}
271function extend() {
272  const to = Object(arguments.length <= 0 ? undefined : arguments[0]);
273  const noExtend = ['__proto__', 'constructor', 'prototype'];
274  for (let i = 1; i < arguments.length; i += 1) {
275    const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
276    if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
277      const keysArray = Object.keys(Object(nextSource)).filter((key) => noExtend.indexOf(key) < 0);
278      for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
279        const nextKey = keysArray[nextIndex];
280        const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
281        if (desc !== undefined && desc.enumerable) {
282          if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
283            if (nextSource[nextKey].__swiper__) {
284              to[nextKey] = nextSource[nextKey];
285            } else {
286              extend(to[nextKey], nextSource[nextKey]);
287            }
288          } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
289            to[nextKey] = {};
290            if (nextSource[nextKey].__swiper__) {
291              to[nextKey] = nextSource[nextKey];
292            } else {
293              extend(to[nextKey], nextSource[nextKey]);
294            }
295          } else {
296            to[nextKey] = nextSource[nextKey];
297          }
298        }
299      }
300    }
301  }
302  return to;
303}
304function setCSSProperty(el, varName, varValue) {
305  el.style.setProperty(varName, varValue);
306}
307function animateCSSModeScroll(_ref) {
308  let { swiper, targetPosition, side } = _ref;
309  const window = getWindow();
310  const startPosition = -swiper.translate;
311  let startTime = null;
312  let time;
313  const duration = swiper.params.speed;
314  swiper.wrapperEl.style.scrollSnapType = 'none';
315  window.cancelAnimationFrame(swiper.cssModeFrameID);
316  const dir = targetPosition > startPosition ? 'next' : 'prev';
317  const isOutOfBound = (current, target) => {
318    return (dir === 'next' && current >= target) || (dir === 'prev' && current <= target);
319  };
320  const animate = () => {
321    time = new Date().getTime();
322    if (startTime === null) {
323      startTime = time;
324    }
325    const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
326    const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;

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

995  }
996  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
997  if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
998    wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
999  }
1000  if (params.setWrapperSize) {
1001    wrapperEl.style[getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;
1002  }
1003  if (gridEnabled) {
1004    swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);
1005  }
1006
1007  // Remove last grid elements depending on width
1008  if (!params.centeredSlides) {
1009    const newSlidesGrid = [];
1010    for (let i = 0; i < snapGrid.length; i += 1) {
1011      let slidesGridItem = snapGrid[i];
1012      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1013      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1014        newSlidesGrid.push(slidesGridItem);
1015      }
1016    }
1017    snapGrid = newSlidesGrid;
1018    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1019      snapGrid.push(swiper.virtualSize - swiperSize);
1020    }
1021  }
1022  if (isVirtual && params.loop) {
1023    const size = slidesSizesGrid[0] + spaceBetween;
1024    if (params.slidesPerGroup > 1) {
1025      const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
1026      const groupSize = size * params.slidesPerGroup;
1027      for (let i = 0; i < groups; i += 1) {
1028        snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1029      }
1030    }
1031    for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1032      if (params.slidesPerGroup === 1) {
1033        snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1034      }
1035      slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1036      swiper.virtualSize += size;
1037    }
1038  }
1039  if (snapGrid.length === 0) snapGrid = [0];

1040  if (spaceBetween !== 0) {
1041    const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');
1042    slides
1043      .filter((_, slideIndex) => {
1044        if (!params.cssMode || params.loop) return true;
1045        if (slideIndex === slides.length - 1) {
1046          return false;
1047        }
1048        return true;
1049      })
1050      .forEach((slideEl) => {
1051        slideEl.style[key] = `${spaceBetween}px`;
1052      });
1053  }
1054  if (params.centeredSlides && params.centeredSlidesBounds) {
1055    let allSlidesSize = 0;
1056    slidesSizesGrid.forEach((slideSizeValue) => {
1057      allSlidesSize += slideSizeValue + (spaceBetween || 0);
1058    });
1059    allSlidesSize -= spaceBetween;
1060    const maxSnap = allSlidesSize - swiperSize;
1061    snapGrid = snapGrid.map((snap) => {
1062      if (snap <= 0) return -offsetBefore;
1063      if (snap > maxSnap) return maxSnap + offsetAfter;
1064      return snap;
1065    });
1066  }
1067  if (params.centerInsufficientSlides) {
1068    let allSlidesSize = 0;
1069    slidesSizesGrid.forEach((slideSizeValue) => {
1070      allSlidesSize += slideSizeValue + (spaceBetween || 0);
1071    });
1072    allSlidesSize -= spaceBetween;
1073    if (allSlidesSize < swiperSize) {
1074      const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1075      snapGrid.forEach((snap, snapIndex) => {
1076        snapGrid[snapIndex] = snap - allSlidesOffset;
1077      });
1078      slidesGrid.forEach((snap, snapIndex) => {
1079        slidesGrid[snapIndex] = snap + allSlidesOffset;
1080      });
1081    }
1082  }
1083  Object.assign(swiper, {
1084    slides,
1085    snapGrid,
1086    slidesGrid,
1087    slidesSizesGrid,
1088  });
1089  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1090    setCSSProperty(wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
1091    setCSSProperty(
1092      wrapperEl,
1093      '--swiper-centered-offset-after',
1094      `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`
1095    );
1096    const addToSnapGrid = -swiper.snapGrid[0];
1097    const addToSlidesGrid = -swiper.slidesGrid[0];
1098    swiper.snapGrid = swiper.snapGrid.map((v) => v + addToSnapGrid);
1099    swiper.slidesGrid = swiper.slidesGrid.map((v) => v + addToSlidesGrid);
1100  }
1101  if (slidesLength !== previousSlidesLength) {
1102    swiper.emit('slidesLengthChange');
1103  }
1104  if (snapGrid.length !== previousSnapGridLength) {
1105    if (swiper.params.watchOverflow) swiper.checkOverflow();
1106    swiper.emit('snapGridLengthChange');
1107  }
1108  if (slidesGrid.length !== previousSlidesGridLength) {
1109    swiper.emit('slidesGridLengthChange');
1110  }
1111  if (params.watchSlidesProgress) {
1112    swiper.updateSlidesOffset();
1113  }
1114  if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1115    const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1116    const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1117    if (slidesLength <= params.maxBackfaceHiddenSlides) {
1118      if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1119    } else if (hasClassBackfaceClassAdded) {
1120      swiper.el.classList.remove(backFaceHiddenClass);
1121    }
1122  }
1123}
1124
1125function updateAutoHeight(speed) {
1126  const swiper = this;
1127  const activeSlides = [];
1128  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1129  let newHeight = 0;
1130  let i;
1131  if (typeof speed === 'number') {
1132    swiper.setTransition(speed);
1133  } else if (speed === true) {
1134    swiper.setTransition(swiper.params.speed);
1135  }
1136  const getSlideByIndex = (index) => {
1137    if (isVirtual) {
1138      return swiper.slides[swiper.getSlideIndexByData(index)];
1139    }
1140    return swiper.slides[index];
1141  };
1142  // Find slides currently in view
1143  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1144    if (swiper.params.centeredSlides) {
1145      (swiper.visibleSlides || []).forEach((slide) => {
1146        activeSlides.push(slide);
1147      });
1148    } else {
1149      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1150        const index = swiper.activeIndex + i;
1151        if (index > swiper.slides.length && !isVirtual) break;
1152        activeSlides.push(getSlideByIndex(index));
1153      }
1154    }
1155  } else {
1156    activeSlides.push(getSlideByIndex(swiper.activeIndex));
1157  }
1158
1159  // Find new height from highest slide in view
1160  for (i = 0; i < activeSlides.length; i += 1) {
1161    if (typeof activeSlides[i] !== 'undefined') {
1162      const height = activeSlides[i].offsetHeight;
1163      newHeight = height > newHeight ? height : newHeight;
1164    }
1165  }
1166
1167  // Update Height
1168  if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;
1169}
1170
1171function updateSlidesOffset() {
1172  const swiper = this;
1173  const slides = swiper.slides;
1174  // eslint-disable-next-line
1175  const minusOffset = swiper.isElement
1176    ? swiper.isHorizontal()
1177      ? swiper.wrapperEl.offsetLeft
1178      : swiper.wrapperEl.offsetTop
1179    : 0;
1180  for (let i = 0; i < slides.length; i += 1) {
1181    slides[i].swiperSlideOffset =
1182      (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) -
1183      minusOffset -
1184      swiper.cssOverflowAdjustment();
1185  }
1186}
1187
1188function updateSlidesProgress(translate) {
1189  if (translate === void 0) {
1190    translate = (this && this.translate) || 0;
1191  }
1192  const swiper = this;
1193  const params = swiper.params;
1194  const { slides, rtlTranslate: rtl, snapGrid } = swiper;
1195  if (slides.length === 0) return;
1196  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
1197  let offsetCenter = -translate;
1198  if (rtl) offsetCenter = translate;
1199
1200  // Visible Slides
1201  slides.forEach((slideEl) => {
1202    slideEl.classList.remove(params.slideVisibleClass);
1203  });
1204  swiper.visibleSlidesIndexes = [];
1205  swiper.visibleSlides = [];
1206  let spaceBetween = params.spaceBetween;
1207  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1208    spaceBetween = (parseFloat(spaceBetween.replace('%', '')) / 100) * swiper.size;
1209  } else if (typeof spaceBetween === 'string') {
1210    spaceBetween = parseFloat(spaceBetween);
1211  }
1212  for (let i = 0; i < slides.length; i += 1) {
1213    const slide = slides[i];
1214    let slideOffset = slide.swiperSlideOffset;
1215    if (params.cssMode && params.centeredSlides) {
1216      slideOffset -= slides[0].swiperSlideOffset;
1217    }
1218    const slideProgress =
1219      (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) /
1220      (slide.swiperSlideSize + spaceBetween);
1221    const originalSlideProgress =
1222      (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) /
1223      (slide.swiperSlideSize + spaceBetween);
1224    const slideBefore = -(offsetCenter - slideOffset);
1225    const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1226    const isVisible =
1227      (slideBefore >= 0 && slideBefore < swiper.size - 1) ||
1228      (slideAfter > 1 && slideAfter <= swiper.size) ||
1229      (slideBefore <= 0 && slideAfter >= swiper.size);
1230    if (isVisible) {
1231      swiper.visibleSlides.push(slide);
1232      swiper.visibleSlidesIndexes.push(i);
1233      slides[i].classList.add(params.slideVisibleClass);
1234    }
1235    slide.progress = rtl ? -slideProgress : slideProgress;
1236    slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1237  }
1238}
1239
1240function updateProgress(translate) {
1241  const swiper = this;
1242  if (typeof translate === 'undefined') {
1243    const multiplier = swiper.rtlTranslate ? -1 : 1;
1244    // eslint-disable-next-line
1245    translate = (swiper && swiper.translate && swiper.translate * multiplier) || 0;
1246  }
1247  const params = swiper.params;
1248  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1249  let { progress, isBeginning, isEnd, progressLoop } = swiper;
1250  const wasBeginning = isBeginning;
1251  const wasEnd = isEnd;
1252  if (translatesDiff === 0) {
1253    progress = 0;
1254    isBeginning = true;
1255    isEnd = true;
1256  } else {
1257    progress = (translate - swiper.minTranslate()) / translatesDiff;
1258    const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;
1259    const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;
1260    isBeginning = isBeginningRounded || progress <= 0;
1261    isEnd = isEndRounded || progress >= 1;
1262    if (isBeginningRounded) progress = 0;
1263    if (isEndRounded) progress = 1;
1264  }
1265  if (params.loop) {
1266    const firstSlideIndex = swiper.getSlideIndexByData(0);
1267    const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1268    const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1269    const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1270    const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1271    const translateAbs = Math.abs(translate);
1272    if (translateAbs >= firstSlideTranslate) {
1273      progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
1274    } else {
1275      progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1276    }
1277    if (progressLoop > 1) progressLoop -= 1;
1278  }
1279  Object.assign(swiper, {
1280    progress,
1281    progressLoop,
1282    isBeginning,
1283    isEnd,
1284  });
1285  if (params.watchSlidesProgress || (params.centeredSlides && params.autoHeight))
1286    swiper.updateSlidesProgress(translate);
1287  if (isBeginning && !wasBeginning) {
1288    swiper.emit('reachBeginning toEdge');
1289  }
1290  if (isEnd && !wasEnd) {
1291    swiper.emit('reachEnd toEdge');
1292  }

1293  if ((wasBeginning && !isBeginning) || (wasEnd && !isEnd)) {
1294    swiper.emit('fromEdge');
1295  }
1296  swiper.emit('progress', progress);
1297}
1298
1299function updateSlidesClasses() {
1300  const swiper = this;
1301  const { slides, params, slidesEl, activeIndex } = swiper;
1302  const isVirtual = swiper.virtual && params.virtual.enabled;
1303  const getFilteredSlide = (selector) => {
1304    return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1305  };
1306  slides.forEach((slideEl) => {
1307    slideEl.classList.remove(params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
1308  });
1309  let activeSlide;
1310  if (isVirtual) {
1311    if (params.loop) {
1312      let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1313      if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1314      if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1315      activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1316    } else {
1317      activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1318    }
1319  } else {
1320    activeSlide = slides[activeIndex];
1321  }
1322  if (activeSlide) {
1323    // Active classes
1324    activeSlide.classList.add(params.slideActiveClass);
1325
1326    // Next Slide
1327    let nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1328    if (params.loop && !nextSlide) {
1329      nextSlide = slides[0];
1330    }
1331    if (nextSlide) {
1332      nextSlide.classList.add(params.slideNextClass);
1333    }
1334    // Prev Slide
1335    let prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1336    if (params.loop && !prevSlide === 0) {
1337      prevSlide = slides[slides.length - 1];
1338    }
1339    if (prevSlide) {
1340      prevSlide.classList.add(params.slidePrevClass);
1341    }
1342  }
1343  swiper.emitSlidesClasses();
1344}
1345
1346const processLazyPreloader = (swiper, imageEl) => {
1347  if (!swiper || swiper.destroyed || !swiper.params) return;
1348  const slideSelector = () => (swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`);
1349  const slideEl = imageEl.closest(slideSelector());
1350  if (slideEl) {
1351    const lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1352    if (lazyEl) lazyEl.remove();
1353  }
1354};
1355const unlazy = (swiper, index) => {
1356  if (!swiper.slides[index]) return;
1357  const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1358  if (imageEl) imageEl.removeAttribute('loading');
1359};
1360const preload = (swiper) => {
1361  if (!swiper || swiper.destroyed || !swiper.params) return;
1362  let amount = swiper.params.lazyPreloadPrevNext;
1363  const len = swiper.slides.length;
1364  if (!len || !amount || amount < 0) return;
1365  amount = Math.min(amount, len);
1366  const slidesPerView =
1367    swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1368  const activeIndex = swiper.activeIndex;
1369  if (swiper.params.grid && swiper.params.grid.rows > 1) {
1370    const activeColumn = activeIndex;
1371    const preloadColumns = [activeColumn - amount];
1372    preloadColumns.push(
1373      ...Array.from({
1374        length: amount,
1375      }).map((_, i) => {
1376        return activeColumn + slidesPerView + i;
1377      })
1378    );
1379    swiper.slides.forEach((slideEl, i) => {
1380      if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1381    });
1382    return;
1383  }
1384  const slideIndexLastInView = activeIndex + slidesPerView - 1;
1385  if (swiper.params.rewind || swiper.params.loop) {
1386    for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1387      const realIndex = ((i % len) + len) % len;
1388      if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1389    }
1390  } else {
1391    for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1392      if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1393        unlazy(swiper, i);
1394      }
1395    }
1396  }
1397};
1398
1399function getActiveIndexByTranslate(swiper) {
1400  const { slidesGrid, params } = swiper;
1401  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1402  let activeIndex;
1403  for (let i = 0; i < slidesGrid.length; i += 1) {
1404    if (typeof slidesGrid[i + 1] !== 'undefined') {
1405      if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1406        activeIndex = i;
1407      } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1408        activeIndex = i + 1;
1409      }
1410    } else if (translate >= slidesGrid[i]) {
1411      activeIndex = i;
1412    }
1413  }
1414  // Normalize slideIndex
1415  if (params.normalizeSlideIndex) {
1416    if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1417  }
1418  return activeIndex;
1419}
1420function updateActiveIndex(newActiveIndex) {
1421  const swiper = this;
1422  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1423  const {
1424    snapGrid,
1425    params,
1426    activeIndex: previousIndex,
1427    realIndex: previousRealIndex,
1428    snapIndex: previousSnapIndex,
1429  } = swiper;
1430  let activeIndex = newActiveIndex;
1431  let snapIndex;
1432  const getVirtualRealIndex = (aIndex) => {
1433    let realIndex = aIndex - swiper.virtual.slidesBefore;
1434    if (realIndex < 0) {
1435      realIndex = swiper.virtual.slides.length + realIndex;
1436    }
1437    if (realIndex >= swiper.virtual.slides.length) {
1438      realIndex -= swiper.virtual.slides.length;
1439    }
1440    return realIndex;
1441  };
1442  if (typeof activeIndex === 'undefined') {
1443    activeIndex = getActiveIndexByTranslate(swiper);
1444  }
1445  if (snapGrid.indexOf(translate) >= 0) {
1446    snapIndex = snapGrid.indexOf(translate);
1447  } else {
1448    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1449    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1450  }
1451  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1452  if (activeIndex === previousIndex) {
1453    if (snapIndex !== previousSnapIndex) {
1454      swiper.snapIndex = snapIndex;
1455      swiper.emit('snapIndexChange');
1456    }
1457    if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1458      swiper.realIndex = getVirtualRealIndex(activeIndex);
1459    }
1460    return;
1461  }
1462  // Get real index
1463  let realIndex;
1464  if (swiper.virtual && params.virtual.enabled && params.loop) {
1465    realIndex = getVirtualRealIndex(activeIndex);
1466  } else if (swiper.slides[activeIndex]) {
1467    realIndex = parseInt(swiper.slides[activeIndex].getAttribute('data-swiper-slide-index') || activeIndex, 10);
1468  } else {
1469    realIndex = activeIndex;
1470  }
1471  Object.assign(swiper, {
1472    previousSnapIndex,
1473    snapIndex,
1474    previousRealIndex,
1475    realIndex,
1476    previousIndex,
1477    activeIndex,
1478  });
1479  if (swiper.initialized) {
1480    preload(swiper);
1481  }
1482  swiper.emit('activeIndexChange');
1483  swiper.emit('snapIndexChange');
1484  if (previousRealIndex !== realIndex) {
1485    swiper.emit('realIndexChange');
1486  }
1487  if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1488    swiper.emit('slideChange');
1489  }
1490}
1491
1492function updateClickedSlide(e) {
1493  const swiper = this;
1494  const params = swiper.params;
1495  const slide = e.closest(`.${params.slideClass}, swiper-slide`);
1496  let slideFound = false;
1497  let slideIndex;
1498  if (slide) {
1499    for (let i = 0; i < swiper.slides.length; i += 1) {
1500      if (swiper.slides[i] === slide) {
1501        slideFound = true;
1502        slideIndex = i;
1503        break;
1504      }
1505    }
1506  }
1507  if (slide && slideFound) {
1508    swiper.clickedSlide = slide;
1509    if (swiper.virtual && swiper.params.virtual.enabled) {
1510      swiper.clickedIndex = parseInt(slide.getAttribute('data-swiper-slide-index'), 10);
1511    } else {
1512      swiper.clickedIndex = slideIndex;
1513    }
1514  } else {
1515    swiper.clickedSlide = undefined;
1516    swiper.clickedIndex = undefined;
1517    return;
1518  }
1519  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1520    swiper.slideToClickedSlide();
1521  }
1522}
1523
1524var update = {
1525  updateSize,
1526  updateSlides,
1527  updateAutoHeight,
1528  updateSlidesOffset,
1529  updateSlidesProgress,
1530  updateProgress,
1531  updateSlidesClasses,
1532  updateActiveIndex,
1533  updateClickedSlide,
1534};
1535
1536function getSwiperTranslate(axis) {
1537  if (axis === void 0) {
1538    axis = this.isHorizontal() ? 'x' : 'y';
1539  }
1540  const swiper = this;
1541  const { params, rtlTranslate: rtl, translate, wrapperEl } = swiper;
1542  if (params.virtualTranslate) {
1543    return rtl ? -translate : translate;
1544  }
1545  if (params.cssMode) {
1546    return translate;
1547  }
1548  let currentTranslate = getTranslate(wrapperEl, axis);

1549  currentTranslate += swiper.cssOverflowAdjustment();
1550  if (rtl) currentTranslate = -currentTranslate;
1551  return currentTranslate || 0;
1552}
1553
1554function setTranslate(translate, byController) {
1555  const swiper = this;
1556  const { rtlTranslate: rtl, params, wrapperEl, progress } = swiper;
1557  let x = 0;
1558  let y = 0;
1559  const z = 0;
1560  if (swiper.isHorizontal()) {
1561    x = rtl ? -translate : translate;
1562  } else {
1563    y = translate;
1564  }
1565  if (params.roundLengths) {
1566    x = Math.floor(x);
1567    y = Math.floor(y);
1568  }
1569  swiper.previousTranslate = swiper.translate;
1570  swiper.translate = swiper.isHorizontal() ? x : y;
1571  if (params.cssMode) {
1572    wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
1573  } else if (!params.virtualTranslate) {
1574    if (swiper.isHorizontal()) {
1575      x -= swiper.cssOverflowAdjustment();
1576    } else {
1577      y -= swiper.cssOverflowAdjustment();
1578    }
1579    wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1580  }
1581
1582  // Check if we need to update progress
1583  let newProgress;
1584  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1585  if (translatesDiff === 0) {
1586    newProgress = 0;
1587  } else {
1588    newProgress = (translate - swiper.minTranslate()) / translatesDiff;
1589  }
1590  if (newProgress !== progress) {
1591    swiper.updateProgress(translate);
1592  }
1593  swiper.emit('setTranslate', swiper.translate, byController);
1594}
1595
1596function minTranslate() {
1597  return -this.snapGrid[0];
1598}
1599
1600function maxTranslate() {
1601  return -this.snapGrid[this.snapGrid.length - 1];
1602}
1603
1604function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
1605  if (translate === void 0) {
1606    translate = 0;
1607  }
1608  if (speed === void 0) {
1609    speed = this.params.speed;
1610  }
1611  if (runCallbacks === void 0) {
1612    runCallbacks = true;
1613  }
1614  if (translateBounds === void 0) {
1615    translateBounds = true;
1616  }
1617  const swiper = this;
1618  const { params, wrapperEl } = swiper;
1619  if (swiper.animating && params.preventInteractionOnTransition) {
1620    return false;
1621  }
1622  const minTranslate = swiper.minTranslate();
1623  const maxTranslate = swiper.maxTranslate();
1624  let newTranslate;
1625  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;
1626  else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;
1627  else newTranslate = translate;
1628
1629  // Update progress
1630  swiper.updateProgress(newTranslate);
1631  if (params.cssMode) {
1632    const isH = swiper.isHorizontal();
1633    if (speed === 0) {
1634      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1635    } else {
1636      if (!swiper.support.smoothScroll) {
1637        animateCSSModeScroll({
1638          swiper,
1639          targetPosition: -newTranslate,
1640          side: isH ? 'left' : 'top',
1641        });
1642        return true;
1643      }
1644      wrapperEl.scrollTo({
1645        [isH ? 'left' : 'top']: -newTranslate,
1646        behavior: 'smooth',
1647      });
1648    }
1649    return true;
1650  }
1651  if (speed === 0) {
1652    swiper.setTransition(0);
1653    swiper.setTranslate(newTranslate);
1654    if (runCallbacks) {
1655      swiper.emit('beforeTransitionStart', speed, internal);
1656      swiper.emit('transitionEnd');
1657    }
1658  } else {
1659    swiper.setTransition(speed);
1660    swiper.setTranslate(newTranslate);
1661    if (runCallbacks) {
1662      swiper.emit('beforeTransitionStart', speed, internal);
1663      swiper.emit('transitionStart');
1664    }
1665    if (!swiper.animating) {
1666      swiper.animating = true;
1667      if (!swiper.onTranslateToWrapperTransitionEnd) {
1668        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1669          if (!swiper || swiper.destroyed) return;
1670          if (e.target !== this) return;
1671          swiper.wrapperEl.removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1672          swiper.onTranslateToWrapperTransitionEnd = null;
1673          delete swiper.onTranslateToWrapperTransitionEnd;
1674          if (runCallbacks) {
1675            swiper.emit('transitionEnd');
1676          }
1677        };
1678      }
1679      swiper.wrapperEl.addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1680    }
1681  }
1682  return true;
1683}
1684
1685var translate = {
1686  getTranslate: getSwiperTranslate,
1687  setTranslate,
1688  minTranslate,
1689  maxTranslate,
1690  translateTo,
1691};
1692
1693function setTransition(duration, byController) {
1694  const swiper = this;
1695  if (!swiper.params.cssMode) {
1696    swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
1697  }
1698  swiper.emit('setTransition', duration, byController);
1699}
1700
1701function transitionEmit(_ref) {
1702  let { swiper, runCallbacks, direction, step } = _ref;
1703  const { activeIndex, previousIndex } = swiper;
1704  let dir = direction;
1705  if (!dir) {
1706    if (activeIndex > previousIndex) dir = 'next';
1707    else if (activeIndex < previousIndex) dir = 'prev';
1708    else dir = 'reset';
1709  }
1710  swiper.emit(`transition${step}`);
1711  if (runCallbacks && activeIndex !== previousIndex) {
1712    if (dir === 'reset') {
1713      swiper.emit(`slideResetTransition${step}`);
1714      return;
1715    }
1716    swiper.emit(`slideChangeTransition${step}`);
1717    if (dir === 'next') {
1718      swiper.emit(`slideNextTransition${step}`);
1719    } else {
1720      swiper.emit(`slidePrevTransition${step}`);
1721    }
1722  }
1723}
1724
1725function transitionStart(runCallbacks, direction) {
1726  if (runCallbacks === void 0) {
1727    runCallbacks = true;
1728  }
1729  const swiper = this;
1730  const { params } = swiper;
1731  if (params.cssMode) return;
1732  if (params.autoHeight) {
1733    swiper.updateAutoHeight();
1734  }
1735  transitionEmit({
1736    swiper,
1737    runCallbacks,
1738    direction,
1739    step: 'Start',
1740  });
1741}
1742
1743function transitionEnd(runCallbacks, direction) {
1744  if (runCallbacks === void 0) {
1745    runCallbacks = true;
1746  }
1747  const swiper = this;
1748  const { params } = swiper;
1749  swiper.animating = false;
1750  if (params.cssMode) return;
1751  swiper.setTransition(0);
1752  transitionEmit({
1753    swiper,
1754    runCallbacks,
1755    direction,
1756    step: 'End',
1757  });
1758}
1759
1760var transition = {
1761  setTransition,
1762  transitionStart,
1763  transitionEnd,
1764};
1765
1766function slideTo(index, speed, runCallbacks, internal, initial) {
1767  if (index === void 0) {
1768    index = 0;
1769  }
1770  if (speed === void 0) {
1771    speed = this.params.speed;
1772  }
1773  if (runCallbacks === void 0) {
1774    runCallbacks = true;
1775  }
1776  if (typeof index === 'string') {
1777    index = parseInt(index, 10);
1778  }
1779  const swiper = this;
1780  let slideIndex = index;
1781  if (slideIndex < 0) slideIndex = 0;
1782  const { params, snapGrid, slidesGrid, previousIndex, activeIndex, rtlTranslate: rtl, wrapperEl, enabled } = swiper;
1783  if ((swiper.animating && params.preventInteractionOnTransition) || (!enabled && !internal && !initial)) {
1784    return false;
1785  }
1786  const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
1787  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
1788  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1789  const translate = -snapGrid[snapIndex];
1790  // Normalize slideIndex
1791  if (params.normalizeSlideIndex) {
1792    for (let i = 0; i < slidesGrid.length; i += 1) {
1793      const normalizedTranslate = -Math.floor(translate * 100);
1794      const normalizedGrid = Math.floor(slidesGrid[i] * 100);
1795      const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
1796      if (typeof slidesGrid[i + 1] !== 'undefined') {
1797        if (
1798          normalizedTranslate >= normalizedGrid &&
1799          normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2
1800        ) {
1801          slideIndex = i;
1802        } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
1803          slideIndex = i + 1;
1804        }
1805      } else if (normalizedTranslate >= normalizedGrid) {
1806        slideIndex = i;
1807      }
1808    }
1809  }
1810  // Directions locks
1811  if (swiper.initialized && slideIndex !== activeIndex) {
1812    if (
1813      !swiper.allowSlideNext &&
1814      (rtl
1815        ? translate > swiper.translate && translate > swiper.minTranslate()
1816        : translate < swiper.translate && translate < swiper.minTranslate())
1817    ) {
1818      return false;
1819    }
1820    if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
1821      if ((activeIndex || 0) !== slideIndex) {
1822        return false;
1823      }
1824    }
1825  }
1826  if (slideIndex !== (previousIndex || 0) && runCallbacks) {
1827    swiper.emit('beforeSlideChangeStart');
1828  }
1829
1830  // Update progress
1831  swiper.updateProgress(translate);
1832  let direction;
1833  if (slideIndex > activeIndex) direction = 'next';
1834  else if (slideIndex < activeIndex) direction = 'prev';
1835  else direction = 'reset';
1836
1837  // Update Index
1838  if ((rtl && -translate === swiper.translate) || (!rtl && translate === swiper.translate)) {
1839    swiper.updateActiveIndex(slideIndex);
1840    // Update Height
1841    if (params.autoHeight) {
1842      swiper.updateAutoHeight();
1843    }
1844    swiper.updateSlidesClasses();
1845    if (params.effect !== 'slide') {
1846      swiper.setTranslate(translate);
1847    }
1848    if (direction !== 'reset') {
1849      swiper.transitionStart(runCallbacks, direction);
1850      swiper.transitionEnd(runCallbacks, direction);
1851    }
1852    return false;
1853  }
1854  if (params.cssMode) {
1855    const isH = swiper.isHorizontal();
1856    const t = rtl ? translate : -translate;
1857    if (speed === 0) {
1858      const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1859      if (isVirtual) {
1860        swiper.wrapperEl.style.scrollSnapType = 'none';
1861        swiper._immediateVirtual = true;
1862      }
1863      if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
1864        swiper._cssModeVirtualInitialSet = true;
1865        requestAnimationFrame(() => {
1866          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1867        });
1868      } else {
1869        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1870      }
1871      if (isVirtual) {
1872        requestAnimationFrame(() => {
1873          swiper.wrapperEl.style.scrollSnapType = '';
1874          swiper._immediateVirtual = false;
1875        });
1876      }
1877    } else {
1878      if (!swiper.support.smoothScroll) {
1879        animateCSSModeScroll({
1880          swiper,
1881          targetPosition: t,
1882          side: isH ? 'left' : 'top',
1883        });
1884        return true;
1885      }
1886      wrapperEl.scrollTo({
1887        [isH ? 'left' : 'top']: t,
1888        behavior: 'smooth',
1889      });
1890    }
1891    return true;
1892  }
1893  swiper.setTransition(speed);
1894  swiper.setTranslate(translate);
1895  swiper.updateActiveIndex(slideIndex);
1896  swiper.updateSlidesClasses();
1897  swiper.emit('beforeTransitionStart', speed, internal);
1898  swiper.transitionStart(runCallbacks, direction);
1899  if (speed === 0) {
1900    swiper.transitionEnd(runCallbacks, direction);
1901  } else if (!swiper.animating) {
1902    swiper.animating = true;
1903    if (!swiper.onSlideToWrapperTransitionEnd) {
1904      swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
1905        if (!swiper || swiper.destroyed) return;
1906        if (e.target !== this) return;
1907        swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1908        swiper.onSlideToWrapperTransitionEnd = null;
1909        delete swiper.onSlideToWrapperTransitionEnd;
1910        swiper.transitionEnd(runCallbacks, direction);
1911      };
1912    }
1913    swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1914  }
1915  return true;
1916}
1917
1918function slideToLoop(index, speed, runCallbacks, internal) {
1919  if (index === void 0) {
1920    index = 0;
1921  }
1922  if (speed === void 0) {
1923    speed = this.params.speed;
1924  }
1925  if (runCallbacks === void 0) {
1926    runCallbacks = true;
1927  }
1928  if (typeof index === 'string') {
1929    const indexAsNumber = parseInt(index, 10);
1930    index = indexAsNumber;
1931  }
1932  const swiper = this;
1933  let newIndex = index;
1934  if (swiper.params.loop) {
1935    if (swiper.virtual && swiper.params.virtual.enabled) {
1936      // eslint-disable-next-line
1937      newIndex = newIndex + swiper.virtual.slidesBefore;
1938    } else {
1939      newIndex = swiper.getSlideIndexByData(newIndex);
1940    }
1941  }
1942  return swiper.slideTo(newIndex, speed, runCallbacks, internal);
1943}
1944
1945/* eslint no-unused-vars: "off" */
1946function slideNext(speed, runCallbacks, internal) {
1947  if (speed === void 0) {
1948    speed = this.params.speed;
1949  }
1950  if (runCallbacks === void 0) {
1951    runCallbacks = true;
1952  }
1953  const swiper = this;
1954  const { enabled, params, animating } = swiper;
1955  if (!enabled) return swiper;
1956  let perGroup = params.slidesPerGroup;
1957  if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
1958    perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
1959  }
1960  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;

1961  const isVirtual = swiper.virtual && params.virtual.enabled;
1962  if (params.loop) {
1963    if (animating && !isVirtual && params.loopPreventsSliding) return false;
1964    swiper.loopFix({
1965      direction: 'next',
1966    });
1967    // eslint-disable-next-line
1968    swiper._clientLeft = swiper.wrapperEl.clientLeft;
1969  }
1970  if (params.rewind && swiper.isEnd) {
1971    return swiper.slideTo(0, speed, runCallbacks, internal);
1972  }
1973  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
1974}
1975
1976/* eslint no-unused-vars: "off" */
1977function slidePrev(speed, runCallbacks, internal) {
1978  if (speed === void 0) {
1979    speed = this.params.speed;
1980  }
1981  if (runCallbacks === void 0) {
1982    runCallbacks = true;
1983  }
1984  const swiper = this;
1985  const { params, snapGrid, slidesGrid, rtlTranslate, enabled, animating } = swiper;
1986  if (!enabled) return swiper;
1987  const isVirtual = swiper.virtual && params.virtual.enabled;
1988  if (params.loop) {
1989    if (animating && !isVirtual && params.loopPreventsSliding) return false;
1990    swiper.loopFix({
1991      direction: 'prev',
1992    });
1993    // eslint-disable-next-line
1994    swiper._clientLeft = swiper.wrapperEl.clientLeft;
1995  }
1996  const translate = rtlTranslate ? swiper.translate : -swiper.translate;
1997  function normalize(val) {
1998    if (val < 0) return -Math.floor(Math.abs(val));
1999    return Math.floor(val);
2000  }
2001  const normalizedTranslate = normalize(translate);
2002  const normalizedSnapGrid = snapGrid.map((val) => normalize(val));
2003  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2004  if (typeof prevSnap === 'undefined' && params.cssMode) {
2005    let prevSnapIndex;
2006    snapGrid.forEach((snap, snapIndex) => {
2007      if (normalizedTranslate >= snap) {
2008        // prevSnap = snap;
2009        prevSnapIndex = snapIndex;
2010      }
2011    });
2012    if (typeof prevSnapIndex !== 'undefined') {
2013      prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2014    }
2015  }
2016  let prevIndex = 0;
2017  if (typeof prevSnap !== 'undefined') {
2018    prevIndex = slidesGrid.indexOf(prevSnap);
2019    if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2020    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2021      prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2022      prevIndex = Math.max(prevIndex, 0);
2023    }
2024  }
2025  if (params.rewind && swiper.isBeginning) {
2026    const lastIndex =
2027      swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual
2028        ? swiper.virtual.slides.length - 1
2029        : swiper.slides.length - 1;
2030    return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2031  }
2032  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2033}
2034
2035/* eslint no-unused-vars: "off" */
2036function slideReset(speed, runCallbacks, internal) {
2037  if (speed === void 0) {
2038    speed = this.params.speed;
2039  }
2040  if (runCallbacks === void 0) {
2041    runCallbacks = true;
2042  }
2043  const swiper = this;
2044  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2045}
2046
2047/* eslint no-unused-vars: "off" */
2048function slideToClosest(speed, runCallbacks, internal, threshold) {
2049  if (speed === void 0) {
2050    speed = this.params.speed;
2051  }
2052  if (runCallbacks === void 0) {
2053    runCallbacks = true;
2054  }
2055  if (threshold === void 0) {
2056    threshold = 0.5;
2057  }
2058  const swiper = this;
2059  let index = swiper.activeIndex;
2060  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2061  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2062  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2063  if (translate >= swiper.snapGrid[snapIndex]) {
2064    // The current translate is on or after the current snap index, so the choice
2065    // is between the current index and the one after it.
2066    const currentSnap = swiper.snapGrid[snapIndex];
2067    const nextSnap = swiper.snapGrid[snapIndex + 1];
2068    if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
2069      index += swiper.params.slidesPerGroup;
2070    }
2071  } else {
2072    // The current translate is before the current snap index, so the choice
2073    // is between the current index and the one before it.
2074    const prevSnap = swiper.snapGrid[snapIndex - 1];
2075    const currentSnap = swiper.snapGrid[snapIndex];
2076    if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
2077      index -= swiper.params.slidesPerGroup;
2078    }
2079  }
2080  index = Math.max(index, 0);
2081  index = Math.min(index, swiper.slidesGrid.length - 1);
2082  return swiper.slideTo(index, speed, runCallbacks, internal);
2083}
2084
2085function slideToClickedSlide() {
2086  const swiper = this;
2087  const { params, slidesEl } = swiper;
2088  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2089  let slideToIndex = swiper.clickedIndex;
2090  let realIndex;
2091  const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2092  if (params.loop) {
2093    if (swiper.animating) return;
2094    realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
2095    if (params.centeredSlides) {
2096      if (
2097        slideToIndex < swiper.loopedSlides - slidesPerView / 2 ||
2098        slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2
2099      ) {
2100        swiper.loopFix();
2101        slideToIndex = swiper.getSlideIndex(
2102          elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]
2103        );
2104        nextTick(() => {
2105          swiper.slideTo(slideToIndex);
2106        });
2107      } else {
2108        swiper.slideTo(slideToIndex);
2109      }
2110    } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2111      swiper.loopFix();
2112      slideToIndex = swiper.getSlideIndex(
2113        elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]
2114      );
2115      nextTick(() => {
2116        swiper.slideTo(slideToIndex);
2117      });
2118    } else {
2119      swiper.slideTo(slideToIndex);
2120    }
2121  } else {
2122    swiper.slideTo(slideToIndex);
2123  }
2124}
2125
2126var slide = {
2127  slideTo,
2128  slideToLoop,
2129  slideNext,
2130  slidePrev,
2131  slideReset,
2132  slideToClosest,
2133  slideToClickedSlide,
2134};
2135
2136function loopCreate(slideRealIndex) {
2137  const swiper = this;
2138  const { params, slidesEl } = swiper;
2139  if (!params.loop || (swiper.virtual && swiper.params.virtual.enabled)) return;
2140  const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
2141  slides.forEach((el, index) => {
2142    el.setAttribute('data-swiper-slide-index', index);
2143  });
2144  swiper.loopFix({
2145    slideRealIndex,
2146    direction: params.centeredSlides ? undefined : 'next',
2147  });
2148}
2149
2150function loopFix(_temp) {
2151  let {
2152    slideRealIndex,
2153    slideTo = true,
2154    direction,
2155    setTranslate,
2156    activeSlideIndex,
2157    byController,
2158    byMousewheel,
2159  } = _temp === void 0 ? {} : _temp;
2160  const swiper = this;
2161  if (!swiper.params.loop) return;
2162  swiper.emit('beforeLoopFix');
2163  const { slides, allowSlidePrev, allowSlideNext, slidesEl, params } = swiper;
2164  swiper.allowSlidePrev = true;
2165  swiper.allowSlideNext = true;
2166  if (swiper.virtual && params.virtual.enabled) {
2167    if (slideTo) {
2168      if (!params.centeredSlides && swiper.snapIndex === 0) {
2169        swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
2170      } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
2171        swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
2172      } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
2173        swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2174      }
2175    }
2176    swiper.allowSlidePrev = allowSlidePrev;
2177    swiper.allowSlideNext = allowSlideNext;
2178    swiper.emit('loopFix');
2179    return;
2180  }
2181  const slidesPerView =
2182    params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(parseFloat(params.slidesPerView, 10));
2183  let loopedSlides = params.loopedSlides || slidesPerView;
2184  if (loopedSlides % params.slidesPerGroup !== 0) {
2185    loopedSlides += params.slidesPerGroup - (loopedSlides % params.slidesPerGroup);
2186  }
2187  swiper.loopedSlides = loopedSlides;
2188  const prependSlidesIndexes = [];
2189  const appendSlidesIndexes = [];
2190  let activeIndex = swiper.activeIndex;
2191  if (typeof activeSlideIndex === 'undefined') {
2192    activeSlideIndex = swiper.getSlideIndex(
2193      swiper.slides.filter((el) => el.classList.contains(params.slideActiveClass))[0]
2194    );
2195  } else {
2196    activeIndex = activeSlideIndex;
2197  }
2198  const isNext = direction === 'next' || !direction;
2199  const isPrev = direction === 'prev' || !direction;
2200  let slidesPrepended = 0;
2201  let slidesAppended = 0;
2202  // prepend last slides before start
2203  if (activeSlideIndex < loopedSlides) {
2204    slidesPrepended = Math.max(loopedSlides - activeSlideIndex, params.slidesPerGroup);
2205    for (let i = 0; i < loopedSlides - activeSlideIndex; i += 1) {
2206      const index = i - Math.floor(i / slides.length) * slides.length;
2207      prependSlidesIndexes.push(slides.length - index - 1);
2208    }
2209  } else if (activeSlideIndex /* + slidesPerView */ > swiper.slides.length - loopedSlides * 2) {
2210    slidesAppended = Math.max(activeSlideIndex - (swiper.slides.length - loopedSlides * 2), params.slidesPerGroup);
2211    for (let i = 0; i < slidesAppended; i += 1) {
2212      const index = i - Math.floor(i / slides.length) * slides.length;
2213      appendSlidesIndexes.push(index);
2214    }
2215  }
2216  if (isPrev) {
2217    prependSlidesIndexes.forEach((index) => {
2218      swiper.slides[index].swiperLoopMoveDOM = true;
2219      slidesEl.prepend(swiper.slides[index]);
2220      swiper.slides[index].swiperLoopMoveDOM = false;
2221    });
2222  }
2223  if (isNext) {
2224    appendSlidesIndexes.forEach((index) => {
2225      swiper.slides[index].swiperLoopMoveDOM = true;
2226      slidesEl.append(swiper.slides[index]);
2227      swiper.slides[index].swiperLoopMoveDOM = false;
2228    });
2229  }
2230  swiper.recalcSlides();
2231  if (params.slidesPerView === 'auto') {
2232    swiper.updateSlides();
2233  }
2234  if (params.watchSlidesProgress) {
2235    swiper.updateSlidesOffset();
2236  }
2237  if (slideTo) {
2238    if (prependSlidesIndexes.length > 0 && isPrev) {
2239      if (typeof slideRealIndex === 'undefined') {
2240        const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2241        const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2242        const diff = newSlideTranslate - currentSlideTranslate;
2243        if (byMousewheel) {
2244          swiper.setTranslate(swiper.translate - diff);
2245        } else {
2246          swiper.slideTo(activeIndex + slidesPrepended, 0, false, true);
2247          if (setTranslate) {
2248            swiper.touches[swiper.isHorizontal() ? 'startX' : 'startY'] += diff;
2249          }
2250        }
2251      } else {
2252        if (setTranslate) {
2253          swiper.slideToLoop(slideRealIndex, 0, false, true);
2254        }
2255      }
2256    } else if (appendSlidesIndexes.length > 0 && isNext) {
2257      if (typeof slideRealIndex === 'undefined') {
2258        const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2259        const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2260        const diff = newSlideTranslate - currentSlideTranslate;
2261        if (byMousewheel) {
2262          swiper.setTranslate(swiper.translate - diff);
2263        } else {
2264          swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2265          if (setTranslate) {
2266            swiper.touches[swiper.isHorizontal() ? 'startX' : 'startY'] += diff;
2267          }
2268        }
2269      } else {
2270        swiper.slideToLoop(slideRealIndex, 0, false, true);
2271      }
2272    }
2273  }
2274  swiper.allowSlidePrev = allowSlidePrev;
2275  swiper.allowSlideNext = allowSlideNext;
2276  if (swiper.controller && swiper.controller.control && !byController) {
2277    const loopParams = {
2278      slideRealIndex,
2279      slideTo: false,
2280      direction,
2281      setTranslate,
2282      activeSlideIndex,
2283      byController: true,
2284    };
2285    if (Array.isArray(swiper.controller.control)) {
2286      swiper.controller.control.forEach((c) => {
2287        if (!c.destroyed && c.params.loop) c.loopFix(loopParams);
2288      });
2289    } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
2290      swiper.controller.control.loopFix(loopParams);
2291    }
2292  }
2293  swiper.emit('loopFix');
2294}
2295
2296function loopDestroy() {
2297  const swiper = this;
2298  const { params, slidesEl } = swiper;
2299  if (!params.loop || (swiper.virtual && swiper.params.virtual.enabled)) return;
2300  swiper.recalcSlides();
2301  const newSlidesOrder = [];

2302  swiper.slides.forEach((slideEl) => {
2303    const index =
2304      typeof slideEl.swiperSlideIndex === 'undefined'
2305        ? slideEl.getAttribute('data-swiper-slide-index') * 1
2306        : slideEl.swiperSlideIndex;
2307    newSlidesOrder[index] = slideEl;
2308  });
2309  swiper.slides.forEach((slideEl) => {
2310    slideEl.removeAttribute('data-swiper-slide-index');
2311  });
2312  newSlidesOrder.forEach((slideEl) => {
2313    slidesEl.append(slideEl);
2314  });
2315  swiper.recalcSlides();
2316  swiper.slideTo(swiper.realIndex, 0);
2317}
2318
2319var loop = {
2320  loopCreate,
2321  loopFix,
2322  loopDestroy,
2323};
2324
2325function setGrabCursor(moving) {
2326  const swiper = this;
2327  if (!swiper.params.simulateTouch || (swiper.params.watchOverflow && swiper.isLocked) || swiper.params.cssMode) return;
2328  const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
2329  if (swiper.isElement) {
2330    swiper.__preventObserver__ = true;
2331  }
2332  el.style.cursor = 'move';
2333  el.style.cursor = moving ? 'grabbing' : 'grab';
2334  if (swiper.isElement) {
2335    requestAnimationFrame(() => {
2336      swiper.__preventObserver__ = false;
2337    });
2338  }
2339}
2340
2341function unsetGrabCursor() {
2342  const swiper = this;
2343  if ((swiper.params.watchOverflow && swiper.isLocked) || swiper.params.cssMode) {
2344    return;
2345  }
2346  if (swiper.isElement) {
2347    swiper.__preventObserver__ = true;
2348  }
2349  swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
2350  if (swiper.isElement) {
2351    requestAnimationFrame(() => {
2352      swiper.__preventObserver__ = false;
2353    });
2354  }
2355}
2356
2357var grabCursor = {
2358  setGrabCursor,
2359  unsetGrabCursor,
2360};
2361
2362// Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd
2363function closestElement(selector, base) {
2364  if (base === void 0) {
2365    base = this;
2366  }
2367  function __closestFrom(el) {
2368    if (!el || el === getDocument() || el === getWindow()) return null;
2369    if (el.assignedSlot) el = el.assignedSlot;
2370    const found = el.closest(selector);
2371    if (!found && !el.getRootNode) {
2372      return null;
2373    }
2374    return found || __closestFrom(el.getRootNode().host);
2375  }
2376  return __closestFrom(base);
2377}
2378function onTouchStart(event) {
2379  const swiper = this;
2380  const document = getDocument();
2381  const window = getWindow();
2382  const data = swiper.touchEventsData;
2383  data.evCache.push(event);
2384  const { params, touches, enabled } = swiper;
2385  if (!enabled) return;
2386  if (!params.simulateTouch && event.pointerType === 'mouse') return;
2387  if (swiper.animating && params.preventInteractionOnTransition) {
2388    return;
2389  }
2390  if (!swiper.animating && params.cssMode && params.loop) {
2391    swiper.loopFix();
2392  }
2393  let e = event;
2394  if (e.originalEvent) e = e.originalEvent;
2395  let targetEl = e.target;
2396  if (params.touchEventsTarget === 'wrapper') {
2397    if (!swiper.wrapperEl.contains(targetEl)) return;
2398  }
2399  if ('which' in e && e.which === 3) return;
2400  if ('button' in e && e.button > 0) return;
2401  if (data.isTouched && data.isMoved) return;
2402
2403  // change target el for shadow root component
2404  const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';
2405  // eslint-disable-next-line
2406  const eventPath = event.composedPath ? event.composedPath() : event.path;
2407  if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
2408    targetEl = eventPath[0];
2409  }
2410  const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2411  const isTargetShadow = !!(e.target && e.target.shadowRoot);
2412
2413  // use closestElement for shadow root element to get the actual closest for nested shadow root element
2414  if (
2415    params.noSwiping &&
2416    (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))
2417  ) {
2418    swiper.allowClick = true;
2419    return;
2420  }
2421  if (params.swipeHandler) {
2422    if (!targetEl.closest(params.swipeHandler)) return;
2423  }
2424  touches.currentX = e.pageX;
2425  touches.currentY = e.pageY;
2426  const startX = touches.currentX;
2427  const startY = touches.currentY;
2428
2429  // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
2430
2431  const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;

2432  const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
2433  if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
2434    if (edgeSwipeDetection === 'prevent') {
2435      event.preventDefault();
2436    } else {
2437      return;
2438    }
2439  }
2440  Object.assign(data, {
2441    isTouched: true,
2442    isMoved: false,
2443    allowTouchCallbacks: true,
2444    isScrolling: undefined,
2445    startMoving: undefined,
2446  });
2447  touches.startX = startX;
2448  touches.startY = startY;
2449  data.touchStartTime = now();
2450  swiper.allowClick = true;
2451  swiper.updateSize();
2452  swiper.swipeDirection = undefined;
2453  if (params.threshold > 0) data.allowThresholdMove = false;
2454  let preventDefault = true;
2455  if (targetEl.matches(data.focusableElements)) {
2456    preventDefault = false;
2457    if (targetEl.nodeName === 'SELECT') {
2458      data.isTouched = false;
2459    }
2460  }
2461  if (
2462    document.activeElement &&
2463    document.activeElement.matches(data.focusableElements) &&
2464    document.activeElement !== targetEl
2465  ) {
2466    document.activeElement.blur();
2467  }
2468  const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
2469  if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !targetEl.isContentEditable) {
2470    e.preventDefault();
2471  }
2472  if (params.freeMode && params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
2473    swiper.freeMode.onTouchStart();
2474  }
2475  swiper.emit('touchStart', e);
2476}
2477
2478function onTouchMove(event) {
2479  const document = getDocument();
2480  const swiper = this;
2481  const data = swiper.touchEventsData;
2482  const { params, touches, rtlTranslate: rtl, enabled } = swiper;
2483  if (!enabled) return;
2484  if (!params.simulateTouch && event.pointerType === 'mouse') return;
2485  let e = event;
2486  if (e.originalEvent) e = e.originalEvent;
2487  if (!data.isTouched) {
2488    if (data.startMoving && data.isScrolling) {
2489      swiper.emit('touchMoveOpposite', e);
2490    }
2491    return;
2492  }
2493  const pointerIndex = data.evCache.findIndex((cachedEv) => cachedEv.pointerId === e.pointerId);
2494  if (pointerIndex >= 0) data.evCache[pointerIndex] = e;
2495  const targetTouch = data.evCache.length > 1 ? data.evCache[0] : e;
2496  const pageX = targetTouch.pageX;
2497  const pageY = targetTouch.pageY;
2498  if (e.preventedByNestedSwiper) {
2499    touches.startX = pageX;
2500    touches.startY = pageY;
2501    return;
2502  }
2503  if (!swiper.allowTouchMove) {
2504    if (!e.target.matches(data.focusableElements)) {
2505      swiper.allowClick = false;
2506    }
2507    if (data.isTouched) {
2508      Object.assign(touches, {
2509        startX: pageX,
2510        startY: pageY,
2511        prevX: swiper.touches.currentX,
2512        prevY: swiper.touches.currentY,
2513        currentX: pageX,
2514        currentY: pageY,
2515      });
2516      data.touchStartTime = now();
2517    }
2518    return;
2519  }
2520  if (params.touchReleaseOnEdges && !params.loop) {
2521    if (swiper.isVertical()) {
2522      // Vertical
2523      if (
2524        (pageY < touches.startY && swiper.translate <= swiper.maxTranslate()) ||
2525        (pageY > touches.startY && swiper.translate >= swiper.minTranslate())
2526      ) {
2527        data.isTouched = false;
2528        data.isMoved = false;
2529        return;
2530      }
2531    } else if (
2532      (pageX < touches.startX && swiper.translate <= swiper.maxTranslate()) ||
2533      (pageX > touches.startX && swiper.translate >= swiper.minTranslate())
2534    ) {
2535      return;
2536    }
2537  }
2538  if (document.activeElement) {
2539    if (e.target === document.activeElement && e.target.matches(data.focusableElements)) {
2540      data.isMoved = true;
2541      swiper.allowClick = false;
2542      return;
2543    }
2544  }
2545  if (data.allowTouchCallbacks) {
2546    swiper.emit('touchMove', e);
2547  }
2548  if (e.targetTouches && e.targetTouches.length > 1) return;
2549  touches.currentX = pageX;
2550  touches.currentY = pageY;
2551  const diffX = touches.currentX - touches.startX;
2552  const diffY = touches.currentY - touches.startY;
2553  if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;
2554  if (typeof data.isScrolling === 'undefined') {
2555    let touchAngle;
2556    if (
2557      (swiper.isHorizontal() && touches.currentY === touches.startY) ||
2558      (swiper.isVertical() && touches.currentX === touches.startX)
2559    ) {
2560      data.isScrolling = false;
2561    } else {
2562      // eslint-disable-next-line
2563      if (diffX * diffX + diffY * diffY >= 25) {
2564        touchAngle = (Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180) / Math.PI;
2565        data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
2566      }
2567    }
2568  }
2569  if (data.isScrolling) {
2570    swiper.emit('touchMoveOpposite', e);
2571  }
2572  if (typeof data.startMoving === 'undefined') {
2573    if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
2574      data.startMoving = true;
2575    }
2576  }
2577  if (
2578    data.isScrolling ||
2579    (swiper.zoom && swiper.params.zoom && swiper.params.zoom.enabled && data.evCache.length > 1)
2580  ) {
2581    data.isTouched = false;
2582    return;
2583  }
2584  if (!data.startMoving) {
2585    return;
2586  }
2587  swiper.allowClick = false;
2588  if (!params.cssMode && e.cancelable) {
2589    e.preventDefault();
2590  }
2591  if (params.touchMoveStopPropagation && !params.nested) {
2592    e.stopPropagation();
2593  }
2594  let diff = swiper.isHorizontal() ? diffX : diffY;
2595  let touchesDiff = swiper.isHorizontal() ? touches.currentX - touches.previousX : touches.currentY - touches.previousY;
2596  if (params.oneWayMovement) {
2597    diff = Math.abs(diff) * (rtl ? 1 : -1);
2598    touchesDiff = Math.abs(touchesDiff) * (rtl ? 1 : -1);
2599  }
2600  touches.diff = diff;
2601  diff *= params.touchRatio;
2602  if (rtl) {
2603    diff = -diff;
2604    touchesDiff = -touchesDiff;
2605  }
2606  const prevTouchesDirection = swiper.touchesDirection;
2607  swiper.swipeDirection = diff > 0 ? 'prev' : 'next';
2608  swiper.touchesDirection = touchesDiff > 0 ? 'prev' : 'next';
2609  const isLoop = swiper.params.loop && !params.cssMode;
2610  if (!data.isMoved) {
2611    if (isLoop) {
2612      swiper.loopFix({
2613        direction: swiper.swipeDirection,
2614      });
2615    }
2616    data.startTranslate = swiper.getTranslate();
2617    swiper.setTransition(0);
2618    if (swiper.animating) {
2619      const evt = new window.CustomEvent('transitionend', {
2620        bubbles: true,
2621        cancelable: true,
2622      });
2623      swiper.wrapperEl.dispatchEvent(evt);
2624    }
2625    data.allowMomentumBounce = false;
2626    // Grab Cursor
2627    if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
2628      swiper.setGrabCursor(true);
2629    }
2630    swiper.emit('sliderFirstMove', e);
2631  }
2632  let loopFixed;
2633  if (data.isMoved && prevTouchesDirection !== swiper.touchesDirection && isLoop && Math.abs(diff) >= 1) {
2634    // need another loop fix
2635    swiper.loopFix({
2636      direction: swiper.swipeDirection,
2637      setTranslate: true,
2638    });
2639    loopFixed = true;
2640  }
2641  swiper.emit('sliderMove', e);
2642  data.isMoved = true;
2643  data.currentTranslate = diff + data.startTranslate;
2644  let disableParentSwiper = true;
2645  let resistanceRatio = params.resistanceRatio;
2646  if (params.touchReleaseOnEdges) {
2647    resistanceRatio = 0;
2648  }
2649  if (diff > 0) {
2650    if (
2651      isLoop &&
2652      !loopFixed &&
2653      data.currentTranslate > (params.centeredSlides ? swiper.minTranslate() - swiper.size / 2 : swiper.minTranslate())
2654    ) {
2655      swiper.loopFix({
2656        direction: 'prev',
2657        setTranslate: true,
2658        activeSlideIndex: 0,
2659      });
2660    }
2661    if (data.currentTranslate > swiper.minTranslate()) {
2662      disableParentSwiper = false;
2663      if (params.resistance) {
2664        data.currentTranslate =
2665          swiper.minTranslate() - 1 + (-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio;
2666      }
2667    }
2668  } else if (diff < 0) {
2669    if (
2670      isLoop &&
2671      !loopFixed &&
2672      data.currentTranslate < (params.centeredSlides ? swiper.maxTranslate() + swiper.size / 2 : swiper.maxTranslate())
2673    ) {
2674      swiper.loopFix({
2675        direction: 'next',
2676        setTranslate: true,
2677        activeSlideIndex:
2678          swiper.slides.length -
2679          (params.slidesPerView === 'auto'
2680            ? swiper.slidesPerViewDynamic()
2681            : Math.ceil(parseFloat(params.slidesPerView, 10))),
2682      });
2683    }
2684    if (data.currentTranslate < swiper.maxTranslate()) {
2685      disableParentSwiper = false;
2686      if (params.resistance) {
2687        data.currentTranslate =
2688          swiper.maxTranslate() + 1 - (swiper.maxTranslate() - data.startTranslate - diff) ** resistanceRatio;
2689      }
2690    }
2691  }
2692  if (disableParentSwiper) {
2693    e.preventedByNestedSwiper = true;
2694  }
2695
2696  // Directions locks
2697  if (!swiper.allowSlideNext && swiper.swipeDirection === 'next' && data.currentTranslate < data.startTranslate) {
2698    data.currentTranslate = data.startTranslate;
2699  }
2700  if (!swiper.allowSlidePrev && swiper.swipeDirection === 'prev' && data.currentTranslate > data.startTranslate) {
2701    data.currentTranslate = data.startTranslate;
2702  }
2703  if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {
2704    data.currentTranslate = data.startTranslate;
2705  }
2706
2707  // Threshold
2708  if (params.threshold > 0) {
2709    if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
2710      if (!data.allowThresholdMove) {
2711        data.allowThresholdMove = true;
2712        touches.startX = touches.currentX;
2713        touches.startY = touches.currentY;
2714        data.currentTranslate = data.startTranslate;
2715        touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;
2716        return;
2717      }
2718    } else {
2719      data.currentTranslate = data.startTranslate;
2720      return;
2721    }
2722  }
2723  if (!params.followFinger || params.cssMode) return;
2724
2725  // Update active index in free mode
2726  if ((params.freeMode && params.freeMode.enabled && swiper.freeMode) || params.watchSlidesProgress) {
2727    swiper.updateActiveIndex();
2728    swiper.updateSlidesClasses();
2729  }
2730  if (params.freeMode && params.freeMode.enabled && swiper.freeMode) {
2731    swiper.freeMode.onTouchMove();
2732  }
2733  // Update progress
2734  swiper.updateProgress(data.currentTranslate);
2735  // Update translate
2736  swiper.setTranslate(data.currentTranslate);
2737}
2738
2739function onTouchEnd(event) {
2740  const swiper = this;
2741  const data = swiper.touchEventsData;
2742  const pointerIndex = data.evCache.findIndex((cachedEv) => cachedEv.pointerId === event.pointerId);
2743  if (pointerIndex >= 0) {
2744    data.evCache.splice(pointerIndex, 1);
2745  }
2746  if (['pointercancel', 'pointerout', 'pointerleave'].includes(event.type)) {
2747    const proceed = event.type === 'pointercancel' && (swiper.browser.isSafari || swiper.browser.isWebView);
2748    if (!proceed) {
2749      return;
2750    }
2751  }
2752  const { params, touches, rtlTranslate: rtl, slidesGrid, enabled } = swiper;
2753  if (!enabled) return;
2754  if (!params.simulateTouch && event.pointerType === 'mouse') return;
2755  let e = event;
2756  if (e.originalEvent) e = e.originalEvent;
2757  if (data.allowTouchCallbacks) {
2758    swiper.emit('touchEnd', e);
2759  }
2760  data.allowTouchCallbacks = false;
2761  if (!data.isTouched) {
2762    if (data.isMoved && params.grabCursor) {
2763      swiper.setGrabCursor(false);
2764    }
2765    data.isMoved = false;
2766    data.startMoving = false;
2767    return;
2768  }
2769  // Return Grab Cursor
2770  if (
2771    params.grabCursor &&
2772    data.isMoved &&
2773    data.isTouched &&
2774    (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)
2775  ) {
2776    swiper.setGrabCursor(false);
2777  }
2778
2779  // Time diff
2780  const touchEndTime = now();
2781  const timeDiff = touchEndTime - data.touchStartTime;
2782
2783  // Tap, doubleTap, Click
2784  if (swiper.allowClick) {
2785    const pathTree = e.path || (e.composedPath && e.composedPath());
2786    swiper.updateClickedSlide((pathTree && pathTree[0]) || e.target);
2787    swiper.emit('tap click', e);
2788    if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {
2789      swiper.emit('doubleTap doubleClick', e);
2790    }
2791  }
2792  data.lastClickTime = now();
2793  nextTick(() => {
2794    if (!swiper.destroyed) swiper.allowClick = true;
2795  });
2796  if (
2797    !data.isTouched ||
2798    !data.isMoved ||
2799    !swiper.swipeDirection ||
2800    touches.diff === 0 ||
2801    data.currentTranslate === data.startTranslate
2802  ) {
2803    data.isTouched = false;
2804    data.isMoved = false;
2805    data.startMoving = false;
2806    return;
2807  }
2808  data.isTouched = false;
2809  data.isMoved = false;
2810  data.startMoving = false;
2811  let currentPos;
2812  if (params.followFinger) {
2813    currentPos = rtl ? swiper.translate : -swiper.translate;
2814  } else {
2815    currentPos = -data.currentTranslate;
2816  }
2817  if (params.cssMode) {
2818    return;
2819  }
2820  if (params.freeMode && params.freeMode.enabled) {
2821    swiper.freeMode.onTouchEnd({
2822      currentPos,
2823    });
2824    return;
2825  }
2826
2827  // Find current slide
2828  let stopIndex = 0;
2829  let groupSize = swiper.slidesSizesGrid[0];
2830  for (let i = 0; i < slidesGrid.length; i += i < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup) {
2831    const increment = i < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
2832    if (typeof slidesGrid[i + increment] !== 'undefined') {
2833      if (currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + increment]) {
2834        stopIndex = i;
2835        groupSize = slidesGrid[i + increment] - slidesGrid[i];
2836      }
2837    } else if (currentPos >= slidesGrid[i]) {
2838      stopIndex = i;
2839      groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];
2840    }
2841  }
2842  let rewindFirstIndex = null;
2843  let rewindLastIndex = null;
2844  if (params.rewind) {
2845    if (swiper.isBeginning) {
2846      rewindLastIndex =
2847        params.virtual && params.virtual.enabled && swiper.virtual
2848          ? swiper.virtual.slides.length - 1
2849          : swiper.slides.length - 1;
2850    } else if (swiper.isEnd) {
2851      rewindFirstIndex = 0;
2852    }
2853  }
2854  // Find current slide size
2855  const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;
2856  const increment = stopIndex < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
2857  if (timeDiff > params.longSwipesMs) {
2858    // Long touches
2859    if (!params.longSwipes) {
2860      swiper.slideTo(swiper.activeIndex);
2861      return;
2862    }
2863    if (swiper.swipeDirection === 'next') {
2864      if (ratio >= params.longSwipesRatio)
2865        swiper.slideTo(params.rewind && swiper.isEnd ? rewindFirstIndex : stopIndex + increment);
2866      else swiper.slideTo(stopIndex);
2867    }
2868    if (swiper.swipeDirection === 'prev') {
2869      if (ratio > 1 - params.longSwipesRatio) {
2870        swiper.slideTo(stopIndex + increment);
2871      } else if (rewindLastIndex !== null && ratio < 0 && Math.abs(ratio) > params.longSwipesRatio) {
2872        swiper.slideTo(rewindLastIndex);
2873      } else {
2874        swiper.slideTo(stopIndex);
2875      }
2876    }
2877  } else {
2878    // Short swipes
2879    if (!params.shortSwipes) {
2880      swiper.slideTo(swiper.activeIndex);
2881      return;
2882    }
2883    const isNavButtonTarget =
2884      swiper.navigation && (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);
2885    if (!isNavButtonTarget) {
2886      if (swiper.swipeDirection === 'next') {
2887        swiper.slideTo(rewindFirstIndex !== null ? rewindFirstIndex : stopIndex + increment);
2888      }
2889      if (swiper.swipeDirection === 'prev') {
2890        swiper.slideTo(rewindLastIndex !== null ? rewindLastIndex : stopIndex);
2891      }
2892    } else if (e.target === swiper.navigation.nextEl) {
2893      swiper.slideTo(stopIndex + increment);
2894    } else {
2895      swiper.slideTo(stopIndex);
2896    }
2897  }
2898}
2899
2900function onResize() {
2901  const swiper = this;
2902  const { params, el } = swiper;
2903  if (el && el.offsetWidth === 0) return;
2904
2905  // Breakpoints
2906  if (params.breakpoints) {
2907    swiper.setBreakpoint();
2908  }
2909
2910  // Save locks
2911  const { allowSlideNext, allowSlidePrev, snapGrid } = swiper;
2912  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2913
2914  // Disable locks on resize
2915  swiper.allowSlideNext = true;
2916  swiper.allowSlidePrev = true;
2917  swiper.updateSize();
2918  swiper.updateSlides();
2919  swiper.updateSlidesClasses();
2920  const isVirtualLoop = isVirtual && params.loop;
2921  if (
2922    (params.slidesPerView === 'auto' || params.slidesPerView > 1) &&
2923    swiper.isEnd &&
2924    !swiper.isBeginning &&
2925    !swiper.params.centeredSlides &&
2926    !isVirtualLoop
2927  ) {
2928    swiper.slideTo(swiper.slides.length - 1, 0, false, true);
2929  } else {
2930    if (swiper.params.loop && !isVirtual) {
2931      swiper.slideToLoop(swiper.realIndex, 0, false, true);
2932    } else {
2933      swiper.slideTo(swiper.activeIndex, 0, false, true);
2934    }
2935  }
2936  if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
2937    clearTimeout(swiper.autoplay.resizeTimeout);
2938    swiper.autoplay.resizeTimeout = setTimeout(() => {
2939      if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
2940        swiper.autoplay.resume();
2941      }
2942    }, 500);
2943  }
2944  // Return locks after resize
2945  swiper.allowSlidePrev = allowSlidePrev;
2946  swiper.allowSlideNext = allowSlideNext;
2947  if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {
2948    swiper.checkOverflow();
2949  }
2950}
2951
2952function onClick(e) {
2953  const swiper = this;
2954  if (!swiper.enabled) return;
2955  if (!swiper.allowClick) {
2956    if (swiper.params.preventClicks) e.preventDefault();
2957    if (swiper.params.preventClicksPropagation && swiper.animating) {
2958      e.stopPropagation();
2959      e.stopImmediatePropagation();
2960    }
2961  }
2962}
2963
2964function onScroll() {
2965  const swiper = this;
2966  const { wrapperEl, rtlTranslate, enabled } = swiper;
2967  if (!enabled) return;
2968  swiper.previousTranslate = swiper.translate;
2969  if (swiper.isHorizontal()) {
2970    swiper.translate = -wrapperEl.scrollLeft;
2971  } else {
2972    swiper.translate = -wrapperEl.scrollTop;
2973  }
2974  // eslint-disable-next-line
2975  if (swiper.translate === 0) swiper.translate = 0;
2976  swiper.updateActiveIndex();
2977  swiper.updateSlidesClasses();
2978  let newProgress;
2979  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2980  if (translatesDiff === 0) {
2981    newProgress = 0;
2982  } else {
2983    newProgress = (swiper.translate - swiper.minTranslate()) / translatesDiff;
2984  }
2985  if (newProgress !== swiper.progress) {
2986    swiper.updateProgress(rtlTranslate ? -swiper.translate : swiper.translate);
2987  }
2988  swiper.emit('setTranslate', swiper.translate, false);
2989}
2990
2991function onLoad(e) {
2992  const swiper = this;
2993  processLazyPreloader(swiper, e.target);
2994  if (swiper.params.cssMode || (swiper.params.slidesPerView !== 'auto' && !swiper.params.autoHeight)) {
2995    return;
2996  }