https://www.eifel-direkt.de/_assets/1798f66a72c0609b2ee5b404d10475…/Components/Teasers.62baa6019b395b09968b.js

1/******/ (() => { // webpackBootstrap
2/******/ 	"use strict";
3// This entry needs to be wrapped in an IIFE because it needs to be isolated against other entry modules.
4(() => {
5// extracted by mini-css-extract-plugin
6
7})();
8
9// This entry needs to be wrapped in an IIFE because it needs to be isolated against other entry modules.
10(() => {
11
12
13document.querySelectorAll('.themes__item').forEach(asset => {
14  const video = asset.querySelector('video');
15  const button = asset.querySelector('.moviebutton');
16  if (video && button) {
17    const text = button.querySelector('span');
18    const icon = button.querySelector('iconify-icon');
19    button.addEventListener('click', () => {
20      if (video.paused) {
21        video.dataset.playing = '1';
22        video.play();
23      } else {
24        video.dataset.playing = '0';
25        video.pause();
26      }
27    });
28    video.addEventListener('play', () => {
29      text.innerText = button.dataset.textPause || '';
30      icon.setAttribute('icon', button.dataset.iconPause || '');
31    });
32    video.addEventListener('pause', () => {
33      text.innerText = button.dataset.textPlay || '';
34      icon.setAttribute('icon', button.dataset.iconPlay || '');
35    });
36  }
37});
38})();
39
40// This entry needs to be wrapped in an IIFE because it needs to be isolated against other entry modules.
41(() => {
42
43;// ./node_modules/swiper/shared/ssr-window.esm.mjs
44/**
45 * SSR Window 5.0.0
46 * Better handling for window object in SSR environment
47 * https://github.com/nolimits4web/ssr-window
48 *
49 * Copyright 2025, Vladimir Kharlampidi
50 *
51 * Licensed under MIT
52 *
53 * Released on: February 12, 2025
54 */
55/* eslint-disable no-param-reassign */
56function isObject(obj) {
57  return obj !== null && typeof obj === 'object' && 'constructor' in obj && obj.constructor === Object;
58}
59function extend(target, src) {
60  if (target === void 0) {
61    target = {};
62  }
63  if (src === void 0) {
64    src = {};
65  }
66  const noExtend = ['__proto__', 'constructor', 'prototype'];
67  Object.keys(src).filter(key => noExtend.indexOf(key) < 0).forEach(key => {
68    if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject(src[key]) && isObject(target[key]) && Object.keys(src[key]).length > 0) {
69      extend(target[key], src[key]);
70    }
71  });
72}
73const ssrDocument = {
74  body: {},
75  addEventListener() {},
76  removeEventListener() {},
77  activeElement: {
78    blur() {},
79    nodeName: ''
80  },
81  querySelector() {
82    return null;
83  },
84  querySelectorAll() {
85    return [];
86  },
87  getElementById() {
88    return null;
89  },
90  createEvent() {
91    return {
92      initEvent() {}
93    };
94  },
95  createElement() {
96    return {
97      children: [],
98      childNodes: [],
99      style: {},
100      setAttribute() {},
101      getElementsByTagName() {
102        return [];
103      }
104    };
105  },
106  createElementNS() {
107    return {};
108  },
109  importNode() {
110    return null;
111  },
112  location: {
113    hash: '',
114    host: '',
115    hostname: '',
116    href: '',
117    origin: '',
118    pathname: '',
119    protocol: '',
120    search: ''
121  }
122};
123function getDocument() {
124  const doc = typeof document !== 'undefined' ? document : {};
125  extend(doc, ssrDocument);
126  return doc;
127}
128const ssrWindow = {
129  document: ssrDocument,
130  navigator: {
131    userAgent: ''
132  },
133  location: {
134    hash: '',
135    host: '',
136    hostname: '',
137    href: '',
138    origin: '',
139    pathname: '',
140    protocol: '',
141    search: ''
142  },
143  history: {
144    replaceState() {},
145    pushState() {},
146    go() {},
147    back() {}
148  },
149  CustomEvent: function CustomEvent() {
150    return this;
151  },
152  addEventListener() {},
153  removeEventListener() {},
154  getComputedStyle() {
155    return {
156      getPropertyValue() {
157        return '';
158      }
159    };
160  },
161  Image() {},
162  Date() {},
163  screen: {},
164  setTimeout() {},
165  clearTimeout() {},
166  matchMedia() {
167    return {};
168  },
169  requestAnimationFrame(callback) {
170    if (typeof setTimeout === 'undefined') {
171      callback();
172      return null;
173    }
174    return setTimeout(callback, 0);
175  },
176  cancelAnimationFrame(id) {
177    if (typeof setTimeout === 'undefined') {
178      return;
179    }
180    clearTimeout(id);
181  }
182};
183function getWindow() {
184  const win = typeof window !== 'undefined' ? window : {};
185  extend(win, ssrWindow);
186  return win;
187}
188
189
190
191;// ./node_modules/swiper/shared/utils.mjs
192
193

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

348    let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
349    if (isOutOfBound(currentPosition, targetPosition)) {
350      currentPosition = targetPosition;
351    }
352    swiper.wrapperEl.scrollTo({
353      [side]: currentPosition
354    });
355    if (isOutOfBound(currentPosition, targetPosition)) {
356      swiper.wrapperEl.style.overflow = 'hidden';
357      swiper.wrapperEl.style.scrollSnapType = '';
358      setTimeout(() => {
359        swiper.wrapperEl.style.overflow = '';
360        swiper.wrapperEl.scrollTo({
361          [side]: currentPosition
362        });
363      });
364      window.cancelAnimationFrame(swiper.cssModeFrameID);
365      return;
366    }
367    swiper.cssModeFrameID = window.requestAnimationFrame(animate);
368  };
369  animate();
370}
371function getSlideTransformEl(slideEl) {
372  return slideEl.querySelector('.swiper-slide-transform') || slideEl.shadowRoot && slideEl.shadowRoot.querySelector('.swiper-slide-transform') || slideEl;
373}
374function elementChildren(element, selector) {
375  if (selector === void 0) {
376    selector = '';
377  }
378  const window = getWindow();
379  const children = [...element.children];
380  if (window.HTMLSlotElement && element instanceof HTMLSlotElement) {
381    children.push(...element.assignedElements());
382  }
383  if (!selector) {
384    return children;
385  }
386  return children.filter(el => el.matches(selector));
387}
388function elementIsChildOfSlot(el, slot) {
389  // Breadth-first search through all parent's children and assigned elements
390  const elementsQueue = [slot];
391  while (elementsQueue.length > 0) {
392    const elementToCheck = elementsQueue.shift();
393    if (el === elementToCheck) {
394      return true;
395    }
396    elementsQueue.push(...elementToCheck.children, ...(elementToCheck.shadowRoot?.children || []), ...(elementToCheck.assignedElements?.() || []));
397  }
398}
399function elementIsChildOf(el, parent) {
400  const window = getWindow();
401  let isChild = parent.contains(el);
402  if (!isChild && window.HTMLSlotElement && parent instanceof HTMLSlotElement) {
403    const children = [...parent.assignedElements()];
404    isChild = children.includes(el);
405    if (!isChild) {
406      isChild = elementIsChildOfSlot(el, parent);
407    }
408  }
409  return isChild;
410}
411function showWarning(text) {
412  try {
413    console.warn(text);
414    return;
415  } catch (err) {
416    // err
417  }
418}
419function createElement(tag, classes) {
420  if (classes === void 0) {
421    classes = [];
422  }
423  const el = document.createElement(tag);
424  el.classList.add(...(Array.isArray(classes) ? classes : classesToTokens(classes)));
425  return el;
426}
427function elementOffset(el) {
428  const window = getWindow();
429  const document = getDocument();
430  const box = el.getBoundingClientRect();
431  const body = document.body;
432  const clientTop = el.clientTop || body.clientTop || 0;
433  const clientLeft = el.clientLeft || body.clientLeft || 0;
434  const scrollTop = el === window ? window.scrollY : el.scrollTop;
435  const scrollLeft = el === window ? window.scrollX : el.scrollLeft;
436  return {
437    top: box.top + scrollTop - clientTop,
438    left: box.left + scrollLeft - clientLeft
439  };
440}
441function elementPrevAll(el, selector) {
442  const prevEls = [];
443  while (el.previousElementSibling) {
444    const prev = el.previousElementSibling; // eslint-disable-line
445    if (selector) {
446      if (prev.matches(selector)) prevEls.push(prev);
447    } else prevEls.push(prev);
448    el = prev;
449  }
450  return prevEls;
451}
452function elementNextAll(el, selector) {
453  const nextEls = [];
454  while (el.nextElementSibling) {
455    const next = el.nextElementSibling; // eslint-disable-line
456    if (selector) {
457      if (next.matches(selector)) nextEls.push(next);
458    } else nextEls.push(next);
459    el = next;
460  }
461  return nextEls;
462}
463function elementStyle(el, prop) {
464  const window = getWindow();
465  return window.getComputedStyle(el, null).getPropertyValue(prop);
466}
467function elementIndex(el) {
468  let child = el;
469  let i;
470  if (child) {
471    i = 0;
472    // eslint-disable-next-line
473    while ((child = child.previousSibling) !== null) {
474      if (child.nodeType === 1) i += 1;
475    }
476    return i;
477  }
478  return undefined;
479}
480function elementParents(el, selector) {
481  const parents = []; // eslint-disable-line
482  let parent = el.parentElement; // eslint-disable-line
483  while (parent) {
484    if (selector) {
485      if (parent.matches(selector)) parents.push(parent);
486    } else {
487      parents.push(parent);
488    }
489    parent = parent.parentElement;
490  }
491  return parents;
492}
493function elementTransitionEnd(el, callback) {
494  function fireCallBack(e) {
495    if (e.target !== el) return;
496    callback.call(el, e);
497    el.removeEventListener('transitionend', fireCallBack);
498  }
499  if (callback) {
500    el.addEventListener('transitionend', fireCallBack);
501  }
502}
503function elementOuterSize(el, size, includeMargins) {
504  const window = getWindow();
505  if (includeMargins) {
506    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'));
507  }
508  return el.offsetWidth;
509}
510function makeElementsArray(el) {
511  return (Array.isArray(el) ? el : [el]).filter(e => !!e);
512}
513function getRotateFix(swiper) {
514  return v => {
515    if (Math.abs(v) > 0 && swiper.browser && swiper.browser.need3dFix && Math.abs(v) % 90 === 0) {
516      return v + 0.001;
517    }
518    return v;
519  };
520}
521
522
523
524;// ./node_modules/swiper/shared/swiper-core.mjs
525
526
527
528let support;
529function calcSupport() {
530  const window = getWindow();
531  const document = getDocument();
532  return {
533    smoothScroll: document.documentElement && document.documentElement.style && 'scrollBehavior' in document.documentElement.style,
534    touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch)
535  };
536}

