https://www.helloklarity.com/_next/static/chunks/vendors-6391b56b-e6ed53caf4804b52.js

125      swiper.slides.forEach(slideEl => {
126        slideEl.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => shadowEl.remove());
127      });
128      // create new one
129      recreateShadows();
130    }
131  });
132  let requireUpdateOnVirtual;
133  on('virtualUpdate', () => {
134    if (swiper.params.effect !== effect) return;
135    if (!swiper.slides.length) {
136      requireUpdateOnVirtual = true;
137    }
138    requestAnimationFrame(() => {
139      if (requireUpdateOnVirtual && swiper.slides && swiper.slides.length) {
140        setTranslate();
141        requireUpdateOnVirtual = false;
142      }
143    });
144  });
145}
146
147
148
149
150/***/ }),
151
152/***/ 682503:
153/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
154
155"use strict";
156/* unused harmony export e */
157/* harmony import */ var _utils_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(107185);
158
159
160function effectTarget(effectParams, slideEl) {
161  const transformEl = getSlideTransformEl(slideEl);
162  if (transformEl !== slideEl) {
163    transformEl.style.backfaceVisibility = 'hidden';
164    transformEl.style['-webkit-backface-visibility'] = 'hidden';
165  }
166  return transformEl;
167}
168
169
170
171
172/***/ }),
173
174/***/ 979181:
175/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
176
177"use strict";
178/* unused harmony export e */
179/* harmony import */ var _utils_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(107185);
180
181
182function effectVirtualTransitionEnd(_ref) {
183  let {
184    swiper,
185    duration,
186    transformElements,
187    allSlides
188  } = _ref;
189  const {
190    activeIndex
191  } = swiper;
192  const getSlide = el => {
193    if (!el.parentElement) {
194      // assume shadow root
195      const slide = swiper.slides.filter(slideEl => slideEl.shadowRoot && slideEl.shadowRoot === el.parentNode)[0];
196      return slide;
197    }
198    return el.parentElement;
199  };
200  if (swiper.params.virtualTranslate && duration !== 0) {
201    let eventTriggered = false;
202    let transitionEndTarget;
203    if (allSlides) {
204      transitionEndTarget = transformElements;
205    } else {
206      transitionEndTarget = transformElements.filter(transformEl => {
207        const el = transformEl.classList.contains('swiper-slide-transform') ? getSlide(transformEl) : transformEl;
208        return swiper.getSlideIndex(el) === activeIndex;
209      });
210    }
211    transitionEndTarget.forEach(el => {
212      elementTransitionEnd(el, () => {
213        if (eventTriggered) return;
214        if (!swiper || swiper.destroyed) return;
215        eventTriggered = true;
216        swiper.animating = false;
217        const evt = new window.CustomEvent('transitionend', {
218          bubbles: true,
219          cancelable: true
220        });
221        swiper.wrapperEl.dispatchEvent(evt);
222      });
223    });
224  }
225}
226
227
228
229
230/***/ }),
231
232/***/ 113433:
233/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
234
235"use strict";
236/* harmony export */ __webpack_require__.d(__webpack_exports__, {
237/* harmony export */   a: function() { return /* binding */ getWindow; },
238/* harmony export */   g: function() { return /* binding */ getDocument; }
239/* harmony export */ });
240/**
241 * SSR Window 4.0.2
242 * Better handling for window object in SSR environment
243 * https://github.com/nolimits4web/ssr-window
244 *
245 * Copyright 2021, Vladimir Kharlampidi
246 *
247 * Licensed under MIT
248 *
249 * Released on: December 13, 2021
250 */
251/* eslint-disable no-param-reassign */
252function isObject(obj) {
253  return obj !== null && typeof obj === 'object' && 'constructor' in obj && obj.constructor === Object;
254}
255function extend(target, src) {
256  if (target === void 0) {
257    target = {};
258  }
259  if (src === void 0) {
260    src = {};
261  }
262  Object.keys(src).forEach(key => {
263    if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject(src[key]) && isObject(target[key]) && Object.keys(src[key]).length > 0) {
264      extend(target[key], src[key]);
265    }
266  });
267}
268const ssrDocument = {
269  body: {},
270  addEventListener() {},
271  removeEventListener() {},
272  activeElement: {
273    blur() {},
274    nodeName: ''
275  },
276  querySelector() {
277    return null;
278  },
279  querySelectorAll() {
280    return [];
281  },
282  getElementById() {
283    return null;
284  },
285  createEvent() {
286    return {
287      initEvent() {}
288    };
289  },
290  createElement() {
291    return {
292      children: [],
293      childNodes: [],
294      style: {},
295      setAttribute() {},
296      getElementsByTagName() {
297        return [];
298      }
299    };
300  },
301  createElementNS() {
302    return {};
303  },
304  importNode() {
305    return null;
306  },
307  location: {
308    hash: '',
309    host: '',
310    hostname: '',
311    href: '',
312    origin: '',
313    pathname: '',
314    protocol: '',
315    search: ''
316  }
317};
318function getDocument() {
319  const doc = typeof document !== 'undefined' ? document : {};
320  extend(doc, ssrDocument);
321  return doc;
322}
323const ssrWindow = {
324  document: ssrDocument,
325  navigator: {
326    userAgent: ''
327  },
328  location: {
329    hash: '',
330    host: '',
331    hostname: '',
332    href: '',
333    origin: '',
334    pathname: '',
335    protocol: '',
336    search: ''
337  },
338  history: {
339    replaceState() {},
340    pushState() {},
341    go() {},
342    back() {}
343  },
344  CustomEvent: function CustomEvent() {
345    return this;
346  },
347  addEventListener() {},
348  removeEventListener() {},
349  getComputedStyle() {
350    return {
351      getPropertyValue() {
352        return '';
353      }
354    };
355  },
356  Image() {},
357  Date() {},
358  screen: {},
359  setTimeout() {},

360  clearTimeout() {},
361  matchMedia() {
362    return {};
363  },
364  requestAnimationFrame(callback) {
365    if (typeof setTimeout === 'undefined') {
366      callback();
367      return null;
368    }
369    return setTimeout(callback, 0);
370  },
371  cancelAnimationFrame(id) {
372    if (typeof setTimeout === 'undefined') {
373      return;
374    }
375    clearTimeout(id);
376  }
377};
378function getWindow() {
379  const win = typeof window !== 'undefined' ? window : {};
380  extend(win, ssrWindow);
381  return win;
382}
383
384
385
386
387/***/ }),
388
389/***/ 107185:
390/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
391
392"use strict";
393/* harmony export */ __webpack_require__.d(__webpack_exports__, {
394/* harmony export */   a: function() { return /* binding */ elementParents; },
395/* harmony export */   c: function() { return /* binding */ createElement; },
396/* harmony export */   d: function() { return /* binding */ now; },
397/* harmony export */   e: function() { return /* binding */ elementChildren; },
398/* harmony export */   f: function() { return /* binding */ elementOuterSize; },
399/* harmony export */   g: function() { return /* binding */ elementIndex; },
400/* harmony export */   i: function() { return /* binding */ getTranslate; },
401/* harmony export */   m: function() { return /* binding */ elementStyle; },
402/* harmony export */   n: function() { return /* binding */ nextTick; },
403/* harmony export */   o: function() { return /* binding */ elementNextAll; },
404/* harmony export */   p: function() { return /* binding */ elementPrevAll; },
405/* harmony export */   q: function() { return /* binding */ animateCSSModeScroll; },
406/* harmony export */   r: function() { return /* binding */ showWarning; },
407/* harmony export */   s: function() { return /* binding */ setCSSProperty; },
408/* harmony export */   t: function() { return /* binding */ extend; },
409/* harmony export */   u: function() { return /* binding */ deleteProps; }
410/* harmony export */ });
411/* unused harmony exports b, h, j, k, l */
412/* harmony import */ var _ssr_window_esm_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(113433);
413
414
415function classesToTokens(classes) {
416  if (classes === void 0) {
417    classes = '';
418  }
419  return classes.trim().split(' ').filter(c => !!c.trim());
420}
421
422function deleteProps(obj) {
423  const object = obj;
424  Object.keys(object).forEach(key => {
425    try {
426      object[key] = null;
427    } catch (e) {
428      // no getter for object
429    }
430    try {
431      delete object[key];
432    } catch (e) {
433      // something got wrong
434    }
435  });
436}
437function nextTick(callback, delay) {
438  if (delay === void 0) {
439    delay = 0;
440  }
441  return setTimeout(callback, delay);
442}
443function now() {
444  return Date.now();
445}
446function getComputedStyle(el) {
447  const window = (0,_ssr_window_esm_mjs__WEBPACK_IMPORTED_MODULE_0__.a)();
448  let style;
449  if (window.getComputedStyle) {
450    style = window.getComputedStyle(el, null);
451  }
452  if (!style && el.currentStyle) {
453    style = el.currentStyle;
454  }
455  if (!style) {
456    style = el.style;
457  }
458  return style;
459}
460function getTranslate(el, axis) {
461  if (axis === void 0) {
462    axis = 'x';
463  }
464  const window = (0,_ssr_window_esm_mjs__WEBPACK_IMPORTED_MODULE_0__.a)();
465  let matrix;
466  let curTransform;
467  let transformMatrix;
468  const curStyle = getComputedStyle(el);
469  if (window.WebKitCSSMatrix) {
470    curTransform = curStyle.transform || curStyle.webkitTransform;
471    if (curTransform.split(',').length > 6) {
472      curTransform = curTransform.split(', ').map(a => a.replace(',', '.')).join(', ');
473    }
474    // Some old versions of Webkit choke when 'none' is passed; pass
475    // empty string instead in this case
476    transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
477  } else {
478    transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
479    matrix = transformMatrix.toString().split(',');
480  }
481  if (axis === 'x') {
482    // Latest Chrome and webkits Fix
483    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41;
484    // Crazy IE10 Matrix
485    else if (matrix.length === 16) curTransform = parseFloat(matrix[12]);
486    // Normal Browsers
487    else curTransform = parseFloat(matrix[4]);
488  }
489  if (axis === 'y') {
490    // Latest Chrome and webkits Fix
491    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42;
492    // Crazy IE10 Matrix
493    else if (matrix.length === 16) curTransform = parseFloat(matrix[13]);
494    // Normal Browsers
495    else curTransform = parseFloat(matrix[5]);
496  }
497  return curTransform || 0;
498}
499function isObject(o) {
500  return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';
501}
502function isNode(node) {
503  // eslint-disable-next-line
504  if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
505    return node instanceof HTMLElement;
506  }
507  return node && (node.nodeType === 1 || node.nodeType === 11);
508}
509function extend() {
510  const to = Object(arguments.length <= 0 ? undefined : arguments[0]);
511  const noExtend = ['__proto__', 'constructor', 'prototype'];
512  for (let i = 1; i < arguments.length; i += 1) {
513    const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
514    if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
515      const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);
516      for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
517        const nextKey = keysArray[nextIndex];
518        const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
519        if (desc !== undefined && desc.enumerable) {
520          if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
521            if (nextSource[nextKey].__swiper__) {
522              to[nextKey] = nextSource[nextKey];
523            } else {
524              extend(to[nextKey], nextSource[nextKey]);
525            }
526          } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
527            to[nextKey] = {};
528            if (nextSource[nextKey].__swiper__) {
529              to[nextKey] = nextSource[nextKey];
530            } else {
531              extend(to[nextKey], nextSource[nextKey]);
532            }
533          } else {
534            to[nextKey] = nextSource[nextKey];
535          }
536        }
537      }
538    }
539  }
540  return to;
541}
542function setCSSProperty(el, varName, varValue) {
543  el.style.setProperty(varName, varValue);
544}
545function animateCSSModeScroll(_ref) {
546  let {
547    swiper,
548    targetPosition,
549    side
550  } = _ref;
551  const window = (0,_ssr_window_esm_mjs__WEBPACK_IMPORTED_MODULE_0__.a)();
552  const startPosition = -swiper.translate;
553  let startTime = null;
554  let time;
555  const duration = swiper.params.speed;
556  swiper.wrapperEl.style.scrollSnapType = 'none';
557  window.cancelAnimationFrame(swiper.cssModeFrameID);
558  const dir = targetPosition > startPosition ? 'next' : 'prev';
559  const isOutOfBound = (current, target) => {
560    return dir === 'next' && current >= target || dir === 'prev' && current <= target;
561  };
562  const animate = () => {
563    time = new Date().getTime();
564    if (startTime === null) {
565      startTime = time;
566    }
567    const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
568    const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;

569    let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
570    if (isOutOfBound(currentPosition, targetPosition)) {
571      currentPosition = targetPosition;
572    }
573    swiper.wrapperEl.scrollTo({
574      [side]: currentPosition
575    });
576    if (isOutOfBound(currentPosition, targetPosition)) {
577      swiper.wrapperEl.style.overflow = 'hidden';
578      swiper.wrapperEl.style.scrollSnapType = '';
579      setTimeout(() => {
580        swiper.wrapperEl.style.overflow = '';
581        swiper.wrapperEl.scrollTo({
582          [side]: currentPosition
583        });
584      });
585      window.cancelAnimationFrame(swiper.cssModeFrameID);
586      return;
587    }
588    swiper.cssModeFrameID = window.requestAnimationFrame(animate);
589  };
590  animate();
591}
592function getSlideTransformEl(slideEl) {
593  return slideEl.querySelector('.swiper-slide-transform') || slideEl.shadowRoot && slideEl.shadowRoot.querySelector('.swiper-slide-transform') || slideEl;
594}
595function elementChildren(element, selector) {
596  if (selector === void 0) {
597    selector = '';
598  }
599  return [...element.children].filter(el => el.matches(selector));
600}
601function showWarning(text) {
602  try {
603    console.warn(text);
604    return;
605  } catch (err) {
606    // err
607  }
608}
609function createElement(tag, classes) {
610  if (classes === void 0) {
611    classes = [];
612  }
613  const el = document.createElement(tag);
614  el.classList.add(...(Array.isArray(classes) ? classes : classesToTokens(classes)));
615  return el;
616}
617function elementOffset(el) {
618  const window = getWindow();
619  const document = getDocument();
620  const box = el.getBoundingClientRect();
621  const body = document.body;
622  const clientTop = el.clientTop || body.clientTop || 0;
623  const clientLeft = el.clientLeft || body.clientLeft || 0;
624  const scrollTop = el === window ? window.scrollY : el.scrollTop;
625  const scrollLeft = el === window ? window.scrollX : el.scrollLeft;
626  return {
627    top: box.top + scrollTop - clientTop,
628    left: box.left + scrollLeft - clientLeft
629  };
630}
631function elementPrevAll(el, selector) {
632  const prevEls = [];
633  while (el.previousElementSibling) {
634    const prev = el.previousElementSibling; // eslint-disable-line
635    if (selector) {
636      if (prev.matches(selector)) prevEls.push(prev);
637    } else prevEls.push(prev);
638    el = prev;
639  }
640  return prevEls;
641}
642function elementNextAll(el, selector) {
643  const nextEls = [];
644  while (el.nextElementSibling) {
645    const next = el.nextElementSibling; // eslint-disable-line
646    if (selector) {
647      if (next.matches(selector)) nextEls.push(next);
648    } else nextEls.push(next);
649    el = next;
650  }
651  return nextEls;
652}
653function elementStyle(el, prop) {
654  const window = (0,_ssr_window_esm_mjs__WEBPACK_IMPORTED_MODULE_0__.a)();
655  return window.getComputedStyle(el, null).getPropertyValue(prop);
656}
657function elementIndex(el) {
658  let child = el;
659  let i;
660  if (child) {
661    i = 0;
662    // eslint-disable-next-line
663    while ((child = child.previousSibling) !== null) {
664      if (child.nodeType === 1) i += 1;
665    }
666    return i;
667  }
668  return undefined;
669}
670function elementParents(el, selector) {
671  const parents = []; // eslint-disable-line
672  let parent = el.parentElement; // eslint-disable-line
673  while (parent) {
674    if (selector) {
675      if (parent.matches(selector)) parents.push(parent);
676    } else {
677      parents.push(parent);
678    }
679    parent = parent.parentElement;
680  }
681  return parents;
682}
683function elementTransitionEnd(el, callback) {
684  function fireCallBack(e) {
685    if (e.target !== el) return;
686    callback.call(el, e);
687    el.removeEventListener('transitionend', fireCallBack);
688  }
689  if (callback) {
690    el.addEventListener('transitionend', fireCallBack);
691  }
692}
693function elementOuterSize(el, size, includeMargins) {
694  const window = (0,_ssr_window_esm_mjs__WEBPACK_IMPORTED_MODULE_0__.a)();
695  if (includeMargins) {
696    return el[size === 'width' ? 'offsetWidth' : 'offsetHeight'] + parseFloat(window.getComputedStyle(el, null).getPropertyValue(size === 'width' ? 'margin-right' : 'margin-top')) + parseFloat(window.getComputedStyle(el, null).getPropertyValue(size === 'width' ? 'margin-left' : 'margin-bottom'));
697  }
698  return el.offsetWidth;
699}
700
701
702
703
704/***/ }),
705
706/***/ 202261:
707/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
708
709"use strict";
710
711// EXPORTS
712__webpack_require__.d(__webpack_exports__, {
713  tq: function() { return /* binding */ swiper_react_Swiper; },
714  o5: function() { return /* binding */ SwiperSlide; }
715});
716
717// UNUSED EXPORTS: useSwiper, useSwiperSlide
718
719// EXTERNAL MODULE: ./node_modules/react/index.js
720var react = __webpack_require__(667294);
721// EXTERNAL MODULE: ./node_modules/swiper/shared/ssr-window.esm.mjs
722var ssr_window_esm = __webpack_require__(113433);
723// EXTERNAL MODULE: ./node_modules/swiper/shared/utils.mjs
724var utils = __webpack_require__(107185);
725;// CONCATENATED MODULE: ./node_modules/swiper/shared/swiper-core.mjs
726
727
728
729let support;
730function calcSupport() {
731  const window = (0,ssr_window_esm.a)();
732  const document = (0,ssr_window_esm.g)();
733  return {
734    smoothScroll: document.documentElement && document.documentElement.style && 'scrollBehavior' in document.documentElement.style,
735    touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch)
736  };
737}