537function getSupport() {
538  if (!support) {
539    support = calcSupport();
540  }
541  return support;
542}
543
544let deviceCached;
545function calcDevice(_temp) {
546  let {
547    userAgent
548  } = _temp === void 0 ? {} : _temp;
549  const support = getSupport();
550  const window = getWindow();
551  const platform = window.navigator.platform;
552  const ua = userAgent || window.navigator.userAgent;
553  const device = {
554    ios: false,
555    android: false
556  };
557  const screenWidth = window.screen.width;
558  const screenHeight = window.screen.height;
559  const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
560  let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
561  const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
562  const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
563  const windows = platform === 'Win32';
564  let macos = platform === 'MacIntel';
565
566  // iPadOs 13 fix
567  const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
568  if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
569    ipad = ua.match(/(Version)\/([\d.]+)/);
570    if (!ipad) ipad = [0, 1, '13_0_0'];
571    macos = false;
572  }
573
574  // Android
575  if (android && !windows) {
576    device.os = 'android';
577    device.android = true;
578  }
579  if (ipad || iphone || ipod) {
580    device.os = 'ios';
581    device.ios = true;
582  }
583
584  // Export object
585  return device;
586}
587function getDevice(overrides) {
588  if (overrides === void 0) {
589    overrides = {};
590  }
591  if (!deviceCached) {
592    deviceCached = calcDevice(overrides);
593  }
594  return deviceCached;
595}
596
597let browser;
598function calcBrowser() {
599  const window = getWindow();
600  const device = getDevice();
601  let needPerspectiveFix = false;
602  function isSafari() {
603    const ua = window.navigator.userAgent.toLowerCase();
604    return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
605  }
606  if (isSafari()) {
607    const ua = String(window.navigator.userAgent);
608    if (ua.includes('Version/')) {
609      const [major, minor] = ua.split('Version/')[1].split(' ')[0].split('.').map(num => Number(num));
610      needPerspectiveFix = major < 16 || major === 16 && minor < 2;
611    }
612  }
613  const isWebView = /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent);
614  const isSafariBrowser = isSafari();
615  const need3dFix = isSafariBrowser || isWebView && device.ios;
616  return {
617    isSafari: needPerspectiveFix || isSafariBrowser,
618    needPerspectiveFix,
619    need3dFix,
620    isWebView
621  };
622}
623function getBrowser() {
624  if (!browser) {
625    browser = calcBrowser();
626  }
627  return browser;
628}
629
630function Resize(_ref) {
631  let {
632    swiper,
633    on,
634    emit
635  } = _ref;
636  const window = getWindow();
637  let observer = null;
638  let animationFrame = null;
639  const resizeHandler = () => {
640    if (!swiper || swiper.destroyed || !swiper.initialized) return;
641    emit('beforeResize');
642    emit('resize');
643  };
644  const createObserver = () => {
645    if (!swiper || swiper.destroyed || !swiper.initialized) return;
646    observer = new ResizeObserver(entries => {
647      animationFrame = window.requestAnimationFrame(() => {
648        const {
649          width,
650          height
651        } = swiper;
652        let newWidth = width;
653        let newHeight = height;
654        entries.forEach(_ref2 => {
655          let {
656            contentBoxSize,
657            contentRect,
658            target
659          } = _ref2;
660          if (target && target !== swiper.el) return;
661          newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
662          newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
663        });
664        if (newWidth !== width || newHeight !== height) {
665          resizeHandler();
666        }
667      });
668    });
669    observer.observe(swiper.el);
670  };
671  const removeObserver = () => {
672    if (animationFrame) {
673      window.cancelAnimationFrame(animationFrame);
674    }
675    if (observer && observer.unobserve && swiper.el) {
676      observer.unobserve(swiper.el);
677      observer = null;
678    }
679  };
680  const orientationChangeHandler = () => {
681    if (!swiper || swiper.destroyed || !swiper.initialized) return;
682    emit('orientationchange');
683  };
684  on('init', () => {
685    if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
686      createObserver();
687      return;
688    }
689    window.addEventListener('resize', resizeHandler);
690    window.addEventListener('orientationchange', orientationChangeHandler);
691  });
692  on('destroy', () => {
693    removeObserver();
694    window.removeEventListener('resize', resizeHandler);
695    window.removeEventListener('orientationchange', orientationChangeHandler);
696  });
697}
698
699function Observer(_ref) {
700  let {
701    swiper,
702    extendParams,
703    on,
704    emit
705  } = _ref;
706  const observers = [];
707  const window = getWindow

707();
708  const attach = function (target, options) {
709    if (options === void 0) {
710      options = {};
711    }
712    const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
713    const observer = new ObserverFunc(mutations => {
714      // The observerUpdate event should only be triggered
715      // once despite the number of mutations.  Additional
716      // triggers are redundant and are very costly
717      if (swiper.__preventObserver__) return;
718      if (mutations.length === 1) {
719        emit('observerUpdate', mutations[0]);
720        return;
721      }
722      const observerUpdate = function observerUpdate() {
723        emit('observerUpdate', mutations[0]);
724      };
725      if (window.requestAnimationFrame) {
726        window.requestAnimationFrame(observerUpdate);
727      } else {
728        window.setTimeout(observerUpdate, 0);
729      }
730    });
731    observer.observe(target, {
732      attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
733      childList: swiper.isElement || (typeof options.childList === 'undefined' ? true : options).childList,
734      characterData: typeof options.characterData === 'undefined' ? true : options.characterData
735    });
736    observers.push(observer);
737  };
738  const init = () => {
739    if (!swiper.params.observer) return;
740    if (swiper.params.observeParents) {
741      const containerParents = elementParents(swiper.hostEl);
742      for (let i = 0; i < containerParents.length; i += 1) {
743        attach(containerParents[i]);
744      }
745    }
746    // Observe container
747    attach(swiper.hostEl, {
748      childList: swiper.params.observeSlideChildren
749    });
750
751    // Observe wrapper
752    attach(swiper.wrapperEl, {
753      attributes: false
754    });
755  };
756  const destroy = () => {
757    observers.forEach(observer => {
758      observer.disconnect();
759    });
760    observers.splice(0, observers.length);
761  };
762  extendParams({
763    observer: false,
764    observeParents: false,
765    observeSlideChildren: false
766  });
767  on('init', init);
768  on('destroy', destroy);
769}
770
771/* eslint-disable no-underscore-dangle */
772
773var eventsEmitter = {
774  on(events, handler, priority) {
775    const self = this;
776    if (!self.eventsListeners || self.destroyed) return self;
777    if (typeof handler !== 'function') return self;
778    const method = priority ? 'unshift' : 'push';
779    events.split(' ').forEach(event => {
780      if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
781      self.eventsListeners[event][method](handler);
782    });
783    return self;
784  },
785  once(events, handler, priority) {
786    const self = this;
787    if (!self.eventsListeners || self.destroyed) return self;
788    if (typeof handler !== 'function') return self;
789    function onceHandler() {
790      self.off(events, onceHandler);
791      if (onceHandler.__emitterProxy) {
792        delete onceHandler.__emitterProxy;
793      }
794      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
795        args[_key] = arguments[_key];
796      }
797      handler.apply(self, args);
798    }
799    onceHandler.__emitterProxy = handler;
800    return self.on(events, onceHandler, priority);
801  },
802  onAny(handler, priority) {
803    const self = this;
804    if (!self.eventsListeners || self.destroyed) return self;
805    if (typeof handler !== 'function') return self;
806    const method = priority ? 'unshift' : 'push';
807    if (self.eventsAnyListeners.indexOf(handler) < 0) {
808      self.eventsAnyListeners[method](handler);
809    }
810    return self;
811  },
812  offAny(handler) {
813    const self = this;
814    if (!self.eventsListeners || self.destroyed) return self;
815    if (!self.eventsAnyListeners) return self;
816    const index = self.eventsAnyListeners.indexOf(handler);
817    if (index >= 0) {
818      self.eventsAnyListeners.splice(index, 1);
819    }
820    return self;
821  },
822  off(events, handler) {
823    const self = this;
824    if (!self.eventsListeners || self.destroyed) return self;
825    if (!self.eventsListeners) return self;
826    events.split(' ').forEach(event => {
827      if (typeof handler === 'undefined') {
828        self.eventsListeners[event] = [];
829      } else if (self.eventsListeners[event]) {
830        self.eventsListeners[event].forEach((eventHandler, index) => {
831          if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
832            self.eventsListeners[event].splice(index, 1);
833          }
834        });
835      }
836    });
837    return self;
838  },
839  emit() {
840    const self = this;
841    if (!self.eventsListeners || self.destroyed) return self;
842    if (!self.eventsListeners) return self;
843    let events;
844    let data;
845    let context;
846    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
847      args[_key2] = arguments[_key2];
848    }
849    if (typeof args[0] === 'string' || Array.isArray(args[0])) {
850      events = args[0];
851      data = args.slice(1, args.length);
852      context = self;
853    } else {
854      events = args[0].events;
855      data = args[0].data;
856      context = args[0].context || self;
857    }
858    data.unshift(context);
859    const eventsArray = Array.isArray(events) ? events : events.split(' ');
860    eventsArray.forEach(event => {
861      if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
862        self.eventsAnyListeners.forEach(eventHandler => {
863          eventHandler.apply(context, [event, ...data]);
864        });
865      }
866      if (self.eventsListeners && self.eventsListeners[event]) {
867        self.eventsListeners[event].forEach(eventHandler => {
868          eventHandler.apply(context, data);
869        });
870      }
871    });
872    return self;
873  }
874};
875
876function updateSize() {
877  const swiper = this;
878  let width;
879  let height;
880  const el = swiper.el;
881  if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
882    width = swiper.params.width;
883  } else {
884    width = el.clientWidth;
885  }
886  if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
887    height = swiper.params.height;
888  } else {
889    height = el.clientHeight;
890  }
891  if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
892    return;
893  }
894
895  // Subtract paddings
896  width = width - parseInt(elementStyle(el, 'padding-left') || 0, 10) - parseInt(elementStyle(el, 'padding-right') || 0, 10);
897  height = height - parseInt(elementStyle(el, 'padding-top') || 0, 10) - parseInt(elementStyle(el, 'padding-bottom') || 0, 10);
898  if (Number.isNaN(width)) width = 0;
899  if (Number.isNaN(height)) height = 0;
900  Object.assign(swiper, {
901    width,
902    height,
903    size: swiper.isHorizontal() ? width : height
904  });
905}
906
907function updateSlides() {
908  const swiper = this;
909  function getDirectionPropertyValue(node, label) {
910    return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
911  }
912  const params = swiper.params;
913  const {
914    wrapperEl,
915    slidesEl,
916    size: swiperSize,
917    rtlTranslate: rtl,
918    wrongRTL
919  } = swiper;
920  const isVirtual = swiper.virtual && params.virtual.enabled;
921  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
922  const slides = elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
923  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
924  let snapGrid = [];
925  const slidesGrid = [];
926  const slidesSizesGrid = [];
927  let offsetBefore = params.slidesOffsetBefore;
928  if (typeof offsetBefore === 'function') {
929    offsetBefore = params.slidesOffsetBefore.call(swiper);
930  }
931  let offsetAfter = params.slidesOffsetAfter;
932  if (typeof offsetAfter === 'function') {
933    offsetAfter = params.slidesOffsetAfter.call(swiper);
934  }
935  const previousSnapGridLength = swiper.snapGrid.length;
936  const previousSlidesGridLength = swiper.slidesGrid.length;
937  let spaceBetween = params.spaceBetween;
938  let slidePosition = -offsetBefore;
939  let prevSlideSize = 0;
940  let index = 0;
941  if (typeof swiperSize === 'undefined') {
942    return;
943  }
944  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
945    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
946  } else if (typeof spaceBetween === 'string') {
947    spaceBetween = parseFloat(spaceBetween);
948  }
949  swiper.virtualSize = -spaceBetween;
950
951  // reset margins
952  slides.forEach(slideEl => {
953    if (rtl) {
954      slideEl.style.marginLeft = '';
955    } else {
956      slideEl.style.marginRight = '';
957    }
958    slideEl.style.marginBottom = '';
959    slideEl.style.marginTop = '';
960  });
961
962  // reset cssMode offsets
963  if (params.centeredSlides && params.cssMode) {
964    setCSSProperty

965(wrapperEl, '--swiper-centered-offset-after', '');
966  }
967  const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
968  if (gridEnabled) {
969    swiper.grid.initSlides(slides);
970  } else if (swiper.grid) {
971    swiper.grid.unsetSlides();
972  }
973
974  // Calc slides
975  let slideSize;
976  const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
977    return typeof params.breakpoints[key].slidesPerView !== 'undefined';
978  }).length > 0;
979  for (let i = 0; i < slidesLength; i += 1) {
980    slideSize = 0;
981    let slide;
982    if (slides[i]) slide = slides[i];
983    if (gridEnabled) {
984      swiper.grid.updateSlide(i, slide, slides);
985    }
986    if (slides[i] && elementStyle(slide, 'display') === 'none') continue; // eslint-disable-line
987
988    if (params.slidesPerView === 'auto') {
989      if (shouldResetSlideSize) {
990        slides[i].style[swiper.getDirectionLabel('width')] = ``;
991      }
992      const slideStyles = getComputedStyle(slide);
993      const currentTransform = slide.style.transform;
994      const currentWebKitTransform = slide.style.webkitTransform;
995      if (currentTransform) {
996        slide.style.transform = 'none';
997      }
998      if (currentWebKitTransform) {
999        slide.style.webkitTransform = 'none';
1000      }
1001      if (params.roundLengths) {
1002        slideSize = swiper.isHorizontal() ? elementOuterSize(slide, 'width', true) : elementOuterSize(slide, 'height', true);
1003      } else {
1004        // eslint-disable-next-line
1005        const width = getDirectionPropertyValue(slideStyles, 'width');
1006        const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
1007        const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
1008        const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
1009        const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
1010        const boxSizing = slideStyles.getPropertyValue('box-sizing');
1011        if (boxSizing && boxSizing === 'border-box') {
1012          slideSize = width + marginLeft + marginRight;
1013        } else {
1014          const {
1015            clientWidth,
1016            offsetWidth
1017          } = slide;
1018          slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1019        }
1020      }
1021      if (currentTransform) {
1022        slide.style.transform = currentTransform;
1023      }
1024      if (currentWebKitTransform) {
1025        slide.style.webkitTransform = currentWebKitTransform;
1026      }
1027      if (params.roundLengths) slideSize = Math.floor(slideSize);
1028    } else {
1029      slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
1030      if (params.roundLengths) slideSize = Math.floor(slideSize);
1031      if (slides[i]) {
1032        slides[i].style[swiper.getDirectionLabel('width')] = `${slideSize}px`;
1033      }
1034    }
1035    if (slides[i]) {
1036      slides[i].swiperSlideSize = slideSize;
1037    }
1038    slidesSizesGrid.push(slideSize);
1039    if (params.centeredSlides) {
1040      slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1041      if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1042      if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1043      if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
1044      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1045      if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1046      slidesGrid.push(slidePosition);
1047    } else {
1048      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1049      if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1050      slidesGrid.push(slidePosition);
1051      slidePosition = slidePosition + slideSize + spaceBetween;
1052    }
1053    swiper.virtualSize += slideSize + spaceBetween;
1054    prevSlideSize = slideSize;
1055    index += 1;
1056  }
1057  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1058  if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1059    wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
1060  }
1061  if (params.setWrapperSize) {
1062    wrapperEl.style[swiper.getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;
1063  }
1064  if (gridEnabled) {
1065    swiper.grid.updateWrapperSize(slideSize, snapGrid);
1066  }
1067
1068  // Remove last grid elements depending on width
1069  if (!params.centeredSlides) {
1070    const newSlidesGrid = [];
1071    for (let i = 0; i < snapGrid.length; i += 1) {
1072      let slidesGridItem = snapGrid[i];
1073      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1074      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1075        newSlidesGrid.push(slidesGridItem);
1076      }
1077    }
1078    snapGrid = newSlidesGrid;
1079    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1080      snapGrid.push(swiper.virtualSize - swiperSize);
1081    }
1082  }
1083  if (isVirtual && params.loop) {
1084    const size = slidesSizesGrid[0] + spaceBetween;
1085    if (params.slidesPerGroup > 1) {
1086      const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
1087      const groupSize = size * params.slidesPerGroup;
1088      for (let i = 0; i < groups; i += 1) {
1089        snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1090      }
1091    }
1092    for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1093      if (params.slidesPerGroup === 1) {
1094        snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1095      }
1096      slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1097      swiper.virtualSize += size;
1098    }
1099  }
1100  if (snapGrid.length === 0) snapGrid = [0];
1101  if (spaceBetween !== 0) {
1102    const key = swiper.isHorizontal() && rtl ? 'marginLeft' : swiper.getDirectionLabel('marginRight');
1103    slides.filter((_, slideIndex) => {
1104      if (!params.cssMode || params.loop) return true;
1105      if (slideIndex === slides.length - 1) {
1106        return false;
1107      }
1108      return true;
1109    }).forEach(slideEl => {
1110      slideEl.style[key] = `${spaceBetween}px`;
1111    });
1112  }
1113  if (params.centeredSlides && params.centeredSlidesBounds) {
1114    let allSlidesSize = 0;
1115    slidesSizesGrid.forEach(slideSizeValue => {
1116      allSlidesSize += slideSizeValue + (spaceBetween || 0);
1117    });
1118    allSlidesSize -= spaceBetween;
1119    const maxSnap = allSlidesSize > swiperSize ? allSlidesSize - swiperSize : 0;
1120    snapGrid = snapGrid.map(snap => {
1121      if (snap <= 0) return -offsetBefore;
1122      if (snap > maxSnap) return maxSnap + offsetAfter;
1123      return snap;
1124    });
1125  }
1126  if (params.centerInsufficientSlides) {
1127    let allSlidesSize = 0;
1128    slidesSizesGrid.forEach(slideSizeValue => {
1129      allSlidesSize += slideSizeValue + (spaceBetween || 0);
1130    });
1131    allSlidesSize -= spaceBetween;
1132    const offsetSize = (params.slidesOffsetBefore || 0) + (params.slidesOffsetAfter || 0);
1133    if (allSlidesSize + offsetSize < swiperSize) {
1134      const allSlidesOffset = (swiperSize - allSlidesSize - offsetSize) / 2;
1135      snapGrid.forEach((snap, snapIndex) => {
1136        snapGrid[snapIndex] = snap - allSlidesOffset;
1137      });
1138      slidesGrid.forEach((snap, snapIndex) => {
1139        slidesGrid[snapIndex] = snap + allSlidesOffset;
1140      });
1141    }
1142  }
1143  Object.assign(swiper, {
1144    slides,
1145    snapGrid,
1146    slidesGrid,
1147    slidesSizesGrid
1148  });
1149  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1150    setCSSProperty

1151(wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1152    const addToSnapGrid = -swiper.snapGrid[0];
1153    const addToSlidesGrid = -swiper.slidesGrid[0];
1154    swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1155    swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1156  }
1157  if (slidesLength !== previousSlidesLength) {
1158    swiper.emit('slidesLengthChange');
1159  }
1160  if (snapGrid.length !== previousSnapGridLength) {
1161    if (swiper.params.watchOverflow) swiper.checkOverflow();
1162    swiper.emit('snapGridLengthChange');
1163  }
1164  if (slidesGrid.length !== previousSlidesGridLength) {
1165    swiper.emit('slidesGridLengthChange');
1166  }
1167  if (params.watchSlidesProgress) {
1168    swiper.updateSlidesOffset();
1169  }
1170  swiper.emit('slidesUpdated');
1171  if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1172    const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1173    const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1174    if (slidesLength <= params.maxBackfaceHiddenSlides) {
1175      if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1176    } else if (hasClassBackfaceClassAdded) {
1177      swiper.el.classList.remove(backFaceHiddenClass);
1178    }
1179  }
1180}
1181
1182function updateAutoHeight(speed) {
1183  const swiper = this;
1184  const activeSlides = [];
1185  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1186  let newHeight = 0;
1187  let i;
1188  if (typeof speed === 'number') {
1189    swiper.setTransition(speed);
1190  } else if (speed === true) {
1191    swiper.setTransition(swiper.params.speed);
1192  }
1193  const getSlideByIndex = index => {
1194    if (isVirtual) {
1195      return swiper.slides[swiper.getSlideIndexByData(index)];
1196    }
1197    return swiper.slides[index];
1198  };
1199  // Find slides currently in view
1200  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1201    if (swiper.params.centeredSlides) {
1202      (swiper.visibleSlides || []).forEach(slide => {
1203        activeSlides.push(slide);
1204      });
1205    } else {
1206      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1207        const index = swiper.activeIndex + i;
1208        if (index > swiper.slides.length && !isVirtual) break;
1209        activeSlides.push(getSlideByIndex(index));
1210      }
1211    }
1212  } else {
1213    activeSlides.push(getSlideByIndex(swiper.activeIndex));
1214  }
1215
1216  // Find new height from highest slide in view
1217  for (i = 0; i < activeSlides.length; i += 1) {
1218    if (typeof activeSlides[i] !== 'undefined') {
1219      const height = activeSlides[i].offsetHeight;
1220      newHeight = height > newHeight ? height : newHeight;
1221    }
1222  }
1223
1224  // Update Height
1225  if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;
1226}
1227
1228function updateSlidesOffset() {
1229  const swiper = this;
1230  const slides = swiper.slides;
1231  // eslint-disable-next-line
1232  const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;
1233  for (let i = 0; i < slides.length; i += 1) {
1234    slides[i].swiperSlideOffset = (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) - minusOffset - swiper.cssOverflowAdjustment();
1235  }
1236}
1237
1238const toggleSlideClasses$1 = (slideEl, condition, className) => {
1239  if (condition && !slideEl.classList.contains(className)) {
1240    slideEl.classList.add(className);
1241  } else if (!condition && slideEl.classList.contains(className)) {
1242    slideEl.classList.remove(className);
1243  }
1244};
1245function updateSlidesProgress(translate) {
1246  if (translate === void 0) {
1247    translate = this && this.translate || 0;
1248  }
1249  const swiper = this;
1250  const params = swiper.params;
1251  const {
1252    slides,
1253    rtlTranslate: rtl,
1254    snapGrid
1255  } = swiper;
1256  if (slides.length === 0) return;
1257  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
1258  let offsetCenter = -translate;
1259  if (rtl) offsetCenter = translate;
1260  swiper.visibleSlidesIndexes = [];
1261  swiper.visibleSlides = [];
1262  let spaceBetween = params.spaceBetween;
1263  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1264    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;
1265  } else if (typeof spaceBetween === 'string') {
1266    spaceBetween = parseFloat(spaceBetween);
1267  }
1268  for (let i = 0; i < slides.length; i += 1) {
1269    const slide = slides[i];
1270    let slideOffset = slide.swiperSlideOffset;
1271    if (params.cssMode && params.centeredSlides) {
1272      slideOffset -= slides[0].swiperSlideOffset;
1273    }
1274    const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1275    const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1276    const slideBefore = -(offsetCenter - slideOffset);
1277    const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1278    const isFullyVisible = slideBefore >= 0 && slideBefore <= swiper.size - swiper.slidesSizesGrid[i];
1279    const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1280    if (isVisible) {
1281      swiper.visibleSlides.push(slide);
1282      swiper.visibleSlidesIndexes.push(i);
1283    }
1284    toggleSlideClasses$1(slide, isVisible, params.slideVisibleClass);
1285    toggleSlideClasses$1(slide, isFullyVisible, params.slideFullyVisibleClass);
1286    slide.progress = rtl ? -slideProgress : slideProgress;
1287    slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1288  }
1289}
1290
1291function updateProgress(translate) {
1292  const swiper = this;
1293  if (typeof translate === 'undefined') {
1294    const multiplier = swiper.rtlTranslate ? -1 : 1;
1295    // eslint-disable-next-line
1296    translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
1297  }
1298  const params = swiper.params;
1299  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1300  let {
1301    progress,
1302    isBeginning,
1303    isEnd,
1304    progressLoop
1305  } = swiper;
1306  const wasBeginning = isBeginning;
1307  const wasEnd = isEnd;
1308  if (translatesDiff === 0) {
1309    progress = 0;
1310    isBeginning = true;
1311    isEnd = true;
1312  } else {
1313    progress = (translate - swiper.minTranslate()) / translatesDiff;
1314    const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;
1315    const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;
1316    isBeginning = isBeginningRounded || progress <= 0;
1317    isEnd = isEndRounded || progress >= 1;
1318    if (isBeginningRounded) progress = 0;
1319    if (isEndRounded) progress = 1;
1320  }
1321  if (params.loop) {
1322    const firstSlideIndex = swiper.getSlideIndexByData(0);
1323    const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1324    const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1325    const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1326    const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1327    const translateAbs = Math.abs(translate);
1328    if (translateAbs >= firstSlideTranslate) {
1329      progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
1330    } else {
1331      progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1332    }
1333    if (progressLoop > 1) progressLoop -= 1;
1334  }
1335  Object.assign(swiper, {
1336    progress,
1337    progressLoop,
1338    isBeginning,
1339    isEnd
1340  });
1341  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
1342  if (isBeginning && !wasBeginning) {
1343    swiper.emit('reachBeginning toEdge');
1344  }
1345  if (isEnd && !wasEnd) {
1346    swiper.emit('reachEnd toEdge');
1347  }
1348  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
1349    swiper.emit('fromEdge');
1350  }
1351  swiper.emit('progress', progress);
1352}
1353
1354const toggleSlideClasses = (slideEl, condition, className) => {
1355  if (condition && !slideEl.classList.contains(className)) {
1356    slideEl.classList.add(className);
1357  } else if (!condition && slideEl.classList.contains(className)) {
1358    slideEl.classList.remove(className);
1359  }
1360};
1361function updateSlidesClasses() {
1362  const swiper = this;
1363  const {
1364    slides,
1365    params,
1366    slidesEl,
1367    activeIndex
1368  } = swiper;
1369  const isVirtual = swiper.virtual && params.virtual.enabled;
1370  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1371  const getFilteredSlide = selector => {
1372    return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1373  };
1374  let activeSlide;
1375  let prevSlide;
1376  let nextSlide;
1377  if (isVirtual) {
1378    if (params.loop) {
1379      let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1380      if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1381      if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1382      activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1383    } else {
1384      activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1385    }
1386  } else {
1387    if (gridEnabled) {
1388      activeSlide = slides.find(slideEl => slideEl.column === activeIndex);
1389      nextSlide = slides.find(slideEl => slideEl.column === activeIndex + 1);
1390      prevSlide = slides.find(slideEl => slideEl.column === activeIndex - 1);
1391    } else {
1392      activeSlide = slides[activeIndex];
1393    }
1394  }
1395  if (activeSlide) {
1396    if (!gridEnabled) {
1397      // Next Slide
1398      nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1399      if (params.loop && !nextSlide) {
1400        nextSlide = slides[0];
1401      }
1402
1403      // Prev Slide
1404      prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1405      if (params.loop && !prevSlide === 0) {
1406        prevSlide = slides[slides.length - 1];
1407      }
1408    }
1409  }
1410  slides.forEach(slideEl => {
1411    toggleSlideClasses(slideEl, slideEl === activeSlide, params.slideActiveClass);
1412    toggleSlideClasses(slideEl, slideEl === nextSlide, params.slideNextClass);
1413    toggleSlideClasses(slideEl, slideEl === prevSlide, params.slidePrevClass);
1414  });
1415  swiper.emitSlidesClasses();
1416}
1417
1418const processLazyPreloader = (swiper, imageEl) => {
1419  if (!swiper || swiper.destroyed || !swiper.params) return;
1420  const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1421  const slideEl = imageEl.closest(slideSelector());
1422  if (slideEl) {
1423    let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1424    if (!lazyEl && swiper.isElement) {
1425      if (slideEl.shadowRoot) {
1426        lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1427      } else {
1428        // init later
1429        requestAnimationFrame(() => {
1430          if (slideEl.shadowRoot) {
1431            lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1432            if (lazyEl) lazyEl.remove();
1433          }
1434        });
1435      }
1436    }
1437    if (lazyEl) lazyEl.remove();
1438  }
1439};
1440const unlazy = (swiper, index) => {
1441  if (!swiper.slides[index]) return;
1442  const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1443  if (imageEl) imageEl.removeAttribute('loading');
1444};
1445const preload = swiper => {
1446  if (!swiper || swiper.destroyed || !swiper.params) return;
1447  let amount = swiper.params.lazyPreloadPrevNext;
1448  const len = swiper.slides.length;
1449  if (!len || !amount || amount < 0) return;
1450  amount = Math.min(amount, len);
1451  const slidesPerView = swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1452  const activeIndex = swiper.activeIndex;
1453  if (swiper.params.grid && swiper.params.grid.rows > 1) {
1454    const activeColumn = activeIndex;
1455    const preloadColumns = [activeColumn - amount];
1456    preloadColumns.push(...Array.from({
1457      length: amount
1458    }).map((_, i) => {
1459      return activeColumn + slidesPerView + i;
1460    }));
1461    swiper.slides.forEach((slideEl, i) => {
1462      if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1463    });
1464    return;
1465  }
1466  const slideIndexLastInView = activeIndex + slidesPerView - 1;
1467  if (swiper.params.rewind || swiper.params.loop) {
1468    for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1469      const realIndex = (i % len + len) % len;
1470      if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1471    }
1472  } else {
1473    for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1474      if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1475        unlazy(swiper, i);
1476      }
1477    }
1478  }
1479};
1480
1481function getActiveIndexByTranslate(swiper) {
1482  const {
1483    slidesGrid,
1484    params
1485  } = swiper;
1486  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1487  let activeIndex;
1488  for (let i = 0; i < slidesGrid.length; i += 1) {
1489    if (typeof slidesGrid[i + 1] !== 'undefined') {
1490      if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1491        activeIndex = i;
1492      } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1493        activeIndex = i + 1;
1494      }
1495    } else if (translate >= slidesGrid[i]) {
1496      activeIndex = i;
1497    }
1498  }
1499  // Normalize slideIndex
1500  if (params.normalizeSlideIndex) {
1501    if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1502  }
1503  return activeIndex;
1504}
1505function updateActiveIndex(newActiveIndex) {
1506  const swiper = this;
1507  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1508  const {
1509    snapGrid,
1510    params,
1511    activeIndex: previousIndex,
1512    realIndex: previousRealIndex,
1513    snapIndex: previousSnapIndex
1514  } = swiper;
1515  let activeIndex = newActiveIndex;
1516  let snapIndex;
1517  const getVirtualRealIndex = aIndex => {
1518    let realIndex = aIndex - swiper.virtual.slidesBefore;
1519    if (realIndex < 0) {
1520      realIndex = swiper.virtual.slides.length + realIndex;
1521    }
1522    if (realIndex >= swiper.virtual.slides.length) {
1523      realIndex -= swiper.virtual.slides.length;
1524    }
1525    return realIndex;
1526  };
1527  if (typeof activeIndex === 'undefined') {
1528    activeIndex = getActiveIndexByTranslate(swiper);
1529  }
1530  if (snapGrid.indexOf(translate) >= 0) {
1531    snapIndex = snapGrid.indexOf(translate);
1532  } else {
1533    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1534    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1535  }
1536  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1537  if (activeIndex === previousIndex && !swiper.params.loop) {
1538    if (snapIndex !== previousSnapIndex) {
1539      swiper.snapIndex = snapIndex;
1540      swiper.emit('snapIndexChange');
1541    }
1542    return;
1543  }
1544  if (activeIndex === previousIndex && swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1545    swiper.realIndex = getVirtualRealIndex(activeIndex);
1546    return;
1547  }
1548  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1549
1550  // Get real index
1551  let realIndex;
1552  if (swiper.virtual && params.virtual.enabled && params.loop) {
1553    realIndex = getVirtualRealIndex(activeIndex);
1554  } else if (gridEnabled) {
1555    const firstSlideInColumn = swiper.slides.find(slideEl => slideEl.column === activeIndex);
1556    let activeSlideIndex = parseInt(firstSlideInColumn.getAttribute('data-swiper-slide-index'), 10);
1557    if (Number.isNaN(activeSlideIndex)) {
1558      activeSlideIndex = Math.max(swiper.slides.indexOf(firstSlideInColumn), 0);
1559    }
1560    realIndex = Math.floor(activeSlideIndex / params.grid.rows);
1561  } else if (swiper.slides[activeIndex]) {
1562    const slideIndex = swiper.slides[activeIndex].getAttribute('data-swiper-slide-index');
1563    if (slideIndex) {
1564      realIndex = parseInt(slideIndex, 10);
1565    } else {
1566      realIndex = activeIndex;
1567    }
1568  } else {
1569    realIndex = activeIndex;
1570  }
1571  Object.assign(swiper, {
1572    previousSnapIndex,
1573    snapIndex,
1574    previousRealIndex,
1575    realIndex,
1576    previousIndex,
1577    activeIndex
1578  });
1579  if (swiper.initialized) {
1580    preload(swiper);
1581  }
1582  swiper.emit('activeIndexChange');
1583  swiper.emit('snapIndexChange');
1584  if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1585    if (previousRealIndex !== realIndex) {
1586      swiper.emit('realIndexChange');
1587    }
1588    swiper.emit('slideChange');
1589  }
1590}
1591
1592function updateClickedSlide(el, path) {
1593  const swiper = this;
1594  const params = swiper.params;
1595  let slide = el.closest(`.${params.slideClass}, swiper-slide`);
1596  if (!slide && swiper.isElement && path && path.length > 1 && path.includes(el)) {
1597    [...path.slice(path.indexOf(el) + 1, path.length)].forEach(pathEl => {
1598      if (!slide && pathEl.matches && pathEl.matches(`.${params.slideClass}, swiper-slide`)) {
1599        slide = pathEl;
1600      }
1601    });
1602  }
1603  let slideFound = false;
1604  let slideIndex;
1605  if (slide) {
1606    for (let i = 0; i < swiper.slides.length; i += 1) {
1607      if (swiper.slides[i] === slide) {
1608        slideFound = true;
1609        slideIndex = i;
1610        break;
1611      }
1612    }
1613  }
1614  if (slide && slideFound) {
1615    swiper.clickedSlide = slide;
1616    if (swiper.virtual && swiper.params.virtual.enabled) {
1617      swiper.clickedIndex = parseInt(slide.getAttribute('data-swiper-slide-index'), 10);
1618    } else {
1619      swiper.clickedIndex = slideIndex;
1620    }
1621  } else {
1622    swiper.clickedSlide = undefined;
1623    swiper.clickedIndex = undefined;
1624    return;
1625  }
1626  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1627    swiper.slideToClickedSlide();
1628  }
1629}
1630
1631var update = {
1632  updateSize,
1633  updateSlides,
1634  updateAutoHeight,
1635  updateSlidesOffset,
1636  updateSlidesProgress,
1637  updateProgress,
1638  updateSlidesClasses,
1639  updateActiveIndex,
1640  updateClickedSlide
1641};
1642
1643function getSwiperTranslate(axis) {
1644  if (axis === void 0) {
1645    axis = this.isHorizontal() ? 'x' : 'y';
1646  }
1647  const swiper = this;
1648  const {
1649    params,
1650    rtlTranslate: rtl,
1651    translate,
1652    wrapperEl
1653  } = swiper;
1654  if (params.virtualTranslate) {
1655    return rtl ? -translate : translate;
1656  }
1657  if (params.cssMode) {
1658    return translate;
1659  }
1660  let currentTranslate = getTranslate(wrapperEl, axis);
1661  currentTranslate += swiper.cssOverflowAdjustment();
1662  if (rtl) currentTranslate = -currentTranslate;
1663  return currentTranslate || 0;
1664}
1665
1666function setTranslate(translate, byController) {
1667  const swiper = this;
1668  const {
1669    rtlTranslate: rtl,
1670    params,
1671    wrapperEl,
1672    progress
1673  } = swiper;
1674  let x = 0;
1675  let y = 0;
1676  const z = 0;
1677  if (swiper.isHorizontal()) {
1678    x = rtl ? -translate : translate;
1679  } else {
1680    y = translate;
1681  }
1682  if (params.roundLengths) {
1683    x = Math.floor(x);
1684    y = Math.floor(y);
1685  }
1686  swiper.previousTranslate = swiper.translate;
1687  swiper.translate = swiper.isHorizontal() ? x : y;
1688  if (params.cssMode) {
1689    wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
1690  } else if (!params.virtualTranslate) {
1691    if (swiper.isHorizontal()) {
1692      x -= swiper.cssOverflowAdjustment();
1693    } else {
1694      y -= swiper.cssOverflowAdjustment();
1695    }
1696    wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1697  }
1698
1699  // Check if we need to update progress
1700  let newProgress;
1701  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1702  if (translatesDiff === 0) {
1703    newProgress = 0;
1704  } else {
1705    newProgress = (translate - swiper.minTranslate()) / translatesDiff;
1706  }
1707  if (newProgress !== progress) {
1708    swiper.updateProgress(translate);
1709  }
1710  swiper.emit('setTranslate', swiper.translate, byController);
1711}
1712
1713function minTranslate() {
1714  return -this.snapGrid[0];
1715}
1716
1717function maxTranslate() {
1718  return -this.snapGrid[this.snapGrid.length - 1];
1719}
1720
1721function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
1722  if (translate === void 0) {
1723    translate = 0;
1724  }
1725  if (speed === void 0) {
1726    speed = this.params.speed;
1727  }
1728  if (runCallbacks === void 0) {
1729    runCallbacks = true;
1730  }
1731  if (translateBounds === void 0) {
1732    translateBounds = true;
1733  }
1734  const swiper = this;
1735  const {
1736    params,
1737    wrapperEl
1738  } = swiper;
1739  if (swiper.animating && params.preventInteractionOnTransition) {
1740    return false;
1741  }
1742  const minTranslate = swiper.minTranslate();
1743  const maxTranslate = swiper.maxTranslate();
1744  let newTranslate;
1745  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate;
1746
1747  // Update progress
1748  swiper.updateProgress(newTranslate);
1749  if (params.cssMode) {
1750    const isH = swiper.isHorizontal();
1751    if (speed === 0) {
1752      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1753    } else {
1754      if (!swiper.support.smoothScroll) {
1755        animateCSSModeScroll({
1756          swiper,
1757          targetPosition: -newTranslate,
1758          side: isH ? 'left' : 'top'
1759        });
1760        return true;
1761      }
1762      wrapperEl.scrollTo({
1763        [isH ? 'left' : 'top']: -newTranslate,
1764        behavior: 'smooth'
1765      });
1766    }
1767    return true;
1768  }
1769  if (speed === 0) {
1770    swiper.setTransition(0);
1771    swiper.setTranslate(newTranslate);
1772    if (runCallbacks) {
1773      swiper.emit('beforeTransitionStart', speed, internal);
1774      swiper.emit('transitionEnd');
1775    }
1776  } else {
1777    swiper.setTransition(speed);
1778    swiper.setTranslate(newTranslate);
1779    if (runCallbacks) {
1780      swiper.emit('beforeTransitionStart', speed, internal);
1781      swiper.emit('transitionStart');
1782    }
1783    if (!swiper.animating) {
1784      swiper.animating = true;
1785      if (!swiper.onTranslateToWrapperTransitionEnd) {
1786        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1787          if (!swiper || swiper.destroyed) return;
1788          if (e.target !== this) return;
1789          swiper.wrapperEl.removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1790          swiper.onTranslateToWrapperTransitionEnd = null;
1791          delete swiper.onTranslateToWrapperTransitionEnd;
1792          swiper.animating = false;
1793          if (runCallbacks) {
1794            swiper.emit('transitionEnd');
1795          }
1796        };
1797      }
1798      swiper.wrapperEl.addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1799    }
1800  }
1801  return true;
1802}
1803
1804var translate = {
1805  getTranslate: getSwiperTranslate,
1806  setTranslate,
1807  minTranslate,
1808  maxTranslate,
1809  translateTo
1810};
1811
1812function setTransition(duration, byController) {
1813  const swiper = this;
1814  if (!swiper.params.cssMode) {
1815    swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
1816    swiper.wrapperEl.style.transitionDelay = duration === 0 ? `0ms` : '';
1817  }
1818  swiper.emit('setTransition', duration, byController);
1819}
1820
1821function transitionEmit(_ref) {
1822  let {
1823    swiper,
1824    runCallbacks,
1825    direction,
1826    step
1827  } = _ref;
1828  const {
1829    activeIndex,
1830    previousIndex
1831  } = swiper;
1832  let dir = direction;
1833  if (!dir) {
1834    if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
1835  }
1836  swiper.emit(`transition${step}`);
1837  if (runCallbacks && 

1841
1842    swiper.emit(`slideChangeTransition${step}`);
1843    if (dir === 'next') {
1844      swiper.emit(`slideNextTransition${step}`);
1845    } else {
1846      swiper.emit(`slidePrevTransition${step}`);
1847    }
1848  }
1849}
1850
1851function transitionStart(runCallbacks, direction) {
1852  if (runCallbacks === void 0) {
1853    runCallbacks = true;
1854  }
1855  const swiper = this;
1856  const {
1857    params
1858  } = swiper;
1859  if (params.cssMode) return;
1860  if (params.autoHeight) {
1861    swiper.updateAutoHeight();
1862  }
1863  transitionEmit({
1864    swiper,
1865    runCallbacks,
1866    direction,
1867    step: 'Start'
1868  });
1869}
1870
1871function transitionEnd(runCallbacks, direction) {
1872  if (runCallbacks === void 0) {
1873    runCallbacks = true;
1874  }
1875  const swiper = this;
1876  const {
1877    params
1878  } = swiper;
1879  swiper.animating = false;
1880  if (params.cssMode) return;
1881  swiper.setTransition(0);
1882  transitionEmit({
1883    swiper,
1884    runCallbacks,
1885    direction,
1886    step: 'End'
1887  });
1888}
1889
1890var transition = {
1891  setTransition,
1892  transitionStart,
1893  transitionEnd
1894};
1895
1896function slideTo(index, speed, runCallbacks, internal, initial) {
1897  if (index === void 0) {
1898    index = 0;
1899  }
1900  if (runCallbacks === void 0) {
1901    runCallbacks = true;
1902  }
1903  if (typeof index === 'string') {
1904    index = parseInt(index, 10);
1905  }
1906  const swiper = this;
1907  let slideIndex = index;
1908  if (slideIndex < 0) slideIndex = 0;
1909  const {
1910    params,
1911    snapGrid,
1912    slidesGrid,
1913    previousIndex,
1914    activeIndex,
1915    rtlTranslate: rtl,
1916    wrapperEl,
1917    enabled
1918  } = swiper;
1919  if (!enabled && !internal && !initial || swiper.destroyed || swiper.animating && params.preventInteractionOnTransition) {
1920    return false;
1921  }
1922  if (typeof speed === 'undefined') {
1923    speed = swiper.params.speed;
1924  }
1925  const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
1926  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
1927  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1928  const translate = -snapGrid[snapIndex];
1929  // Normalize slideIndex
1930  if (params.normalizeSlideIndex) {
1931    for (let i = 0; i < slidesGrid.length; i += 1) {
1932      const normalizedTranslate = -Math.floor(translate * 100);
1933      const normalizedGrid = Math.floor(slidesGrid[i] * 100);
1934      const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
1935      if (typeof slidesGrid[i + 1] !== 'undefined') {
1936        if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
1937          slideIndex = i;
1938        } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
1939          slideIndex = i + 1;
1940        }
1941      } else if (normalizedTranslate >= normalizedGrid) {
1942        slideIndex = i;
1943      }
1944    }
1945  }
1946  // Directions locks
1947  if (swiper.initialized && slideIndex !== activeIndex) {
1948    if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) {
1949      return false;
1950    }
1951    if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
1952      if ((activeIndex || 0) !== slideIndex) {
1953        return false;
1954      }
1955    }
1956  }
1957  if (slideIndex !== (previousIndex || 0) && runCallbacks) {
1958    swiper.emit('beforeSlideChangeStart');
1959  }
1960
1961  // Update progress
1962  swiper.updateProgress(translate);
1963  let direction;
1964  if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset';
1965
1966  // initial virtual
1967  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1968  const isInitialVirtual = isVirtual && initial;
1969  // Update Index
1970  if (!isInitialVirtual && (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate)) {
1971    swiper.updateActiveIndex(slideIndex);
1972    // Update Height
1973    if (params.autoHeight) {
1974      swiper.updateAutoHeight();
1975    }
1976    swiper.updateSlidesClasses();
1977    if (params.effect !== 'slide') {
1978      swiper.setTranslate(translate);
1979    }
1980    if (direction !== 'reset') {
1981      swiper.transitionStart(runCallbacks, direction);
1982      swiper.transitionEnd(runCallbacks, direction);
1983    }
1984    return false;
1985  }
1986  if (params.cssMode) {
1987    const isH = swiper.isHorizontal();
1988    const t = rtl ? translate : -translate;
1989    if (speed === 0) {
1990      if (isVirtual) {
1991        swiper.wrapperEl.style.scrollSnapType = 'none';
1992        swiper._immediateVirtual = true;
1993      }
1994      if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
1995        swiper._cssModeVirtualInitialSet = true;
1996        requestAnimationFrame(() => {
1997          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1998        });
1999      } else {
2000        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
2001      }
2002      if (isVirtual) {
2003        requestAnimationFrame(() => {
2004          swiper.wrapperEl.style.scrollSnapType = '';
2005          swiper._immediateVirtual = false;
2006        });
2007      }
2008    } else {
2009      if (!swiper.support.smoothScroll) {
2010        animateCSSModeScroll({
2011          swiper,
2012          targetPosition: t,
2013          side: isH ? 'left' : 'top'
2014        });
2015        return true;
2016      }
2017      wrapperEl.scrollTo({
2018        [isH ? 'left' : 'top']: t,
2019        behavior: 'smooth'
2020      });
2021    }
2022    return true;
2023  }
2024  const browser = getBrowser();
2025  const isSafari = browser.isSafari;
2026  if (isVirtual && !initial && isSafari && swiper.isElement) {
2027    swiper.virtual.update(false, false, slideIndex);
2028  }
2029  swiper.setTransition(speed);
2030  swiper.setTranslate(translate);
2031  swiper.updateActiveIndex(slideIndex);
2032  swiper.updateSlidesClasses();
2033  swiper.emit('beforeTransitionStart', speed, internal);
2034  swiper.transitionStart(runCallbacks, direction);
2035  if (speed === 0) {
2036    swiper.transitionEnd(runCallbacks, direction);
2037  } else if (!swiper.animating) {
2038    swiper.animating = true;
2039    if (!swiper.onSlideToWrapperTransitionEnd) {
2040      swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2041        if (!swiper || swiper.destroyed) return;
2042        if (e.target !== this) return;
2043        swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2044        swiper.onSlideToWrapperTransitionEnd = null;
2045        delete swiper.onSlideToWrapperTransitionEnd;
2046        swiper.transitionEnd(runCallbacks, direction);
2047      };
2048    }
2049    swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2050  }
2051  return true;
2052}
2053
2054function slideToLoop(index, speed, runCallbacks, internal) {
2055  if (index === void 0) {
2056    index = 0;
2057  }
2058  if (runCallbacks === void 0) {
2059    runCallbacks = true;
2060  }
2061  if (typeof index === 'string') {
2062    const indexAsNumber = parseInt(index, 10);
2063    index = indexAsNumber;
2064  }
2065  const swiper = this;
2066  if (swiper.destroyed) return;
2067  if (typeof speed === 'undefined') {
2068    speed = swiper.params.speed;
2069  }
2070  const gridEnabled = swiper.grid && swiper.params.grid && swiper.params.grid.rows > 1;
2071  let newIndex = index;
2072  if (swiper.params.loop) {
2073    if (swiper.virtual && swiper.params.virtual.enabled) {
2074      // eslint-disable-next-line
2075      newIndex = newIndex + swiper.virtual.slidesBefore;
2076    } else {
2077      let targetSlideIndex;
2078      if (gridEnabled) {
2079        const slideIndex = newIndex * swiper.params.grid.rows;
2080        targetSlideIndex = swiper.slides.find(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex).column;
2081      } else {
2082        targetSlideIndex = swiper.getSlideIndexByData(newIndex);
2083      }
2084      const cols = gridEnabled ? Math.ceil(swiper.slides.length / swiper.params.grid.rows) : swiper.slides.length;
2085      const {
2086        centeredSlides
2087      } = swiper.params;
2088      let slidesPerView = swiper.params.slidesPerView;
2089      if (slidesPerView === 'auto') {
2090        slidesPerView = swiper.slidesPerViewDynamic();
2091      } else {
2092        slidesPerView = Math.ceil(parseFloat(swiper.params.slidesPerView, 10));
2093        if (centeredSlides && slidesPerView % 2 === 0) {
2094          slidesPerView = slidesPerView + 1;
2095        }
2096      }
2097      let needLoopFix = cols - targetSlideIndex < slidesPerView;
2098      if (centeredSlides) {
2099        needLoopFix = needLoopFix || targetSlideIndex < Math.ceil(slidesPerView / 2);
2100      }
2101      if (internal && centeredSlides && swiper.params.slidesPerView !== 'auto' && !gridEnabled) {
2102        needLoopFix = false;
2103      }
2104      if (needLoopFix) {
2105        const direction = centeredSlides ? targetSlideIndex < swiper.activeIndex ? 'prev' : 'next' : targetSlideIndex - swiper.activeIndex - 1 < swiper.params.slidesPerView ? 'next' : 'prev';
2106        swiper.loopFix({
2107          direction,
2108          slideTo: true,
2109          activeSlideIndex: direction === 'next' ? targetSlideIndex + 1 : targetSlideIndex - cols + 1,
2110          slideRealIndex: direction === 'next' ? swiper.realIndex : undefined
2111        });
2112      }
2113      if (gridEnabled) {
2114        const slideIndex = newIndex * swiper.params.grid.rows;
2115        newIndex = swiper.slides.find(slideEl => slideEl.getAttribute('data-swiper-slide-index') * 1 === slideIndex).column;
2116      } else {
2117        newIndex = swiper.getSlideIndexByData(newIndex);
2118      }
2119    }
2120  }
2121  requestAnimationFrame(() => {
2122    swiper.slideTo(newIndex, speed, runCallbacks, internal);
2123  });
2124  return swiper;
2125}
2126
2127/* eslint no-unused-vars: "off" */
2128function slideNext(speed, runCallbacks, internal) {
2129  if (runCallbacks === void 0) {
2130    runCallbacks = true;
2131  }
2132  const swiper = this;
2133  const {
2134    enabled,
2135    params,
2136    animating
2137  } = swiper;
2138  if (!enabled || swiper.destroyed) return swiper;
2139  if (typeof speed === 'undefined') {
2140    speed = swiper.params.speed;
2141  }
2142  let perGroup = params.slidesPerGroup;
2143  if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2144    perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
2145  }
2146  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2147  const isVirtual = swiper.virtual && params.virtual.enabled;
2148  if (params.loop) {
2149    if (animating && !isVirtual && params.loopPreventsSliding) return false;
2150    swiper.loopFix({
2151      direction: 'next'
2152    });
2153    // eslint-disable-next-line
2154    swiper._clientLeft = swiper.wrapperEl.clientLeft;
2155    if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
2156      requestAnimationFrame(() => {
2157        swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2158      });
2159      return true;
2160    }
2161  }
2162  if (params.rewind && swiper.isEnd) {
2163    return swiper.slideTo(0, speed, runCallbacks, internal);
2164  }
2165  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2166}
2167
2168/* eslint no-unused-vars: "off" */
2169function slidePrev(speed, runCallbacks, internal) {
2170  if (runCallbacks === void 0) {
2171    runCallbacks = true;
2172  }
2173  const swiper = this;
2174  const {
2175    params,
2176    snapGrid,
2177    slidesGrid,
2178    rtlTranslate,
2179    enabled,
2180    animating
2181  } = swiper;
2182  if (!enabled || swiper.destroyed) return swiper;
2183  if (typeof speed === 'undefined') {
2184    speed = swiper.params.speed;
2185  }
2186  const isVirtual = swiper.virtual && params.virtual.enabled;
2187  if (params.loop) {
2188    if (animating && !isVirtual && params.loopPreventsSliding) return false;
2189    swiper.loopFix({
2190      direction: 'prev'
2191    });
2192    // eslint-disable-next-line
2193    swiper._clientLeft = swiper.wrapperEl.clientLeft;
2194  }
2195  const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2196  function normalize(val) {
2197    if (val < 0) return -Math.floor(Math.abs(val));
2198    return Math.floor(val);
2199  }
2200  const normalizedTranslate = normalize(translate);
2201  const normalizedSnapGrid = snapGrid.map(val => normalize(val));
2202  const isFreeMode = params.freeMode && params.freeMode.enabled;
2203  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2204  if (typeof prevSnap === 'undefined' && (params.cssMode || isFreeMode)) {
2205    let prevSnapIndex;
2206    snapGrid.forEach((snap, snapIndex) => {
2207      if (normalizedTranslate >= snap) {
2208        // prevSnap = snap;
2209        prevSnapIndex = snapIndex;
2210      }
2211    });
2212    if (typeof prevSnapIndex !== 'undefined') {
2213      prevSnap = isFreeMode ? snapGrid[prevSnapIndex] : snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2214    }
2215  }
2216  let prevIndex = 0;
2217  if (typeof prevSnap !== 'undefined') {
2218    prevIndex = slidesGrid.indexOf(prevSnap);
2219    if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2220    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2221      prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2222      prevIndex = Math.max(prevIndex, 0);
2223    }
2224  }
2225  if (params.rewind && swiper.isBeginning) {
2226    const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2227    return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2228  } else if (params.loop && swiper.activeIndex === 0 && params.cssMode) {
2229    requestAnimationFrame(() => {
2230      swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2231    });
2232    return true;
2233  }
2234  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2235}
2236
2237/* eslint no-unused-vars: "off" */
2238function slideReset(speed, runCallbacks, internal) {
2239  if (runCallbacks === void 0) {
2240    runCallbacks = true;
2241  }
2242  const swiper = this;
2243  if (swiper.destroyed) return;
2244  if (typeof speed === 'undefined') {
2245    speed = swiper.params.speed;
2246  }
2247  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2248}
2249
2250/* eslint no-unused-vars: "off" */
2251function slideToClosest(speed, runCallbacks, internal, threshold) {
2252  if (runCallbacks === void 0) {
2253    runCallbacks = true;
2254  }
2255  if (threshold === void 0) {
2256    threshold = 0.5;
2257  }
2258  const swiper = this;
2259  if (swiper.destroyed) return;
2260  if (typeof speed === 'undefined') {
2261    speed = swiper.params.speed;
2262  }
2263  let index = swiper.activeIndex;
2264  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2265  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2266  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2267  if (translate >= swiper.snapGrid[snapIndex]) {
2268    // The current translate is on or after the current snap index, so the choice
2269    // is between the current index and the one after it.
2270    const currentSnap = swiper.snapGrid[snapIndex];
2271    const nextSnap = swiper.snapGrid[snapIndex + 1];
2272    if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
2273      index += swiper.params.slidesPerGroup;
2274    }
2275  } else {
2276    // The current translate is before the current snap index, so the choice
2277    // is between the current index and the one before it.
2278    const prevSnap = swiper.snapGrid[snapIndex - 1];
2279    const currentSnap = swiper.snapGrid[snapIndex];
2280    if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
2281      index -= swiper.params.slidesPerGroup;
2282    }
2283  }
2284  index = Math.max(index, 0);
2285  index = Math.min(index, swiper.slidesGrid.length - 1);
2286  return swiper.slideTo(index, speed, runCallbacks, internal);
2287}
2288
2289function slideToClickedSlide() {
2290  const swiper = this;
2291  if (swiper.destroyed) return;
2292  const {
2293    params,
2294    slidesEl
2295  } = swiper;
2296  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2297  let slideToIndex = swiper.

2297clickedIndex;
2298  let realIndex;
2299  const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2300  if (params.loop) {
2301    if (swiper.animating) return;
2302    realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
2303    if (params.centeredSlides) {
2304      if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2305        swiper.loopFix();
2306        slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2307        nextTick(() => {
2308          swiper.slideTo(slideToIndex);
2309        });
2310      } else {
2311        swiper.slideTo(slideToIndex);
2312      }
2313    } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2314      swiper.loopFix();
2315      slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2316      nextTick(() => {
2317        swiper.slideTo(slideToIndex);
2318      });
2319    } else {
2320      swiper.slideTo(slideToIndex);
2321    }
2322  } else {
2323    swiper.slideTo(slideToIndex);
2324  }
2325}
2326
2327var slide = {
2328  slideTo,
2329  slideToLoop,
2330  slideNext,
2331  slidePrev,
2332  slideReset,
2333  slideToClosest,
2334  slideToClickedSlide
2335};
2336
2337function loopCreate(slideRealIndex) {
2338  const swiper = this;
2339  const {
2340    params,
2341    slidesEl
2342  } = swiper;
2343  if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2344  const initSlides = () => {
2345    const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
2346    slides.forEach((el, index) => {
2347      el.setAttribute('data-swiper-slide-index', index);
2348    });
2349  };
2350  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2351  const slidesPerGroup = params.slidesPerGroup * (gridEnabled ? params.grid.rows : 1);
2352  const shouldFillGroup = swiper.slides.length % slidesPerGroup !== 0;
2353  const shouldFillGrid = gridEnabled && swiper.slides.length % params.grid.rows !== 0;
2354  const addBlankSlides = amountOfSlides => {
2355    for (let i = 0; i < amountOfSlides; i += 1) {
2356      const slideEl = swiper.isElement ? createElement('swiper-slide', [params.slideBlankClass]) : createElement('div', [params.slideClass, params.slideBlankClass]);
2357      swiper.slidesEl.append(slideEl);
2358    }
2359  };
2360  if (shouldFillGroup) {
2361    if (params.loopAddBlankSlides) {
2362      const slidesToAdd = slidesPerGroup - swiper.slides.length % slidesPerGroup;
2363      addBlankSlides(slidesToAdd);
2364      swiper.recalcSlides();
2365      swiper.updateSlides();
2366    } else {
2367      showWarning('Swiper Loop Warning: The number of slides is not even to slidesPerGroup, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)');
2368    }
2369    initSlides();
2370  } else if (shouldFillGrid) {
2371    if (params.loopAddBlankSlides) {
2372      const slidesToAdd = params.grid.rows - swiper.slides.length % params.grid.rows;
2373      addBlankSlides(slidesToAdd);
2374      swiper.recalcSlides();
2375      swiper.updateSlides();
2376    } else {
2377      showWarning('Swiper Loop Warning: The number of slides is not even to grid.rows, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)');
2378    }
2379    initSlides();
2380  } else {
2381    initSlides();
2382  }
2383  swiper.loopFix({
2384    slideRealIndex,
2385    direction: params.centeredSlides ? undefined : 'next'
2386  });
2387}
2388
2389function loopFix(_temp) {
2390  let {
2391    slideRealIndex,
2392    slideTo = true,
2393    direction,
2394    setTranslate,
2395    activeSlideIndex,
2396    byController,
2397    byMousewheel
2398  } = _temp === void 0 ? {} : _temp;
2399  const swiper = this;
2400  if (!swiper.params.loop) return;
2401  swiper.emit('beforeLoopFix');
2402  const {
2403    slides,
2404    allowSlidePrev,
2405    allowSlideNext,
2406    slidesEl,
2407    params
2408  } = swiper;
2409  const {
2410    centeredSlides
2411  } = params;
2412  swiper.allowSlidePrev = true;
2413  swiper.allowSlideNext = true;
2414  if (swiper.virtual && params.virtual.enabled) {
2415    if (slideTo) {
2416      if (!params.centeredSlides && swiper.snapIndex === 0) {
2417        swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
2418      } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
2419        swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
2420      } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
2421        swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2422      }
2423    }
2424    swiper.allowSlidePrev = allowSlidePrev;
2425    swiper.allowSlideNext = allowSlideNext;
2426    swiper.emit('loopFix');
2427    return;
2428  }
2429  let slidesPerView = params.slidesPerView;
2430  if (slidesPerView === 'auto') {
2431    slidesPerView = swiper.slidesPerViewDynamic();
2432  } else {
2433    slidesPerView = Math.ceil(parseFloat(params.slidesPerView, 10));
2434    if (centeredSlides && slidesPerView % 2 === 0) {
2435      slidesPerView = slidesPerView + 1;
2436    }
2437  }
2438  const slidesPerGroup = params.slidesPerGroupAuto ? slidesPerView : params.slidesPerGroup;
2439  let loopedSlides = slidesPerGroup;
2440  if (loopedSlides % slidesPerGroup !== 0) {
2441    loopedSlides += slidesPerGroup - loopedSlides % slidesPerGroup;
2442  }
2443  loopedSlides += params.loopAdditionalSlides;
2444  swiper.loopedSlides = loopedSlides;
2445  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2446  if (slides.length < slidesPerView + loopedSlides) {
2447    showWarning('Swiper Loop Warning: The number of slides is not enough for loop mode, it will be disabled and not function properly. You need to add more slides (or make duplicates) or lower the values of slidesPerView and slidesPerGroup parameters');
2448  } else if (gridEnabled && params.grid.fill === 'row') {
2449    showWarning('Swiper Loop Warning: Loop mode is not compatible with grid.fill = `row`');
2450  }
2451  const prependSlidesIndexes = [];
2452  const appendSlidesIndexes = [];
2453  let activeIndex = swiper.activeIndex;
2454  if (typeof activeSlideIndex === 'undefined') {
2455    activeSlideIndex = swiper.getSlideIndex(slides.find(el => el.classList.contains(params.slideActiveClass)));
2456  } else {
2457    activeIndex = activeSlideIndex;
2458  }
2459  const isNext = direction === 'next' || !direction;
2460  const isPrev = direction === 'prev' || !direction;
2461  let slidesPrepended = 0;
2462  let slidesAppended = 0;
2463  const cols = gridEnabled ? Math.ceil(slides.length / params.grid.rows) : slides.length;
2464  const activeColIndex = gridEnabled ? slides[activeSlideIndex].column : activeSlideIndex;
2465  const activeColIndexWithShift = activeColIndex + (centeredSlides && typeof setTranslate === 'undefined' ? -slidesPerView / 2 + 0.5 : 0);
2466  // prepend last slides before start
2467  if (activeColIndexWithShift < loopedSlides) {
2468    slidesPrepended = Math.max(loopedSlides - activeColIndexWithShift, slidesPerGroup);
2469    for (let i = 0; i < loopedSlides - activeColIndexWithShift; i += 1) {

2470      const index = i - Math.floor(i / cols) * cols;
2471      if (gridEnabled) {
2472        const colIndexToPrepend = cols - index - 1;
2473        for (let i = slides.length - 1; i >= 0; i -= 1) {
2474          if (slides[i].column === colIndexToPrepend) prependSlidesIndexes.push(i);
2475        }
2476        // slides.forEach((slide, slideIndex) => {
2477        //   if (slide.column === colIndexToPrepend) prependSlidesIndexes.push(slideIndex);
2478        // });
2479      } else {
2480        prependSlidesIndexes.push(cols - index - 1);
2481      }
2482    }
2483  } else if (activeColIndexWithShift + slidesPerView > cols - loopedSlides) {
2484    slidesAppended = Math.max(activeColIndexWithShift - (cols - loopedSlides * 2), slidesPerGroup);
2485    for (let i = 0; i < slidesAppended; i += 1) {
2486      const index = i - Math.floor(i / cols) * cols;
2487      if (gridEnabled) {
2488        slides.forEach((slide, slideIndex) => {
2489          if (slide.column === index) appendSlidesIndexes.push(slideIndex);
2490        });
2491      } else {
2492        appendSlidesIndexes.push(index);
2493      }
2494    }
2495  }
2496  swiper.__preventObserver__ = true;
2497  requestAnimationFrame(() => {
2498    swiper.__preventObserver__ = false;
2499  });
2500  if (isPrev) {
2501    prependSlidesIndexes.forEach(index => {
2502      slides[index].swiperLoopMoveDOM = true;
2503      slidesEl.prepend(slides[index]);
2504      slides[index].swiperLoopMoveDOM = false;
2505    });
2506  }
2507  if (isNext) {
2508    appendSlidesIndexes.forEach(index => {
2509      slides[index].swiperLoopMoveDOM = true;
2510      slidesEl.append(slides[index]);
2511      slides[index].swiperLoopMoveDOM = false;
2512    });
2513  }
2514  swiper.recalcSlides();
2515  if (params.slidesPerView === 'auto') {
2516    swiper.updateSlides();
2517  } else if (gridEnabled && (prependSlidesIndexes.length > 0 && isPrev || appendSlidesIndexes.length > 0 && isNext)) {
2518    swiper.slides.forEach((slide, slideIndex) => {
2519      swiper.grid.updateSlide(slideIndex, slide, swiper.slides);
2520    });
2521  }
2522  if (params.watchSlidesProgress) {
2523    swiper.updateSlidesOffset();
2524  }
2525  if (slideTo) {
2526    if (prependSlidesIndexes.length > 0 && isPrev) {
2527      if (typeof slideRealIndex === 'undefined') {
2528        const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2529        const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2530        const diff = newSlideTranslate - currentSlideTranslate;
2531        if (byMousewheel) {
2532          swiper.setTranslate(swiper.translate - diff);
2533        } else {
2534          swiper.slideTo(activeIndex + Math.ceil(slidesPrepended), 0, false, true);
2535          if (setTranslate) {
2536            swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2537            swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2538          }
2539        }
2540      } else {
2541        if (setTranslate) {
2542          const shift = gridEnabled ? prependSlidesIndexes.length / params.grid.rows : prependSlidesIndexes.length;
2543          swiper.slideTo(swiper.activeIndex + shift, 0, false, true);
2544          swiper.touchEventsData.currentTranslate = swiper.translate;
2545        }
2546      }
2547    } else if (appendSlidesIndexes.length > 0 && isNext) {
2548      if (typeof slideRealIndex === 'undefined') {
2549        const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2550        const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2551        const diff = newSlideTranslate - currentSlideTranslate;
2552        if (byMousewheel) {
2553          swiper.setTranslate(swiper.translate - diff);
2554        } else {
2555          swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2556          if (setTranslate) {
2557            swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2558            swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2559          }
2560        }
2561      } else {
2562        const shift = gridEnabled ? appendSlidesIndexes.length / params.grid.rows : appendSlidesIndexes.length;
2563        swiper.slideTo(swiper.activeIndex - shift, 0, false, true);
2564      }
2565    }
2566  }
2567  swiper.allowSlidePrev = allowSlidePrev;
2568  swiper.allowSlideNext = allowSlideNext;
2569  if (swiper.controller && swiper.controller.control && !byController) {
2570    const loopParams = {
2571      slideRealIndex,
2572      direction,
2573      setTranslate,
2574      activeSlideIndex,
2575      byController: true
2576    };
2577    if (Array.isArray(swiper.controller.control)) {
2578      swiper.controller.control.forEach(c => {
2579        if (!c.destroyed && c.params.loop) c.loopFix({
2580          ...loopParams,
2581          slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo : false
2582        });
2583      });
2584    } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
2585      swiper.controller.control.loopFix({
2586        ...loopParams,
2587        slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo : false
2588      });
2589    }
2590  }
2591  swiper.emit('loopFix');
2592}
2593
2594function loopDestroy() {
2595  const swiper = this;
2596  const {
2597    params,
2598    slidesEl
2599  } = swiper;
2600  if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2601  swiper.recalcSlides();
2602  const newSlidesOrder = [];

2603  swiper.slides.forEach(slideEl => {
2604    const index = typeof slideEl.swiperSlideIndex === 'undefined' ? slideEl.getAttribute('data-swiper-slide-index') * 1 : slideEl.swiperSlideIndex;
2605    newSlidesOrder[index] = slideEl;
2606  });
2607  swiper.slides.forEach(slideEl => {
2608    slideEl.removeAttribute('data-swiper-slide-index');
2609  });
2610  newSlidesOrder.forEach(slideEl => {
2611    slidesEl.append(slideEl);
2612  });
2613  swiper.recalcSlides();
2614  swiper.slideTo(swiper.realIndex, 0);
2615}
2616
2617var loop = {
2618  loopCreate,
2619  loopFix,
2620  loopDestroy
2621};
2622
2623function setGrabCursor(moving) {
2624  const swiper = this;
2625  if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
2626  const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
2627  if (swiper.isElement) {
2628    swiper.__preventObserver__ = true;
2629  }
2630  el.style.cursor = 'move';
2631  el.style.cursor = moving ? 'grabbing' : 'grab';
2632  if (swiper.isElement) {
2633    requestAnimationFrame(() => {
2634      swiper.__preventObserver__ = false;
2635    });
2636  }
2637}
2638
2639function unsetGrabCursor() {
2640  const swiper = this;
2641  if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
2642    return;
2643  }
2644  if (swiper.isElement) {
2645    swiper.__preventObserver__ = true;
2646  }
2647  swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
2648  if (swiper.isElement) {
2649    requestAnimationFrame(() => {
2650      swiper.__preventObserver__ = false;
2651    });
2652  }
2653}
2654
2655var grabCursor = {
2656  setGrabCursor,
2657  unsetGrabCursor
2658};
2659
2660// Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd
2661function closestElement(selector, base) {
2662  if (base === void 0) {
2663    base = this;
2664  }
2665  function __closestFrom(el) {
2666    if (!el || el === getDocument() || el === getWindow()) return null;
2667    if (el.assignedSlot) el = el.assignedSlot;
2668    const found = el.closest(selector);
2669    if (!found && !el.getRootNode) {
2670      return null;
2671    }
2672    return found || __closestFrom(el.getRootNode().host);
2673  }
2674  return __closestFrom(base);
2675}
2676function preventEdgeSwipe(swiper, event, startX) {
2677  const window = getWindow();
2678  const {
2679    params
2680  } = swiper;
2681  const edgeSwipeDetection = params.edgeSwipeDetection;
2682  const edgeSwipeThreshold = params.edgeSwipeThreshold;
2683  if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
2684    if (edgeSwipeDetection === 'prevent') {
2685      event.preventDefault();
2686      return true;
2687    }
2688    return false;
2689  }
2690  return true;
2691}
2692function onTouchStart(event) {
2693  const swiper = this;
2694  const document = getDocument();
2695  let e = event;
2696  if (e.originalEvent) e = e.originalEvent;
2697  const data = swiper.touchEventsData;
2698  if (e.type === 'pointerdown') {
2699    if (data.pointerId !== null && data.pointerId !== e.pointerId) {
2700      return;
2701    }
2702    data.pointerId = e.pointerId;
2703  } else if (e.type === 'touchstart' && e.targetTouches.length === 1) {
2704    data.touchId = e.targetTouches[0].identifier;
2705  }
2706  if (e.type === 'touchstart') {
2707    // don't proceed touch event
2708    preventEdgeSwipe(swiper, e, e.targetTouches[0].pageX);
2709    return;
2710  }
2711  const {
2712    params,
2713    touches,
2714    enabled
2715  } = swiper;
2716  if (!enabled) return;
2717  if (!params.simulateTouch && e.pointerType === 'mouse') return;
2718  if (swiper.animating && params.preventInteractionOnTransition) {
2719    return;
2720  }
2721  if (!swiper.animating && params.cssMode && params.loop) {
2722    swiper.loopFix();
2723  }
2724  let targetEl = e.target;
2725  if (params.touchEventsTarget === 'wrapper') {
2726    if (!elementIsChildOf(targetEl, swiper.wrapperEl)) return;
2727  }
2728  if ('which' in e && e.which === 3) return;
2729  if ('button' in e && e.button > 0) return;
2730  if (data.isTouched && data.isMoved) return;
2731
2732  // change target el for shadow root component
2733  const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';
2734  // eslint-disable-next-line
2735  const eventPath = e.composedPath ? e.composedPath() : e.path;
2736  if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
2737    targetEl = eventPath[0];
2738  }
2739  const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2740  const isTargetShadow = !!(e.target && e.target.shadowRoot);
2741
2742  // use closestElement for shadow root element to get the actual closest for nested shadow root element
2743  if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {
2744    swiper.allowClick = true;
2745    return;
2746  }
2747  if (params.swipeHandler) {
2748    if (!targetEl.closest(params.swipeHandler)) return;
2749  }
2750  touches.currentX = e.pageX;
2751  touches.currentY = e.pageY;
2752  const startX = touches.currentX;
2753  const startY = touches.currentY;
2754
2755  // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
2756
2757  if (!preventEdgeSwipe(swiper, e, startX)) {
2758    return;
2759  }
2760  Object.assign(data, {
2761    isTouched: true,
2762    isMoved: false,
2763    allowTouchCallbacks: true,
2764    isScrolling: undefined,
2765    startMoving: undefined
2766  });
2767  touches.startX = startX;
2768  touches.startY = startY;