738function getSupport() {
739  if (!support) {
740    support = calcSupport();
741  }
742  return support;
743}
744
745let deviceCached;
746function calcDevice(_temp) {
747  let {
748    userAgent
749  } = _temp === void 0 ? {} : _temp;
750  const support = getSupport();
751  const window = (0,ssr_window_esm.a)();
752  const platform = window.navigator.platform;
753  const ua = userAgent || window.navigator.userAgent;
754  const device = {
755    ios: false,
756    android: false
757  };
758  const screenWidth = window.screen.width;
759  const screenHeight = window.screen.height;
760  const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
761  let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
762  const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
763  const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
764  const windows = platform === 'Win32';
765  let macos = platform === 'MacIntel';
766
767  // iPadOs 13 fix
768  const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
769  if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
770    ipad = ua.match(/(Version)\/([\d.]+)/);
771    if (!ipad) ipad = [0, 1, '13_0_0'];
772    macos = false;
773  }
774
775  // Android
776  if (android && !windows) {
777    device.os = 'android';
778    device.android = true;
779  }
780  if (ipad || iphone || ipod) {
781    device.os = 'ios';
782    device.ios = true;
783  }
784
785  // Export object
786  return device;
787}
788function getDevice(overrides) {
789  if (overrides === void 0) {
790    overrides = {};
791  }
792  if (!deviceCached) {
793    deviceCached = calcDevice(overrides);
794  }
795  return deviceCached;
796}
797
798let browser;
799function calcBrowser() {
800  const window = (0,ssr_window_esm.a)();
801  let needPerspectiveFix = false;
802  function isSafari() {
803    const ua = window.navigator.userAgent.toLowerCase();
804    return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
805  }
806  if (isSafari()) {
807    const ua = String(window.navigator.userAgent);
808    if (ua.includes('Version/')) {
809      const [major, minor] = ua.split('Version/')[1].split(' ')[0].split('.').map(num => Number(num));
810      needPerspectiveFix = major < 16 || major === 16 && minor < 2;
811    }
812  }
813  return {
814    isSafari: needPerspectiveFix || isSafari(),
815    needPerspectiveFix,
816    isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)
817  };
818}
819function getBrowser() {
820  if (!browser) {
821    browser = calcBrowser();
822  }
823  return browser;
824}
825
826function Resize(_ref) {
827  let {
828    swiper,
829    on,
830    emit
831  } = _ref;
832  const window = (0,ssr_window_esm.a)();
833  let observer = null;
834  let animationFrame = null;
835  const resizeHandler = () => {
836    if (!swiper || swiper.destroyed || !swiper.initialized) return;
837    emit('beforeResize');
838    emit('resize');
839  };
840  const createObserver = () => {
841    if (!swiper || swiper.destroyed || !swiper.initialized) return;
842    observer = new ResizeObserver(entries => {
843      animationFrame = window.requestAnimationFrame(() => {
844        const {
845          width,
846          height
847        } = swiper;
848        let newWidth = width;
849        let newHeight = height;
850        entries.forEach(_ref2 => {
851          let {
852            contentBoxSize,
853            contentRect,
854            target
855          } = _ref2;
856          if (target && target !== swiper.el) return;
857          newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
858          newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
859        });
860        if (newWidth !== width || newHeight !== height) {
861          resizeHandler();
862        }
863      });
864    });
865    observer.observe(swiper.el);
866  };
867  const removeObserver = () => {
868    if (animationFrame) {
869      window.cancelAnimationFrame(animationFrame);
870    }
871    if (observer && observer.unobserve && swiper.el) {
872      observer.unobserve(swiper.el);
873      observer = null;
874    }
875  };
876  const orientationChangeHandler = () => {
877    if (!swiper || swiper.destroyed || !swiper.initialized) return;
878    emit('orientationchange');
879  };
880  on('init', () => {
881    if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
882      createObserver();
883      return;
884    }
885    window.addEventListener('resize', resizeHandler);
886    window.addEventListener('orientationchange', orientationChangeHandler);
887  });
888  on('destroy', () => {
889    removeObserver();
890    window.removeEventListener('resize', resizeHandler);
891    window.removeEventListener('orientationchange', orientationChangeHandler);
892  });
893}
894
895function Observer(_ref) {
896  let {
897    swiper,
898    extendParams,
899    on,
900    emit
901  } = _ref;
902  const observers = [];
903  const window = (0,ssr_window_esm.a)();
904  const attach = function (target, options) {
905    if (options === void 0) {
906      options = {};
907    }
908    const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
909    const observer = new ObserverFunc(mutations => {
910      // The observerUpdate event should only be triggered
911      // once despite the number of mutations.  Additional
912      // triggers are redundant and are very costly
913      if (swiper.__preventObserver__) return;
914      if (mutations.length === 1) {
915        emit('observerUpdate', mutations[0]);
916        return;
917      }
918      const observerUpdate = function observerUpdate() {
919        emit('observerUpdate', mutations[0]);
920      };
921      if (window.requestAnimationFrame) {
922        window.requestAnimationFrame(observerUpdate);
923      } else {
924        window.setTimeout(observerUpdate, 0);
925      }
926    });
927    observer.observe(target, {
928      attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
929      childList: typeof options.childList === 'undefined' ? true : options.childList,
930      characterData: typeof options.characterData === 'undefined' ? true : options.characterData
931    });
932    observers.push(observer);
933  };
934  const init = () => {
935    if (!swiper.params.observer) return;
936    if (swiper.params.observeParents) {
937      const containerParents = (0,utils.a)(swiper.hostEl);
938      for (let i = 0; i < containerParents.length; i += 1) {
939        attach(containerParents[i]);
940      }
941    }
942    // Observe container
943    attach(swiper.hostEl, {
944      childList: swiper.params.observeSlideChildren
945    });
946
947    // Observe wrapper
948    attach(swiper.wrapperEl, {
949      attributes: false
950    });
951  };
952  const destroy = () => {

953    observers.forEach(observer => {
954      observer.disconnect();
955    });
956    observers.splice(0, observers.length);
957  };
958  extendParams({
959    observer: false,
960    observeParents: false,
961    observeSlideChildren: false
962  });
963  on('init', init);
964  on('destroy', destroy);
965}
966
967/* eslint-disable no-underscore-dangle */
968
969var eventsEmitter = {
970  on(events, handler, priority) {
971    const self = this;
972    if (!self.eventsListeners || self.destroyed) return self;
973    if (typeof handler !== 'function') return self;
974    const method = priority ? 'unshift' : 'push';
975    events.split(' ').forEach(event => {
976      if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
977      self.eventsListeners[event][method](handler);
978    });
979    return self;
980  },
981  once(events, handler, priority) {
982    const self = this;
983    if (!self.eventsListeners || self.destroyed) return self;
984    if (typeof handler !== 'function') return self;
985    function onceHandler() {
986      self.off(events, onceHandler);
987      if (onceHandler.__emitterProxy) {
988        delete onceHandler.__emitterProxy;
989      }
990      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
991        args[_key] = arguments[_key];
992      }
993      handler.apply(self, args);
994    }
995    onceHandler.__emitterProxy = handler;
996    return self.on(events, onceHandler, priority);
997  },
998  onAny(handler, priority) {
999    const self = this;
1000    if (!self.eventsListeners || self.destroyed) return self;
1001    if (typeof handler !== 'function') return self;
1002    const method = priority ? 'unshift' : 'push';
1003    if (self.eventsAnyListeners.indexOf(handler) < 0) {
1004      self.eventsAnyListeners[method](handler);
1005    }
1006    return self;
1007  },
1008  offAny(handler) {
1009    const self = this;
1010    if (!self.eventsListeners || self.destroyed) return self;
1011    if (!self.eventsAnyListeners) return self;
1012    const index = self.eventsAnyListeners.indexOf(handler);
1013    if (index >= 0) {
1014      self.eventsAnyListeners.splice(index, 1);
1015    }
1016    return self;
1017  },
1018  off(events, handler) {
1019    const self = this;
1020    if (!self.eventsListeners || self.destroyed) return self;
1021    if (!self.eventsListeners) return self;
1022    events.split(' ').forEach(event => {
1023      if (typeof handler === 'undefined') {
1024        self.eventsListeners[event] = [];
1025      } else if (self.eventsListeners[event]) {
1026        self.eventsListeners[event].forEach((eventHandler, index) => {
1027          if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
1028            self.eventsListeners[event].splice(index, 1);
1029          }
1030        });
1031      }
1032    });
1033    return self;
1034  },
1035  emit() {
1036    const self = this;
1037    if (!self.eventsListeners || self.destroyed) return self;
1038    if (!self.eventsListeners) return self;
1039    let events;
1040    let data;
1041    let context;
1042    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
1043      args[_key2] = arguments[_key2];
1044    }
1045    if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1046      events = args[0];
1047      data = args.slice(1, args.length);
1048      context = self;
1049    } else {
1050      events = args[0].events;
1051      data = args[0].data;
1052      context = args[0].context || self;
1053    }
1054    data.unshift(context);
1055    const eventsArray = Array.isArray(events) ? events : events.split(' ');
1056    eventsArray.forEach(event => {
1057      if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
1058        self.eventsAnyListeners.forEach(eventHandler => {
1059          eventHandler.apply(context, [event, ...data]);
1060        });
1061      }
1062      if (self.eventsListeners && self.eventsListeners[event]) {
1063        self.eventsListeners[event].forEach(eventHandler => {
1064          eventHandler.apply(context, data);
1065        });
1066      }
1067    });
1068    return self;
1069  }
1070};
1071
1072function updateSize() {
1073  const swiper = this;
1074  let width;
1075  let height;
1076  const el = swiper.el;
1077  if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
1078    width = swiper.params.width;
1079  } else {
1080    width = el.clientWidth;
1081  }
1082  if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
1083    height = swiper.params.height;
1084  } else {
1085    height = el.clientHeight;
1086  }
1087  if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
1088    return;
1089  }
1090
1091  // Subtract paddings
1092  width = width - parseInt((0,utils.m)(el, 'padding-left') || 0, 10) - parseInt((0,utils.m)(el, 'padding-right') || 0, 10);
1093  height = height - parseInt((0,utils.m)(el, 'padding-top') || 0, 10) - parseInt((0,utils.m)(el, 'padding-bottom') || 0, 10);
1094  if (Number.isNaN(width)) width = 0;
1095  if (Number.isNaN(height)) height = 0;
1096  Object.assign(swiper, {
1097    width,
1098    height,
1099    size: swiper.isHorizontal() ? width : height
1100  });
1101}
1102
1103function updateSlides() {
1104  const swiper = this;
1105  function getDirectionPropertyValue(node, label) {
1106    return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
1107  }
1108  const params = swiper.params;
1109  const {
1110    wrapperEl,
1111    slidesEl,
1112    size: swiperSize,
1113    rtlTranslate: rtl,
1114    wrongRTL
1115  } = swiper;
1116  const isVirtual = swiper.virtual && params.virtual.enabled;
1117  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1118  const slides = (0,utils.e)(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
1119  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1120  let snapGrid = [];
1121  const slidesGrid = [];
1122  const slidesSizesGrid = [];
1123  let offsetBefore = params.slidesOffsetBefore;
1124  if (typeof offsetBefore === 'function') {

1125    offsetBefore = params.slidesOffsetBefore.call(swiper);
1126  }
1127  let offsetAfter = params.slidesOffsetAfter;
1128  if (typeof offsetAfter === 'function') {
1129    offsetAfter = params.slidesOffsetAfter.call(swiper);
1130  }
1131  const previousSnapGridLength = swiper.snapGrid.length;
1132  const previousSlidesGridLength = swiper.slidesGrid.length;
1133  let spaceBetween = params.spaceBetween;
1134  let slidePosition = -offsetBefore;
1135  let prevSlideSize = 0;
1136  let index = 0;
1137  if (typeof swiperSize === 'undefined') {
1138    return;
1139  }
1140  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1141    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
1142  } else if (typeof spaceBetween === 'string') {
1143    spaceBetween = parseFloat(spaceBetween);
1144  }
1145  swiper.virtualSize = -spaceBetween;
1146
1147  // reset margins
1148  slides.forEach(slideEl => {
1149    if (rtl) {
1150      slideEl.style.marginLeft = '';
1151    } else {
1152      slideEl.style.marginRight = '';
1153    }
1154    slideEl.style.marginBottom = '';
1155    slideEl.style.marginTop = '';
1156  });
1157
1158  // reset cssMode offsets
1159  if (params.centeredSlides && params.cssMode) {
1160    (0,utils.s)(wrapperEl, '--swiper-centered-offset-before', '');
1161    (0,utils.s)(wrapperEl, '--swiper-centered-offset-after', '');
1162  }
1163  const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
1164  if (gridEnabled) {
1165    swiper.grid.initSlides(slides);
1166  } else if (swiper.grid) {
1167    swiper.grid.unsetSlides();
1168  }
1169
1170  // Calc slides
1171  let slideSize;
1172  const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
1173    return typeof params.breakpoints[key].slidesPerView !== 'undefined';
1174  }).length > 0;
1175  for (let i = 0; i < slidesLength; i += 1) {
1176    slideSize = 0;
1177    let slide;
1178    if (slides[i]) slide = slides[i];
1179    if (gridEnabled) {
1180      swiper.grid.updateSlide(i, slide, slides);
1181    }
1182    if (slides[i] && (0,utils.m)(slide, 'display') === 'none') continue; // eslint-disable-line
1183
1184    if (params.slidesPerView === 'auto') {
1185      if (shouldResetSlideSize) {
1186        slides[i].style[swiper.getDirectionLabel('width')] = ``;
1187      }
1188      const slideStyles = getComputedStyle(slide);
1189      const currentTransform = slide.style.transform;
1190      const currentWebKitTransform = slide.style.webkitTransform;
1191      if (currentTransform) {
1192        slide.style.transform = 'none';
1193      }
1194      if (currentWebKitTransform) {
1195        slide.style.webkitTransform = 'none';
1196      }
1197      if (params.roundLengths) {
1198        slideSize = swiper.isHorizontal() ? (0,utils.f)(slide, 'width', true) : (0,utils.f)

1198(slide, 'height', true);
1199      } else {
1200        // eslint-disable-next-line
1201        const width = getDirectionPropertyValue(slideStyles, 'width');
1202        const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
1203        const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
1204        const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
1205        const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
1206        const boxSizing = slideStyles.getPropertyValue('box-sizing');
1207        if (boxSizing && boxSizing === 'border-box') {
1208          slideSize = width + marginLeft + marginRight;
1209        } else {
1210          const {
1211            clientWidth,
1212            offsetWidth
1213          } = slide;
1214          slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1215        }
1216      }
1217      if (currentTransform) {
1218        slide.style.transform = currentTransform;
1219      }
1220      if (currentWebKitTransform) {
1221        slide.style.webkitTransform = currentWebKitTransform;
1222      }
1223      if (params.roundLengths) slideSize = Math.floor(slideSize);
1224    } else {
1225      slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
1226      if (params.roundLengths) slideSize = Math.floor(slideSize);
1227      if (slides[i]) {
1228        slides[i].style[swiper.getDirectionLabel('width')] = `${slideSize}px`;
1229      }
1230    }
1231    if (slides[i]) {
1232      slides[i].swiperSlideSize = slideSize;
1233    }
1234    slidesSizesGrid.push(slideSize);
1235    if (params.centeredSlides) {
1236      slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1237      if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1238      if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1239      if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
1240      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1241      if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1242      slidesGrid.push(slidePosition);
1243    } else {
1244      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1245      if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1246      slidesGrid.push(slidePosition);
1247      slidePosition = slidePosition + slideSize + spaceBetween;
1248    }
1249    swiper.virtualSize += slideSize + spaceBetween;
1250    prevSlideSize = slideSize;
1251    index += 1;
1252  }
1253  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1254  if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1255    wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
1256  }
1257  if (params.setWrapperSize) {
1258    wrapperEl.style[swiper.getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;
1259  }
1260  if (gridEnabled) {
1261    swiper.grid.updateWrapperSize(slideSize, snapGrid);
1262  }
1263
1264  // Remove last grid elements depending on width
1265  if (!params.centeredSlides) {
1266    const newSlidesGrid = [];
1267    for (let i = 0; i < snapGrid.length; i += 1) {
1268      let slidesGridItem = snapGrid[i];
1269      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1270      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1271        newSlidesGrid.push(slidesGridItem);
1272      }
1273    }
1274    snapGrid = newSlidesGrid;
1275    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1276      snapGrid.push(swiper.virtualSize - swiperSize);
1277    }
1278  }
1279  if (isVirtual && params.loop) {
1280    const size = slidesSizesGrid[0] + spaceBetween;
1281    if (params.slidesPerGroup > 1) {
1282      const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
1283      const groupSize = size * params.slidesPerGroup;
1284      for (let i = 0; i < groups; i += 1) {
1285        snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1286      }
1287    }
1288    for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1289      if (params.slidesPerGroup === 1) {
1290        snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1291      }
1292      slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1293      swiper.virtualSize += size;
1294    }
1295  }
1296  if (snapGrid.length === 0) snapGrid = [0];
1297  if (spaceBetween !== 0) {
1298    const key = swiper.isHorizontal() && rtl ? 'marginLeft' : swiper.getDirectionLabel('marginRight');
1299    slides.filter((_, slideIndex) => {
1300      if (!params.cssMode || params.loop) return true;
1301      if (slideIndex === slides.length - 1) {
1302        return false;
1303      }
1304      return true;
1305    }).forEach(slideEl => {
1306      slideEl.style[key] = `${spaceBetween}px`;
1307    });
1308  }
1309  if (params.centeredSlides && params.centeredSlidesBounds) {
1310    let allSlidesSize = 0;
1311    slidesSizesGrid.forEach(slideSizeValue => {
1312      allSlidesSize += slideSizeValue + (spaceBetween || 0);
1313    });
1314    allSlidesSize -= spaceBetween;
1315    const maxSnap = allSlidesSize 

1315- swiperSize;
1316    snapGrid = snapGrid.map(snap => {
1317      if (snap <= 0) return -offsetBefore;
1318      if (snap > maxSnap) return maxSnap + offsetAfter;
1319      return snap;
1320    });
1321  }
1322  if (params.centerInsufficientSlides) {
1323    let allSlidesSize = 0;
1324    slidesSizesGrid.forEach(slideSizeValue => {
1325      allSlidesSize += slideSizeValue + (spaceBetween || 0);
1326    });
1327    allSlidesSize -= spaceBetween;
1328    if (allSlidesSize < swiperSize) {
1329      const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1330      snapGrid.forEach((snap, snapIndex) => {
1331        snapGrid[snapIndex] = snap - allSlidesOffset;
1332      });
1333      slidesGrid.forEach((snap, snapIndex) => {
1334        slidesGrid[snapIndex] = snap + allSlidesOffset;
1335      });
1336    }
1337  }
1338  Object.assign(swiper, {
1339    slides,
1340    snapGrid,
1341    slidesGrid,
1342    slidesSizesGrid
1343  });
1344  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1345    (0,utils.s)(wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
1346    (0,utils.s)(wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1347    const addToSnapGrid = -swiper.snapGrid[0];
1348    const addToSlidesGrid = -swiper.slidesGrid[0];
1349    swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1350    swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1351  }
1352  if (slidesLength !== previousSlidesLength) {
1353    swiper.emit('slidesLengthChange');
1354  }
1355  if (snapGrid.length !== previousSnapGridLength) {
1356    if (swiper.params.watchOverflow) swiper.checkOverflow();
1357    swiper.emit('snapGridLengthChange');
1358  }
1359  if (slidesGrid.length !== previousSlidesGridLength) {
1360    swiper.emit('slidesGridLengthChange');
1361  }
1362  if (params.watchSlidesProgress) {
1363    swiper.updateSlidesOffset();
1364  }
1365  swiper.emit('slidesUpdated');
1366  if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1367    const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1368    const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1369    if (slidesLength <= params.maxBackfaceHiddenSlides) {
1370      if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1371    } else if (hasClassBackfaceClassAdded) {
1372      swiper.el.classList.remove(backFaceHiddenClass);
1373    }
1374  }
1375}
1376
1377function updateAutoHeight(speed) {
1378  const swiper = this;
1379  const activeSlides = [];
1380  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1381  let newHeight = 0;
1382  let i;
1383  if (typeof speed === 'number') {
1384    swiper.setTransition(speed);
1385  } else if (speed === true) {
1386    swiper.setTransition(swiper.params.speed);
1387  }
1388  const getSlideByIndex = index => {
1389    if (isVirtual) {
1390      return swiper.slides[swiper.getSlideIndexByData(index)];
1391    }
1392    return swiper.slides[index];
1393  };
1394  // Find slides currently in view
1395  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1396    if (swiper.params.centeredSlides) {

1397      (swiper.visibleSlides || []).forEach(slide => {
1398        activeSlides.push(slide);
1399      });
1400    } else {
1401      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1402        const index = swiper.activeIndex + i;
1403        if (index > swiper.slides.length && !isVirtual) break;
1404        activeSlides.push(getSlideByIndex(index));
1405      }
1406    }
1407  } else {
1408    activeSlides.push(getSlideByIndex(swiper.activeIndex));
1409  }
1410
1411  // Find new height from highest slide in view
1412  for (i = 0; i < activeSlides.length; i += 1) {
1413    if (typeof activeSlides[i] !== 'undefined') {
1414      const height = activeSlides[i].offsetHeight;
1415      newHeight = height > newHeight ? height : newHeight;
1416    }
1417  }
1418
1419  // Update Height
1420  if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;
1421}
1422
1423function updateSlidesOffset() {
1424  const swiper = this;
1425  const slides = swiper.slides;
1426  // eslint-disable-next-line
1427  const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;
1428  for (let i = 0; i < slides.length; i += 1) {
1429    slides[i].swiperSlideOffset = (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) - minusOffset - swiper.cssOverflowAdjustment();
1430  }
1431}
1432
1433function updateSlidesProgress(translate) {
1434  if (translate === void 0) {
1435    translate = this && this.translate || 0;
1436  }
1437  const swiper = this;
1438  const params = swiper.params;
1439  const {
1440    slides,
1441    rtlTranslate: rtl,
1442    snapGrid
1443  } = swiper;
1444  if (slides.length === 0) return;
1445  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
1446  let offsetCenter = -translate;
1447  if (rtl) offsetCenter = translate;
1448
1449  // Visible Slides

1450  slides.forEach(slideEl => {
1451    slideEl.classList.remove(params.slideVisibleClass, params.slideFullyVisibleClass);
1452  });
1453  swiper.visibleSlidesIndexes = [];
1454  swiper.visibleSlides = [];
1455  let spaceBetween = params.spaceBetween;
1456  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1457    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;
1458  } else if (typeof spaceBetween === 'string') {
1459    spaceBetween = parseFloat(spaceBetween);
1460  }
1461  for (let i = 0; i < slides.length; i += 1) {
1462    const slide = slides[i];
1463    let slideOffset = slide.swiperSlideOffset;
1464    if (params.cssMode && params.centeredSlides) {
1465      slideOffset -= slides[0].swiperSlideOffset;
1466    }
1467    const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1468    const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1469    const slideBefore = -(offsetCenter - slideOffset);
1470    const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1471    const isFullyVisible = slideBefore >= 0 && slideBefore <= swiper.size - swiper.slidesSizesGrid[i];
1472    const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1473    if (isVisible) {
1474      swiper.visibleSlides.push(slide);
1475      swiper.visibleSlidesIndexes.push(i);
1476      slides[i].classList.add(params.slideVisibleClass);
1477    }
1478    if (isFullyVisible) {
1479      slides[i].classList.add(params.slideFullyVisibleClass);
1480    }
1481    slide.progress = rtl ? -slideProgress : slideProgress;
1482    slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1483  }
1484}
1485
1486function updateProgress(translate) {
1487  const swiper = this;
1488  if (typeof translate === 'undefined') {
1489    const multiplier = swiper.rtlTranslate ? -1 : 1;
1490    // eslint-disable-next-line
1491    translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
1492  }
1493  const params = swiper.params;
1494  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1495  let {
1496    progress,
1497    isBeginning,
1498    isEnd,
1499    progressLoop
1500  } = swiper;
1501  const wasBeginning = isBeginning;
1502  const wasEnd = isEnd;
1503  if (translatesDiff === 0) {
1504    progress = 0;
1505    isBeginning = true;
1506    isEnd = true;
1507  } else {
1508    progress = (translate - swiper.minTranslate()) / translatesDiff;
1509    const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;
1510    const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;
1511    isBeginning = isBeginningRounded || progress <= 0;
1512    isEnd = isEndRounded || progress >= 1;
1513    if (isBeginningRounded) progress = 0;
1514    if (isEndRounded) progress = 1;
1515  }
1516  if (params.loop) {
1517    const firstSlideIndex = swiper.getSlideIndexByData(0);
1518    const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1519    const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1520    const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1521    const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1522    const translateAbs = Math.abs(translate);
1523    if (translateAbs >= firstSlideTranslate) {
1524      progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
1525    } else {
1526      progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1527    }
1528    if (progressLoop > 1) progressLoop -= 1;
1529  }
1530  Object.assign(swiper, {
1531    progress,
1532    progressLoop,
1533    isBeginning,
1534    isEnd
1535  });
1536  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
1537  if (isBeginning && !wasBeginning) {
1538    swiper.emit('reachBeginning toEdge');
1539  }
1540  if (isEnd && !wasEnd) {
1541    swiper.emit('reachEnd toEdge');
1542  }
1543  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
1544    swiper.emit('fromEdge');
1545  }
1546  swiper.emit('progress', progress);
1547}
1548
1549function updateSlidesClasses() {
1550  const swiper = this;
1551  const {
1552    slides,
1553    params,
1554    slidesEl,
1555    activeIndex
1556  } = swiper;
1557  const isVirtual = swiper.virtual && params.virtual.enabled;
1558  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1559  const getFilteredSlide = selector => {
1560    return (0,utils.e)(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1561  };
1562  slides.forEach(slideEl => {
1563    slideEl.classList.remove(params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
1564  });
1565  let activeSlide;
1566  let prevSlide;
1567  let nextSlide;
1568  if (isVirtual) {
1569    if (params.loop) {
1570      let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1571      if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1572      if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1573      activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1574    } else {
1575      activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1576    }
1577  } else {
1578    if (gridEnabled) {
1579      activeSlide = slides.filter(slideEl => slideEl.column === activeIndex)[0];
1580      nextSlide = slides.filter(slideEl => slideEl.column === activeIndex + 1)[0];
1581      prevSlide = slides.filter(slideEl => slideEl.column === activeIndex - 1)[0];
1582    } else {
1583      activeSlide = slides[activeIndex];
1584    }
1585  }
1586  if (activeSlide) {
1587    // Active classes
1588    activeSlide.classList.add(params.slideActiveClass);
1589    if (gridEnabled) {
1590      if (nextSlide) {
1591        nextSlide.classList.add(params.slideNextClass);
1592      }
1593      if (prevSlide) {
1594        prevSlide.classList.add(params.slidePrevClass);
1595      }
1596    } else {
1597      // Next Slide
1598      nextSlide = (0,utils.o)(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1599      if (params.loop && !nextSlide) {
1600        nextSlide = slides[0];
1601      }
1602      if (nextSlide) {
1603        nextSlide.classList.add(params.slideNextClass);
1604      }
1605
1606      // Prev Slide
1607      prevSlide = (0,utils.p)(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1608      if (params.loop && !prevSlide === 0) {
1609        prevSlide = slides[slides.length - 1];
1610      }
1611      if (prevSlide) {
1612        prevSlide.classList.add(params.slidePrevClass);
1613      }
1614    }
1615  }
1616  swiper.emitSlidesClasses();
1617}
1618
1619const processLazyPreloader = (swiper, imageEl) => {
1620  if (!swiper || swiper.destroyed || !swiper.params) return;
1621  const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1622  const slideEl = imageEl.closest(slideSelector());
1623  if (slideEl) {
1624    let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1625    if (!lazyEl && swiper.isElement) {
1626      if (slideEl.shadowRoot) {
1627        lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1628      } else {
1629        // init later
1630        requestAnimationFrame(() => {
1631          if (slideEl.shadowRoot) {
1632            lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1633            if (lazyEl) lazyEl.remove();
1634          }
1635        });
1636      }
1637    }
1638    if (lazyEl) lazyEl.remove();
1639  }
1640};
1641const unlazy = (swiper, index) => {
1642  if (!swiper.slides[index]) return;
1643  const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1644  if (imageEl) imageEl.removeAttribute('loading');
1645};
1646const preload = swiper => {
1647  if (!swiper || swiper.destroyed || !swiper.params) return;
1648  let amount = swiper.params.lazyPreloadPrevNext;
1649  const len = swiper.slides.length;
1650  if (!len || !amount || amount < 0) return;
1651  amount = Math.min(amount, len);
1652  const slidesPerView = swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1653  const activeIndex = swiper.activeIndex;
1654  if (swiper.params.grid && swiper.params.grid.rows > 1) {
1655    const activeColumn = activeIndex;
1656    const preloadColumns = [activeColumn - amount];
1657    preloadColumns.push(...Array.from({
1658      length: amount
1659    }).map((_, i) => {
1660      return activeColumn + slidesPerView + i;
1661    }));
1662    swiper.slides.forEach((slideEl, i) => {
1663      if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1664    });
1665    return;
1666  }
1667  const slideIndexLastInView = activeIndex + slidesPerView - 1;
1668  if (swiper.params.rewind || swiper.params.loop) {
1669    for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1670      const realIndex = (i % len + len) % len;
1671      if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1672    }
1673  } else {
1674    for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1675      if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1676        unlazy(swiper, i);
1677      }
1678    }
1679  }
1680};
1681
1682function getActiveIndexByTranslate(swiper) {
1683  const {
1684    slidesGrid,
1685    params
1686  } = swiper;
1687  const translate = swiper.rtlTranslate ? swiper.translate : -swi

1687per.translate;
1688  let activeIndex;
1689  for (let i = 0; i < slidesGrid.length; i += 1) {
1690    if (typeof slidesGrid[i + 1] !== 'undefined') {
1691      if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1692        activeIndex = i;
1693      } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1694        activeIndex = i + 1;
1695      }
1696    } else if (translate >= slidesGrid[i]) {
1697      activeIndex = i;
1698    }
1699  }
1700  // Normalize slideIndex
1701  if (params.normalizeSlideIndex) {
1702    if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1703  }
1704  return activeIndex;
1705}
1706function updateActiveIndex(newActiveIndex) {
1707  const swiper = this;
1708  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1709  const {
1710    snapGrid,
1711    params,
1712    activeIndex: previousIndex,
1713    realIndex: previousRealIndex,
1714    snapIndex: previousSnapIndex
1715  } = swiper;
1716  let activeIndex = newActiveIndex;
1717  let snapIndex;
1718  const getVirtualRealIndex = aIndex => {
1719    let realIndex = aIndex - swiper.virtual.slidesBefore;
1720    if (realIndex < 0) {
1721      realIndex = swiper.virtual.slides.length + realIndex;
1722    }
1723    if (realIndex >= swiper.virtual.slides.length) {
1724      realIndex -= swiper.virtual.slides.length;
1725    }
1726    return realIndex;
1727  };
1728  if (typeof activeIndex === 'undefined') {
1729    activeIndex = getActiveIndexByTranslate(swiper);
1730  }
1731  if (snapGrid.indexOf(translate) >= 0) {
1732    snapIndex = snapGrid.indexOf(translate);
1733  } else {
1734    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1735    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1736  }
1737  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1738  if (activeIndex === previousIndex && !swiper.params.loop) {
1739    if (snapIndex !== previousSnapIndex) {
1740      swiper.snapIndex = snapIndex;
1741      swiper.emit('snapIndexChange');
1742    }
1743    return;
1744  }
1745  if (activeIndex === previousIndex && swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1746    swiper.realIndex = getVirtualRealIndex(activeIndex);
1747    return;
1748  }
1749  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1750
1751  // Get real index
1752  let realIndex;
1753  if (swiper.virtual && params.virtual.enabled && params.loop) {
1754    realIndex = getVirtualRealIndex(activeIndex);
1755  } else if (gridEnabled) {
1756    const firstSlideInColumn = swiper.slides.filter(slideEl => slideEl.column === activeIndex)[0];
1757    let activeSlideIndex = parseInt(firstSlideInColumn.getAttribute('data-swiper-slide-index'), 10);
1758    if (Number.isNaN(activeSlideIndex)) {
1759      activeSlideIndex = Math.max(swiper.slides.indexOf(firstSlideInColumn), 0);
1760    }
1761    realIndex = Math.floor(activeSlideIndex / params.grid.rows);
1762  } else if (swiper.slides[activeIndex]) {
1763    const slideIndex = swiper.slides[activeIndex].getAttribute('data-swiper-slide-index');
1764    if (slideIndex) {
1765      realIndex = parseInt(slideIndex, 10);
1766    } else {
1767      realIndex = activeIndex;
1768    }
1769  } else {
1770    realIndex = activeIndex;
1771  }
1772  Object.assign(swiper, {
1773    previousSnapIndex,
1774    snapIndex,
1775    previousRealIndex,
1776    realIndex,
1777    previousIndex,
1778    activeIndex
1779  });
1780  if (swiper.initialized) {
1781    preload(swiper);
1782  }
1783  swiper.emit('activeIndexChange');
1784  swiper.emit('snapIndexChange');
1785  if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1786    if (previousRealIndex !== realIndex) {
1787      swiper.emit('realIndexChange');
1788    }
1789    swiper.emit('slideChange');
1790  }
1791}
1792
1793function updateClickedSlide(el, path) {
1794  const swiper = this;
1795  const params = swiper.params;
1796  let slide = el.closest(`.${params.slideClass}, swiper-slide`);
1797  if (!slide && swiper.isElement && path && path.length > 1 && path.includes(el)) {

1798    [...path.slice(path.indexOf(el) + 1, path.length)].forEach(pathEl => {
1799      if (!slide && pathEl.matches && pathEl.matches(`.${params.slideClass}, swiper-slide`)) {
1800        slide = pathEl;
1801      }
1802    });
1803  }
1804  let slideFound = false;
1805  let slideIndex;
1806  if (slide) {
1807    for (let i = 0; i < swiper.slides.length; i += 1) {
1808      if (swiper.slides[i] === slide) {
1809        slideFound = true;
1810        slideIndex = i;
1811        break;
1812      }
1813    }
1814  }
1815  if (slide && slideFound) {
1816    swiper.clickedSlide = slide;
1817    if (swiper.virtual && swiper.params.virtual.enabled) {
1818      swiper.clickedIndex = parseInt(slide.getAttribute('data-swiper-slide-index'), 10);
1819    } else {
1820      swiper.clickedIndex = slideIndex;
1821    }
1822  } else {
1823    swiper.clickedSlide = undefined;
1824    swiper.clickedIndex = undefined;
1825    return;
1826  }
1827  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1828    swiper.slideToClickedSlide();
1829  }
1830}
1831
1832var update = {
1833  updateSize,
1834  updateSlides,
1835  updateAutoHeight,
1836  updateSlidesOffset,
1837  updateSlidesProgress,
1838  updateProgress,
1839  updateSlidesClasses,
1840  updateActiveIndex,
1841  updateClickedSlide
1842};
1843
1844function getSwiperTranslate(axis) {
1845  if (axis === void 0) {
1846    axis = this.isHorizontal() ? 'x' : 'y';
1847  }
1848  const swiper = this;
1849  const {
1850    params,
1851    rtlTranslate: rtl,
1852    translate,
1853    wrapperEl
1854  } = swiper;
1855  if (params.virtualTranslate) {
1856    return rtl ? -translate : translate;
1857  }
1858  if (params.cssMode) {
1859    return translate;
1860  }
1861  let currentTranslate = (0,utils.i)(wrapperEl, axis);
1862  currentTranslate += swiper.cssOverflowAdjustment();
1863  if (rtl) currentTranslate = -currentTranslate;
1864  return currentTranslate || 0;
1865}
1866
1867function setTranslate(translate, byController) {
1868  const swiper = this;
1869  const {
1870    rtlTranslate: rtl,
1871    params,
1872    wrapperEl,
1873    progress
1874  } = swiper;
1875  let x = 0;
1876  let y = 0;
1877  const z = 0;
1878  if (swiper.isHorizontal()) {
1879    x = rtl ? -translate : translate;
1880  } else {
1881    y = translate;
1882  }
1883  if (params.roundLengths) {
1884    x = Math.floor(x);
1885    y = Math.floor(y);
1886  }
1887  swiper.previousTranslate = swiper.translate;
1888  swiper.translate = swiper.isHorizontal() ? x : y;
1889  if (params.cssMode) {
1890    wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
1891  } else if (!params.virtualTranslate) {
1892    if (swiper.isHorizontal()) {
1893      x -= swiper.cssOverflowAdjustment();
1894    } else {
1895      y -= swiper.cssOverflowAdjustment();
1896    }
1897    wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1898  }
1899
1900  // Check if we need to update progress
1901  let newProgress;
1902  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1903  if (translatesDiff === 0) {
1904    newProgress = 0;
1905  } else {
1906    newProgress = (translate - swiper.minTranslate()) / translatesDiff;
1907  }
1908  if (newProgress !== progress) {
1909    swiper.updateProgress(translate);
1910  }
1911  swiper.emit('setTranslate', swiper.translate, byController);
1912}
1913
1914function minTranslate() {
1915  return -this.snapGrid[0];
1916}
1917
1918function maxTranslate() {
1919  return -this.snapGrid[this.snapGrid.length - 1];
1920}
1921
1922function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
1923  if (translate === void 0) {
1924    translate = 0;
1925  }
1926  if (speed === void 0) {
1927    speed = this.params.speed;
1928  }
1929  if (runCallbacks === void 0) {
1930    runCallbacks = true;
1931  }
1932  if (translateBounds === void 0) {
1933    translateBounds = true;
1934  }
1935  const swiper = this;
1936  const {
1937    params,
1938    wrapperEl
1939  } = swiper;
1940  if (swiper.animating && params.preventInteractionOnTransition) {
1941    return false;
1942  }
1943  const minTranslate = swiper.minTranslate();
1944  const maxTranslate = swiper.maxTranslate();
1945  let newTranslate;
1946  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate;
1947
1948  // Update progress
1949  swiper.updateProgress(newTranslate);
1950  if (params.cssMode) {
1951    const isH = swiper.isHorizontal();
1952    if (speed === 0) {
1953      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1954    } else {
1955      if (!swiper.support.smoothScroll) {
1956        (0,utils.q)({
1957          swiper,
1958          targetPosition: -newTranslate,
1959          side: isH ? 'left' : 'top'
1960        });
1961        return true;
1962      }
1963      wrapperEl.scrollTo({
1964        [isH ? 'left' : 'top']: -newTranslate,
1965        behavior: 'smooth'
1966      });
1967    }
1968    return true;
1969  }
1970  if (speed === 0) {
1971    swiper.setTransition(0);
1972    swiper.setTranslate(newTranslate);
1973    if (runCallbacks) {
1974      swiper.emit('beforeTransitionStart', speed, internal);
1975      swiper.emit('transitionEnd');
1976    }
1977  } else {
1978    swiper.setTransition(speed);
1979    swiper.setTranslate(newTranslate);
1980    if (runCallbacks) {
1981      swiper.emit('beforeTransitionStart', speed, internal);
1982      swiper.emit('transitionStart');
1983    }
1984    if (!swiper.animating) {
1985      swiper.animating = true;
1986      if (!swiper.onTranslateToWrapperTransitionEnd) {
1987        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1988          if (!swiper || swiper.destroyed) return;
1989          if (e.target !== this) return;
1990          swiper.wrapperEl.removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1991          swiper.onTranslateToWrapperTransitionEnd = null;
1992          delete swiper.onTranslateToWrapperTransitionEnd;
1993          if (runCallbacks) {
1994            swiper.emit('transitionEnd');
1995          }
1996        };
1997      }
1998      swiper.wrapperEl.addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1999    }
2000  }
2001  return true;
2002}
2003
2004var translate = {
2005  getTranslate: getSwiperTranslate,
2006  setTranslate,
2007  minTranslate,
2008  maxTranslate,
2009  translateTo
2010};
2011
2012function setTransition(duration, byController) {
2013  const swiper = this;
2014  if (!swiper.params.cssMode) {
2015    swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
2016    swiper.wrapperEl.style.transitionDelay = duration === 0 ? `0ms` : '';
2017  }
2018  swiper.emit('setTransition', duration, byController);
2019}
2020
2021function transitionEmit(_ref) {
2022  let {
2023    swiper,
2024    runCallbacks,
2025    direction,
2026    step
2027  } = _ref;
2028  const {
2029    activeIndex,
2030    previousIndex
2031  } = swiper;
2032  let dir = direction;
2033  if (!dir) {
2034    if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
2035  }
2036  swiper.emit(`transition${step}`);
2037  if (runCallbacks && activeIndex !== previousIndex) {
2038    if (dir === 'reset') {
2039      swiper.emit(`slideResetTransition${step}`);
2040      return;
2041    }
2042    swiper.emit(`slideChangeTransition${step}`);
2043    if (dir === 'next') {
2044      swiper.emit(`slideNextTransition${step}`);
2045    } else {
2046      swiper.emit(`slidePrevTransition${step}`);
2047    }
2048  }
2049}
2050
2051function transitionStart(runCallbacks, direction) {
2052  if (runCallbacks === void 0) {
2053    runCallbacks = true;
2054  }
2055  const swiper = this;
2056  const {
2057    params
2058  } = swiper;
2059  if (params.cssMode) return;
2060  if (params.autoHeight) {
2061    swiper.updateAutoHeight();
2062  }
2063  transitionEmit({
2064    swiper,
2065    runCallbacks,
2066    direction,
2067    step: 'Start'
2068  });
2069}
2070
2071function transitionEnd(runCallbacks, direction) {
2072  if (runCallbacks === void 0) {
2073    runCallbacks = true;
2074  }
2075  const swiper = this;
2076  const {
2077    params
2078  } = swiper;
2079  swiper.animating = false;
2080  if (params.cssMode) return;
2081  swiper.setTransition(0);
2082  transitionEmit({
2083    swiper,
2084    runCallbacks,
2085    direction,
2086    step: 'End'
2087  });
2088}
2089
2090var transition = {
2091  setTransition,
2092  transitionStart,
2093  transitionEnd
2094};
2095
2096function slideTo(index, speed, runCallbacks, internal, initial) {
2097  if (index === void 0) {
2098    index = 0;
2099  }
2100  if (speed === void 0) {
2101    speed = this.params.speed;
2102  }
2103  if (runCallbacks === void 0) {
2104    runCallbacks = true;
2105  }
2106  if (typeof index === 'string') {
2107    index = parseInt(index, 10);
2108  }
2109  const swiper = this;
2110  let slideIndex = index;
2111  if (slideIndex < 0) slideIndex = 0;
2112  const {
2113    params,
2114    snapGrid,
2115    slidesGrid,
2116    previousIndex,
2117    activeIndex,
2118    rtlTranslate: rtl,
2119    wrapperEl,
2120    enabled
2121  } = swiper;
2122  if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
2123    return false;
2124  }
2125  const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
2126  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
2127  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2128  const translate = -snapGrid[snapIndex];
2129  // Normalize slideIndex
2130  if (params.normalizeSlideIndex) {
2131    for (let i = 0; i < slidesGrid.length; i += 1) {
2132      const normalizedTranslate = -Math.floor(translate * 100);
2133      const normalizedGrid = Math.floor(slidesGrid[i] * 100);
2134      const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
2135      if (typeof slidesGrid[i + 1] !== 'undefined') {
2136        if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
2137          slideIndex = i;
2138        } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
2139          slideIndex = i + 1;
2140        }
2141      } else if (normalizedTranslate >= normalizedGrid) {
2142        slideIndex = i;
2143      }
2144    }
2145  }
2146  // Directions locks
2147  if (swiper.initialized && slideIndex !== activeIndex) {
2148    if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) {
2149      return false;
2150    }
2151    if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
2152      if ((activeIndex || 0) !== slideIndex) {
2153        return false;
2154      }
2155    }
2156  }
2157  if (slideIndex !== (previousIndex || 0) && runCallbacks) {
2158    swiper.emit('beforeSlideChangeStart');
2159  }
2160
2161  // Update progress
2162  swiper.updateProgress(translate);
2163  let direction;
2164  if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset';
2165
2166  // Update Index
2167  if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {
2168    swiper.updateActiveIndex(slideIndex);
2169    // Update Height
2170    if (params.autoHeight) {
2171      swiper.updateAutoHeight();
2172    }
2173    swiper.updateSlidesClasses();
2174    if (params.effect !== 'slide') {
2175      swiper.setTranslate(translate);
2176    }
2177    if (direction !== 'reset') {
2178      swiper.transitionStart(runCallbacks, direction);
2179      swiper.transitionEnd(runCallbacks, direction);
2180    }
2181    return false;
2182  }
2183  if (params.cssMode) {
2184    const isH = swiper.isHorizontal();
2185    const t = rtl ? translate : -translate;
2186    if (speed === 0) {
2187      const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2188      if (isVirtual) {
2189        swiper.wrapperEl.style.scrollSnapType = 'none';
2190        swiper._immediateVirtual = true;
2191      }
2192      if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
2193        swiper._cssModeVirtualInitialSet = true;
2194        requestAnimationFrame(() => {
2195          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
2196        });
2197      } else {
2198        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
2199      }
2200      if (isVirtual) {
2201        requestAnimationFrame(() => {
2202          swiper.wrapperEl.style.scrollSnapType = '';
2203          swiper._immediateVirtual = false;
2204        });
2205      }
2206    } else {
2207      if (!swiper.support.smoothScroll) {
2208        (0,utils.q)({
2209          swiper,
2210          targetPosition: t,
2211          side: isH ? 'left' : 'top'
2212        });
2213        return true;
2214      }
2215      wrapperEl.scrollTo({
2216        [isH ? 'left' : 'top']: t,
2217        behavior: 'smooth'
2218      });
2219    }
2220    return true;
2221  }
2222  swiper.setTransition(speed);
2223  swiper.setTranslate(translate);
2224  swiper.updateActiveIndex(slideIndex);
2225  swiper.updateSlidesClasses();
2226  swiper.emit('beforeTransitionStart', speed, internal);
2227  swiper.transitionStart(runCallbacks, direction);
2228  if (speed === 0) {
2229    swiper.transitionEnd(runCallbacks, direction);
2230  } else if (!swiper.animating) {
2231    swiper.animating = true;
2232    if (!swiper.onSlideToWrapperTransitionEnd) {
2233      swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2234        if (!swiper || swiper.destroyed) return;
2235        if (e.target !== this) return;
2236        swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2237        swiper.onSlideToWrapperTransitionEnd = null;
2238        delete swiper.onSlideToWrapperTransitionEnd;
2239        swiper.transitionEnd(runCallbacks, direction);
2240      };
2241    }
2242    swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2243  }
2244  return true;
2245}
2246
2247function slideToLoop(index, speed, runCallbacks, internal) {
2248  if (index === void 0) {
2249    index = 0;
2250  }
2251  if (speed === void 0) {
2252    speed = this.params.speed;
2253  }
2254  if (runCallbacks === void 0) {
2255    runCallbacks = true;
2256  }
2257  if (typeof index === 'string') {
2258    const indexAsNumber = parseInt(index, 10);
2259    index = indexAsNumber;
2260  }
2261  const swiper = this;
2262  const gridEnabled = swiper.grid && swiper.params.grid && swiper.params.grid.rows > 1;
2263  let newIndex = index;
2264  if (swiper.params.loop) {
2265    if (swiper.virtual && swiper.params.virtual.enabled) {
2266      // eslint-disable-next-line
2267      newIndex = newIndex + swiper.virtual.slidesBefore;
2268    } else {
2269      let targetSlideIndex;
2270      if (gridEnabled) {
2271        const slideIndex = newIndex * swiper.params.grid.rows;
2272        targetSlideIndex = swiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex)[0].column;
2273      } else {
2274        targetSlideIndex = swiper.getSlideIndexByData(newIndex);
2275      }
2276      const cols = gridEnabled ? Math.ceil(swiper.slides.length / swiper.params.grid.rows) : swiper.slides.length;
2277      const {
2278        centeredSlides
2279      } = swiper.params;
2280      let slidesPerView = swiper.params.slidesPerView;
2281      if (slidesPerView === 'auto') {
2282        slidesPerView = swiper.slidesPerViewDynamic();
2283      } else {
2284        slidesPerView = Math.ceil(parseFloat(swiper.params.slidesPerView, 10));
2285        if (centeredSlides && slidesPerView % 2 === 0) {
2286          slidesPerView = slidesPerView + 1;
2287        }
2288      }
2289      let needLoopFix = cols - targetSlideIndex < slidesPerView;
2290      if (centeredSlides) {
2291        needLoopFix = needLoopFix || targetSlideIndex < Math.ceil(slidesPerView / 2);
2292      }
2293      if (needLoopFix) {
2294        const direction = centeredSlides ? targetSlideIndex < swiper.activeIndex ? 'prev' : 'next' : targetSlideIndex - swiper.activeIndex - 1 < swiper.params.slidesPerView ? 'next' : 'prev';
2295        swiper.loopFix({
2296          direction,
2297          slideTo: true,
2298          activeSlideIndex: direction === 'next' ? targetSlideIndex + 1 : targetSlideIndex - cols + 1,
2299          slideRealIndex: direction === 'next' ? swiper.realIndex : undefined
2300        });
2301      }
2302      if (gridEnabled) {
2303        const slideIndex = newIndex * swiper.params.grid.rows;
2304        newIndex = swiper.slides.filter(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex)[0].column;
2305      } else {
2306        newIndex = swiper.getSlideIndexByData(newIndex);
2307      }
2308    }
2309  }
2310  requestAnimationFrame(() => {
2311    swiper.slideTo(newIndex, speed, runCallbacks, internal);
2312  });
2313  return swiper;
2314}
2315
2316/* eslint no-unused-vars: "off" */
2317function slideNext(speed, runCallbacks, internal) {
2318  if (speed === void 0) {
2319    speed = this.params.speed;
2320  }
2321  if (runCallbacks === void 0) {
2322    runCallbacks = true;
2323  }
2324  const swiper = this;
2325  const {
2326    enabled,
2327    params,
2328    animating
2329  } = swiper;
2330  if (!enabled) return swiper;
2331  let perGroup = params.slidesPerGroup;
2332  if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2333    perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
2334  }
2335  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2336  const isVirtual = swiper.virtual && params.virtual.enabled;
2337  if (params.loop) {
2338    if (animating && !isVirtual && params.loopPreventsSliding) return false;
2339    swiper.loopFix({
2340      direction: 'next'
2341    });
2342    // eslint-disable-next-line
2343    swiper._clientLeft = swiper.wrapperEl.clientLeft;
2344    if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
2345      requestAnimationFrame(() => {
2346        swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2347      });
2348      return true;
2349    }
2350  }
2351  if (params.rewind && swiper.isEnd) {
2352    return swiper.slideTo(0, speed, runCallbacks, internal);
2353  }
2354  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2355}
2356
2357/* eslint no-unused-vars: "off" */
2358function slidePrev(speed, runCallbacks, internal) {
2359  if (speed === void 0) {
2360    speed = this.params.speed;
2361  }
2362  if (runCallbacks === void 0) {
2363    runCallbacks = true;
2364  }
2365  const swiper = this;
2366  const {
2367    params,
2368    snapGrid,
2369    slidesGrid,
2370    rtlTranslate,
2371    enabled,
2372    animating
2373  } = swiper;
2374  if (!enabled) return swiper;
2375  const isVirtual = swiper.virtual && params.virtual.enabled;
2376  if (params.loop) {
2377    if (animating && !isVirtual && params.loopPreventsSliding) return false;
2378    swiper.loopFix({
2379      direction: 'prev'
2380    });
2381    // eslint-disable-next-line
2382    swiper._clientLeft = swiper.wrapperEl.clientLeft;
2383  }
2384  const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2385  function normalize(val) {
2386    if (val < 0) return -Math.floor(Math.abs(val));
2387    return Math.floor(val);
2388  }
2389  const normalizedTranslate = normalize(translate);
2390  const normalizedSnapGrid = snapGrid.map(val => normalize(val));
2391  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2392  if (typeof prevSnap === 'undefined' && params.cssMode) {
2393    let prevSnapIndex;

2394    snapGrid.forEach((snap, snapIndex) => {
2395      if (normalizedTranslate >= snap) {
2396        // prevSnap = snap;
2397        prevSnapIndex = snapIndex;
2398      }
2399    });
2400    if (typeof prevSnapIndex !== 'undefined') {
2401      prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2402    }
2403  }
2404  let prevIndex = 0;
2405  if (typeof prevSnap !== 'undefined') {
2406    prevIndex = slidesGrid.indexOf(prevSnap);
2407    if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2408    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2409      prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2410      prevIndex = Math.max(prevIndex, 0);
2411    }
2412  }
2413  if (params.rewind && swiper.isBeginning) {
2414    const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2415    return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2416  } else if (params.loop && swiper.activeIndex === 0 && params.cssMode) {
2417    requestAnimationFrame(() => {
2418      swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2419    });
2420    return true;
2421  }
2422  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2423}
2424
2425/* eslint no-unused-vars: "off" */
2426function slideReset(speed, runCallbacks, internal) {
2427  if (speed === void 0) {
2428    speed = this.params.speed;
2429  }
2430  if (runCallbacks === void 0) {
2431    runCallbacks = true;
2432  }
2433  const swiper = this;
2434  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2435}
2436
2437/* eslint no-unused-vars: "off" */
2438function slideToClosest(speed, runCallbacks, internal, threshold) {
2439  if (speed === void 0) {
2440    speed = this.params.speed;
2441  }
2442  if (runCallbacks === void 0) {
2443    runCallbacks = true;
2444  }
2445  if (threshold === void 0) {
2446    threshold = 0.5;
2447  }
2448  const swiper = this;
2449  let index = swiper.activeIndex;
2450  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2451  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2452  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2453  if (translate >= swiper.snapGrid[snapIndex]) {
2454    // The current translate is on or after the current snap index, so the choice
2455    // is between the current index and the one after it.
2456    const currentSnap = swiper.snapGrid[snapIndex];
2457    const nextSnap = swiper.snapGrid[snapIndex + 1];
2458    if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
2459      index += swiper.params.slidesPerGroup;
2460    }
2461  } else {
2462    // The current translate is before the current snap index, so the choice
2463    // is between the current index and the one before it.
2464    const prevSnap = swiper.snapGrid[snapIndex - 1];
2465    const currentSnap = swiper.snapGrid[snapIndex];
2466    if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
2467      index -= swiper.params.slidesPerGroup;
2468    }
2469  }
2470  index = Math.max(index, 0);
2471  index = Math.min(index, swiper.slidesGrid.length - 1);
2472  return swiper.slideTo(index, speed, runCallbacks, internal);
2473}
2474
2475function slideToClickedSlide() {
2476  const swiper = this;
2477  const {
2478    params,
2479    slidesEl
2480  } = swiper;
2481  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2482  let slideToIndex = swiper.clickedIndex;
2483  let realIndex;
2484  const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2485  if (params.loop) {
2486    if (swiper.animating) return;
2487    realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
2488    if (params.centeredSlides) {
2489      if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2490        swiper.loopFix();
2491        slideToIndex = swiper.getSlideIndex((0,utils.e)(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2492        (0,utils.n)(() => {
2493          swiper.slideTo(slideToIndex);
2494        });
2495      } else {
2496        swiper.slideTo(slideToIndex);
2497      }
2498    } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2499      swiper.loopFix();
2500      slideToIndex = swiper.getSlideIndex((0,utils.e)(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2501      (0,utils.n)(() => {
2502        swiper.slideTo(slideToIndex);
2503      });
2504    } else {
2505      swiper.slideTo(slideToIndex);
2506    }
2507  } else {
2508    swiper.slideTo(slideToIndex);
2509  }
2510}
2511
2512var slide = {
2513  slideTo,
2514  slideToLoop,
2515  slideNext,
2516  slidePrev,
2517  slideReset,
2518  slideToClosest,
2519  slideToClickedSlide
2520};
2521
2522function loopCreate(slideRealIndex) {
2523  const swiper = this;
2524  const {
2525    params,
2526    slidesEl
2527  } = swiper;
2528  if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2529  const initSlides = () => {
2530    const slides = (0,utils.e)(slidesEl, `.${params.slideClass}, swiper-slide`);
2531    slides.forEach((el, index) => {
2532      el.setAttribute('data-swiper-slide-index', index);
2533    });
2534  };
2535  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2536  const slidesPerGroup = params.slidesPerGroup * (gridEnabled ? params.grid.rows : 1);
2537  const shouldFillGroup = swiper.slides.length % slidesPerGroup !== 0;
2538  const shouldFillGrid = gridEnabled && swiper.slides.length % params.grid.rows !== 0;
2539  const addBlankSlides = amountOfSlides => {
2540    for (let i = 0; i < amountOfSlides; i += 1) {
2541      const slideEl = swiper.isElement ? (0,utils.c)('swiper-slide', [params.slideBlankClass]) : (0,utils.c)('div', [params.slideClass, params.slideBlankClass]);
2542      swiper.slidesEl.append(slideEl);
2543    }
2544  };
2545  if (shouldFillGroup) {
2546    if (params.loopAddBlankSlides) {
2547      const slidesToAdd = slidesPerGroup - swiper.slides.length % slidesPerGroup;
2548      addBlankSlides(slidesToAdd);
2549      swiper.recalcSlides();
2550      swiper.updateSlides();
2551    } else {
2552      (0,utils.r)('Swiper Loop Warning: The number of slides is not even to slidesPerGroup, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)');
2553    }
2554    initSlides();
2555  } else if (shouldFillGrid) {
2556    if (params.loopAddBlankSlides) {
2557      const slidesToAdd = params.grid.rows - swiper.slides.length % params.grid.rows;
2558      addBlankSlides(slidesToAdd);
2559      swiper.recalcSlides();
2560      swiper.updateSlides();
2561    } else {
2562      (0,utils.r)('Swiper Loop Warning: The number of slides is not even to grid.rows, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)');
2563    }
2564    initSlides();
2565  } else {
2566    initSlides();
2567  }
2568  swiper.loopFix({
2569    slideRealIndex,
2570    direction: params.centeredSlides ? undefined : 'next'
2571  });
2572}
2573
2574function loopFix(_temp) {
2575  let {
2576    slideRealIndex,
2577    slideTo = true,
2578    direction,
2579    setTranslate,
2580    activeSlideIndex,
2581    byController,
2582    byMousewheel
2583  } = _temp === void 0 ? {} : _temp;
2584  const swiper = this;
2585  if (!swiper.params.loop) return;
2586  swiper.emit('beforeLoopFix');
2587  const {
2588    slides,
2589    allowSlidePrev,
2590    allowSlideNext,
2591    slidesEl,
2592    params
2593  } = swiper;
2594  const {
2595    centeredSlides
2596  } = params;
2597  swiper.allowSlidePrev = true;
2598  swiper.allowSlideNext = true;
2599  if (swiper.virtual && params.virtual.enabled) {
2600    if (slideTo) {
2601      if (!params.centeredSlides && swiper.snapIndex === 0) {
2602        swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
2603      } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
2604        swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
2605      } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
2606        swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2607      }
2608    }
2609    swiper.allowSlidePrev = allowSlidePrev;
2610    swiper.allowSlideNext = allowSlideNext;
2611    swiper.emit('loopFix');
2612    return;
2613  }
2614  let slidesPerView = params.slidesPerView;
2615  if (slidesPerView === 'auto') {
2616    slidesPerView = swiper.slidesPerViewDynamic();
2617  } else {
2618    slidesPerView = Math.ceil(parseFloat(params.slidesPerView, 10));
2619    if (centeredSlides && slidesPerView % 2 === 0) {
2620      slidesPerView = slidesPerView + 1;
2621    }
2622  }
2623  const slidesPerGroup = params.slidesPerGroupAuto ? slidesPerView : params.slidesPerGroup;
2624  let loopedSlides = slidesPerGroup;
2625  if (loopedSlides % slidesPerGroup !== 0) {
2626    loopedSlides += slidesPerGroup - loopedSlides % slidesPerGroup;
2627  }
2628  loopedSlides += params.loopAdditionalSlides;
2629  swiper.loopedSlides = loopedSlides;
2630  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2631  if (slides.length < slidesPerView + loopedSlides) {
2632    (0,utils.r)('Swiper Loop Warning: The number of slides is not enough for loop mode, it will be disabled and not function properly. You need to add more slides (or make duplicates) or lower the values of slidesPerView and slidesPerGroup parameters');
2633  } else if (gridEnabled && params.grid.fill === 'row') {
2634    (0,utils.r)('Swiper Loop Warning: Loop mode is not compatible with grid.fill = `row`');
2635  }
2636  const prependSlidesIndexes = [];
2637  const appendSlidesIndexes = [];
2638  let activeIndex = swiper.activeIndex;
2639  if (typeof activeSlideIndex === 'undefined') {
2640    activeSlideIndex = swiper.getSlideIndex(slides.filter(el => el.classList.contains(params.slideActiveClass))[0]);
2641  } else {
2642    activeIndex = activeSlideIndex;
2643  }
2644  const isNext = direction === 'next' || !direction;
2645  const isPrev = direction === 'prev' || !direction;
2646  let slidesPrepended = 0;
2647  let slidesAppended = 0;
2648  const cols = gridEnabled ? Math.ceil(slides.length / params.grid.rows) : slides.length;
2649  const activeColIndex = gridEnabled ? slides[activeSlideIndex].column : activeSlideIndex;
2650  const activeColIndexWithShift = activeColIndex + (centeredSlides && typeof setTranslate === 'undefined' ? -slidesPerView / 2 + 0.5 : 0);
2651  // prepend last slides before start
2652  if (activeColIndexWithShift < loopedSlides) {
2653    slidesPrepended = Math.max(loopedSlides - activeColIndexWithShift, slidesPerGroup);
2654    for (let i = 0; i < loopedSlides - activeColIndexWithShift; i += 1) {