https://www.zi.de/_assets/4483a80560873394161ba712d6ca7e9e/JS/_swiper-1b6c4e52.js

16
17
18/**
19 * SSR Window 4.0.2
20 * Better handling for window object in SSR environment
21 * https://github.com/nolimits4web/ssr-window
22 *
23 * Copyright 2021, Vladimir Kharlampidi
24 *
25 * Licensed under MIT
26 *
27 * Released on: December 13, 2021
28 */
29/* eslint-disable no-param-reassign */
30function isObject$1(obj) {
31    return (obj !== null &&
32        typeof obj === 'object' &&
33        'constructor' in obj &&
34        obj.constructor === Object);
35}
36function extend$1(target = {}, src = {}) {
37    Object.keys(src).forEach((key) => {
38        if (typeof target[key] === 'undefined')
39            target[key] = src[key];
40        else if (isObject$1(src[key]) &&
41            isObject$1(target[key]) &&
42            Object.keys(src[key]).length > 0) {
43            extend$1(target[key], src[key]);
44        }
45    });
46}
47
48const ssrDocument = {
49    body: {},
50    addEventListener() { },
51    removeEventListener() { },
52    activeElement: {
53        blur() { },
54        nodeName: '',
55    },
56    querySelector() {
57        return null;
58    },
59    querySelectorAll() {
60        return [];
61    },
62    getElementById() {
63        return null;
64    },
65    createEvent() {
66        return {
67            initEvent() { },
68        };
69    },
70    createElement() {
71        return {
72            children: [],
73            childNodes: [],
74            style: {},
75            setAttribute() { },
76            getElementsByTagName() {
77                return [];
78            },
79        };
80    },
81    createElementNS() {
82        return {};
83    },
84    importNode() {
85        return null;
86    },
87    location: {
88        hash: '',
89        host: '',
90        hostname: '',
91        href: '',
92        origin: '',
93        pathname: '',
94        protocol: '',
95        search: '',
96    },
97};
98function getDocument() {
99    const doc = typeof document !== 'undefined' ? document : {};
100    extend$1(doc, ssrDocument);
101    return doc;
102}
103
104const ssrWindow = {
105    document: ssrDocument,
106    navigator: {
107        userAgent: '',
108    },
109    location: {
110        hash: '',
111        host: '',
112        hostname: '',
113        href: '',
114        origin: '',
115        pathname: '',
116        protocol: '',
117        search: '',
118    },
119    history: {
120        replaceState() { },
121        pushState() { },
122        go() { },
123        back() { },
124    },
125    CustomEvent: function CustomEvent() {
126        return this;
127    },
128    addEventListener() { },
129    removeEventListener() { },
130    getComputedStyle() {
131        return {
132            getPropertyValue() {
133                return '';
134            },
135        };
136    },
137    Image() { },
138    Date() { },
139    screen: {},
140    setTimeout() { },
141    clearTimeout() { },
142    matchMedia() {
143        return {};
144    },
145    requestAnimationFrame(callback) {
146        if (typeof setTimeout === 'undefined') {
147            callback();
148            return null;
149        }
150        return setTimeout(callback, 0);
151    },
152    cancelAnimationFrame(id) {
153        if (typeof setTimeout === 'undefined') {
154            return;
155        }
156        clearTimeout(id);
157    },
158};
159function getWindow() {
160    const win = typeof window !== 'undefined' ? window : {};
161    extend$1(win, ssrWindow);
162    return win;
163}
164
165/**
166 * Dom7 4.0.6
167 * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API
168 * https://framework7.io/docs/dom7.html
169 *
170 * Copyright 2023, Vladimir Kharlampidi
171 *
172 * Licensed under MIT
173 *
174 * Released on: February 2, 2023
175 */
176
177/* eslint-disable no-proto */
178function makeReactive(obj) {
179  const proto = obj.__proto__;
180  Object.defineProperty(obj, '__proto__', {
181    get() {
182      return proto;
183    },
184
185    set(value) {
186      proto.__proto__ = value;
187    }
188
189  });
190}
191
192class Dom7 extends Array {
193  constructor(items) {
194    if (typeof items === 'number') {
195      super(items);
196    } else {
197      super(...(items || []));
198      makeReactive(this);
199    }
200  }
201
202}
203
204function arrayFlat(arr = []) {
205  const res = [];
206  arr.forEach(el => {
207    if (Array.isArray(el)) {
208      res.push(...arrayFlat(el));
209    } else {
210      res.push(el);
211    }
212  });
213  return res;
214}
215function arrayFilter(arr, callback) {
216  return Array.prototype.filter.call(arr, callback);
217}
218function arrayUnique(arr) {
219  const uniqueArray = [];
220
221  for (let i = 0; i < arr.length; i += 1) {
222    if (uniqueArray.indexOf(arr[i]) === -1) uniqueArray.push(arr[i]);
223  }
224
225  return uniqueArray;
226}
227
228// eslint-disable-next-line
229
230function qsa(selector, context) {
231  if (typeof selector !== 'string') {
232    return [selector];
233  }
234
235  const a = [];
236  const res = context.querySelectorAll(selector);
237
238  for (let i = 0; i < res.length; i += 1) {
239    a.push(res[i]);
240  }
241
242  return a;
243}
244
245function $(selector, context) {
246  const window = getWindow();
247  const document = getDocument();
248  let arr = [];
249
250  if (!context && selector instanceof Dom7) {
251    return selector;
252  }
253
254  if (!selector) {
255    return new Dom7(arr);
256  }
257
258  if (typeof selector === 'string') {
259    const html = selector.trim();
260
261    if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {
262      let toCreate = 'div';
263      if (html.indexOf('<li') === 0) toCreate = 'ul';
264      if (html.indexOf('<tr') === 0) toCreate = 'tbody';
265      if (html.indexOf('<td') === 0 || html.indexOf('<th') === 0) toCreate = 'tr';
266      if (html.indexOf('<tbody') === 0) toCreate = 'table';
267      if (html.indexOf('<option') === 0) toCreate = 'select';
268      const tempParent = document.createElement(toCreate);
269      tempParent.innerHTML = html;
270
271      for (let i = 0; i < tempParent.childNodes.length; i += 1) {
272        arr.push(tempParent.childNodes[i]);
273      }
274    } else {
275      arr = qsa(selector.trim(), context || document);
276    } // arr = qsa(selector, document);
277
278  } else if (selector.nodeType || selector === window || selector === document) {
279    arr.push(selector);
280  } else if (Array.isArray(selector)) {
281    if (selector instanceof Dom7) return selector;
282    arr = selector;
283  }
284
285  return new Dom7(arrayUnique(arr));
286}
287
288$.fn = Dom7.prototype;
289
290// eslint-disable-next-line
291
292function addClass(...classes) {
293  const classNames = arrayFlat(classes.map(c => c.split(' ')));
294  this.forEach(el => {
295    el.classList.add(...classNames);
296  });
297  return this;
298}
299
300function removeClass(...classes) {
301  const classNames = arrayFlat(classes.map(c => c.split(' ')));
302  this.forEach(el => {
303    el.classList.remove(...classNames);
304  });
305  return this;
306}
307
308function toggleClass(...classes) {
309  const classNames = arrayFlat(classes.map(c => c.split(' ')));
310  this.forEach(el => {
311    classNames.forEach(className => {
312      el.classList.toggle(className);
313    });
314  });
315}
316
317function hasClass(...classes) {
318  const classNames = arrayFlat(classes.map(c => c.split(' ')));
319  return arrayFilter(this, el => {
320    return classNames.filter(className => el.classList.contains(className)).length > 0;
321  }).length > 0;
322}
323
324function attr(attrs, value) {
325  if (arguments.length === 1 && typeof attrs === 'string') {
326    // Get attr
327    if (this[0]) return this[0].getAttribute(attrs);
328    return undefined;
329  } // Set attrs
330
331
332  for (let i = 0; i < this.length; i += 1) {
333    if (arguments.length === 2) {
334      // String
335      this[i].setAttribute(attrs, value);
336    } else {
337      // Object
338      for (const attrName in attrs) {
339        this[i][attrName] = attrs[attrName];
340        this[i].setAttribute(attrName, attrs[attrName]);
341      }
342    }
343  }
344
345  return this;
346}
347
348function removeAttr(attr) {
349  for (let i = 0; i < this.length; i += 1) {
350    this[i].removeAttribute(attr);
351  }
352
353  return this;
354}
355
356function transform(transform) {
357  for (let i = 0; i < this.length; i += 1) {
358    this[i].style.transform = transform;
359  }
360
361  return this;
362}
363
364function transition$1(duration) {
365  for (let i = 0; i < this.length; i += 1) {
366    this[i].style.transitionDuration = typeof duration !== 'string' ? `${duration}ms` : duration;
367  }
368
369  return this;
370}
371
372function on(...args) {
373  let [eventType, targetSelector, listener, capture] = args;
374
375  if (typeof args[1] === 'function') {
376    [eventType, listener, capture] = args;
377    targetSelector = undefined;
378  }
379
380  if (!capture) capture = false;
381
382  function handleLiveEvent(e) {
383    const target = e.target;
384    if (!target) return;
385    const eventData = e.target.dom7EventData || [];
386
387    if (eventData.indexOf(e) < 0) {
388      eventData.unshift(e);
389    }
390
391    if ($(target).is(targetSelector)) listener.apply(target, eventData);else {
392      const parents = $(target).parents(); // eslint-disable-line
393
394      for (let k = 0; k < parents.length; k += 1) {
395        if ($(parents[k]).is(targetSelector)) listener.apply(parents[k], eventData);
396      }
397    }
398  }
399
400  function handleEvent(e) {
401    const eventData = e && e.target ? e.target.dom7EventData || [] : [];
402
403    if (eventData.indexOf(e) < 0) {
404      eventData.unshift(e);
405    }
406
407    listener.apply(this, eventData);
408  }
409
410  const events = eventType.split(' ');
411  let j;
412
413  for (let i = 0; i < this.length; i += 1) {
414    const el = this[i];
415
416    if (!targetSelector) {
417      for (j = 0; j < events.length; j += 1) {
418        const event = events[j];
419        if (!el.dom7Listeners) el.dom7Listeners = {};
420        if (!el.dom7Listeners[event]) el.dom7Listeners[event] = [];
421        el.dom7Listeners[event].push({
422          listener,
423          proxyListener: handleEvent
424        });
425        el.addEventListener(event, handleEvent, capture);
426      }
427    } else {
428      // Live events
429      for (j = 0; j < events.length; j += 1) {
430        const event = events[j];
431        if (!el.dom7LiveListeners) el.dom7LiveListeners = {};
432        if (!el.dom7LiveListeners[event]) el.dom7LiveListeners[event] = [];
433        el.dom7LiveListeners[event].push({
434          listener,
435          proxyListener: handleLiveEvent
436        });
437        el.addEventListener(event, handleLiveEvent, capture);
438      }
439    }
440  }
441
442  return this;
443}
444
445function off(...args) {
446  let [eventType, targetSelector, listener, capture] = args;
447
448  if (typeof args[1] === 'function') {
449    [eventType, listener, capture] = args;
450    targetSelector = undefined;
451  }
452
453  if (!capture) capture = false;
454  const events = eventType.split(' ');
455
456  for (let i = 0; i < events.length; i += 1) {
457    const event = events[i];
458
459    for (let j = 0; j < this.length; j += 1) {
460      const el = this[j];
461      let handlers;
462
463      if (!targetSelector && el.dom7Listeners) {
464        handlers = el.dom7Listeners[event];
465      } else if (targetSelector && el.dom7LiveListeners) {
466        handlers = el.dom7LiveListeners[event];
467      }
468
469      if (handlers && handlers.length) {
470        for (let k = handlers.length - 1; k >= 0; k -= 1) {
471          const handler = handlers[k];
472
473          if (listener && handler.listener === listener) {
474            el.removeEventListener(event, handler.proxyListener, capture);
475            handlers.splice(k, 1);
476          } else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) {
477            el.removeEventListener(event, handler.proxyListener, capture);
478            handlers.splice(k, 1);
479          } else if (!listener) {
480            el.removeEventListener(event, handler.proxyListener, capture);
481            handlers.splice(k, 1);
482          }
483        }
484      }
485    }
486  }
487
488  return this;
489}
490
491function trigger(...args) {
492  const window = getWindow();
493  const events = args[0].split(' ');
494  const eventData = args[1];
495
496  for (let i = 0; i < events.length; i += 1) {
497    const event = events[i];
498
499    for (let j = 0; j < this.length; j += 1) {
500      const el = this[j];
501
502      if (window.CustomEvent) {
503        const evt = new window.CustomEvent(event, {
504          detail: eventData,
505          bubbles: true,
506          cancelable: true
507        });
508        el.dom7EventData = args.filter((data, dataIndex) => dataIndex > 0);
509        el.dispatchEvent(evt);
510        el.dom7EventData = [];
511        delete el.dom7EventData;
512      }
513    }
514  }
515
516  return this;
517}
518
519function transitionEnd$1(callback) {
520  const dom = this;
521
522  function fireCallBack(e) {
523    if (e.target !== this) return;
524    callback.call(this, e);
525    dom.off('transitionend', fireCallBack);
526  }
527
528  if (callback) {
529    dom.on('transitionend', fireCallBack);
530  }
531
532  return this;
533}
534
535function outerWidth(includeMargins) {
536  if (this.length > 0) {
537    if (includeMargins) {
538      const styles = this.styles();
539      return this[0].offsetWidth + parseFloat(styles.getPropertyValue('margin-right')) + parseFloat(styles.getPropertyValue('margin-left'));
540    }
541
542    return this[0].offsetWidth;
543  }
544
545  return null;
546}
547
548function outerHeight(includeMargins) {
549  if (this.length > 0) {
550    if (includeMargins) {
551      const styles = this.styles();
552      return this[0].offsetHeight + parseFloat(styles.getPropertyValue('margin-top')) + parseFloat(styles.getPropertyValue('margin-bottom'));
553    }
554
555    return this[0].offsetHeight;
556  }
557
558  return null;
559}
560
561function offset() {
562  if (this.length > 0) {
563    const window = getWindow();
564    const document = getDocument();
565    const el = this[0];
566    const box = el.getBoundingClientRect();
567    const body = document.body;
568    const clientTop = el.clientTop || body.clientTop || 0;
569    const clientLeft = el.clientLeft || body.clientLeft || 0;
570    const scrollTop = el === window ? window.scrollY : el.scrollTop;
571    const scrollLeft = el === window ? window.scrollX : el.scrollLeft;
572    return {
573      top: box.top + scrollTop - clientTop,
574      left: box.left + scrollLeft - clientLeft
575    };
576  }
577
578  return null;
579}
580
581function styles() {
582  const window = getWindow();
583  if (this[0]) return window.getComputedStyle(this[0], null);
584  return {};
585}
586
587function css(props, value) {
588  const window = getWindow();
589  let i;
590
591  if (arguments.length === 1) {
592    if (typeof props === 'string') {
593      // .css('width')
594      if (this[0]) return window.getComputedStyle(this[0], null).getPropertyValue(props);
595    } else {
596      // .css({ width: '100px' })
597      for (i = 0; i < this.length; i += 1) {
598        for (const prop in props) {
599          this[i].style[prop] = props[prop];
600        }
601      }
602
603      return this;
604    }
605  }
606
607  if (arguments.length === 2 && typeof props === 'string') {
608    // .css('width', '100px')
609    for (i = 0; i < this.length; i += 1) {
610      this[i].style[props] = value;
611    }
612
613    return this;
614  }
615
616  return this;
617}
618
619function each(callback) {
620  if (!callback) return this;
621  this.forEach((el, index) => {
622    callback.apply(el, [el, index]);
623  });
624  return this;
625}
626
627function filter(callback) {
628  const result = arrayFilter(this, callback);
629  return $(result);
630}
631
632function html(html) {
633  if (typeof html === 'undefined') {
634    return this[0] ? this[0].innerHTML : null;
635  }
636
637  for (let i = 0; i < this.length; i += 1) {
638    this[i].innerHTML = html;
639  }
640
641  return this;
642}
643
644function text(text) {
645  if (typeof text === 'undefined') {
646    return this[0] ? this[0].textContent.trim() : null;
647  }
648
649  for (let i = 0; i < this.length; i += 1) {
650    this[i].textContent = text;
651  }
652
653  return this;
654}
655
656function is(selector) {
657  const window = getWindow();
658  const document = getDocument();
659  const el = this[0];
660  let compareWith;
661  let i;
662  if (!el || typeof selector === 'undefined') return false;
663
664  if (typeof selector === 'string') {
665    if (el.matches) return el.matches(selector);
666    if (el.webkitMatchesSelector) return el.webkitMatchesSelector(selector);
667    if (el.msMatchesSelector) return el.msMatchesSelector(selector);
668    compareWith = $(selector);
669
670    for (i = 0; i < compareWith.length; i += 1) {
671      if (compareWith[i] === el) return true;
672    }
673
674    return false;
675  }
676
677  if (selector === document) {
678    return el === document;
679  }
680
681  if (selector === window) {
682    return el === window;
683  }
684
685  if (selector.nodeType || selector instanceof Dom7) {
686    compareWith = selector.nodeType ? [selector] : selector;
687
688    for (i = 0; i < compareWith.length; i += 1) {
689      if (compareWith[i] === el) return true;
690    }
691
692    return false;
693  }
694
695  return false;
696}
697
698function index() {
699  let child = this[0];
700  let i;
701
702  if (child) {
703    i = 0; // eslint-disable-next-line
704
705    while ((child = child.previousSibling) !== null) {
706      if (child.nodeType === 1) i += 1;
707    }
708
709    return i;
710  }
711
712  return undefined;
713}
714
715function eq(index) {
716  if (typeof index === 'undefined') return this;
717  const length = this.length;
718
719  if (index > length - 1) {
720    return $([]);
721  }
722
723  if (index < 0) {
724    const returnIndex = length + index;
725    if (returnIndex < 0) return $([]);
726    return $([this[returnIndex]]);
727  }
728
729  return $([this[index]]);
730}
731
732function append(...els) {
733  let newChild;
734  const document = getDocument();
735
736  for (let k = 0; k < els.length; k += 1) {
737    newChild = els[k];
738
739    for (let i = 0; i < this.length; i += 1) {
740      if (typeof newChild === 'string') {
741        const tempDiv = document.createElement('div');
742        tempDiv.innerHTML = newChild;
743
744        while (tempDiv.firstChild) {
745          this[i].appendChild(tempDiv.firstChild);
746        }
747      } else if (newChild instanceof Dom7) {
748        for (let j = 0; j < newChild.length; j += 1) {
749          this[i].appendChild(newChild[j]);
750        }
751      } else {
752        this[i].appendChild(newChild);
753      }
754    }
755  }
756
757  return this;
758}
759
760function prepend(newChild) {
761  const document = getDocument();
762  let i;
763  let j;
764
765  for (i = 0; i < this.length; i += 1) {
766    if (typeof newChild === 'string') {
767      const tempDiv = document.createElement('div');
768      tempDiv.innerHTML = newChild;
769
770      for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
771        this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
772      }
773    } else if (newChild instanceof Dom7) {
774      for (j = 0; j < newChild.length; j += 1) {
775        this[i].insertBefore(newChild[j], this[i].childNodes[0]);
776      }
777    } else {
778      this[i].insertBefore(newChild, this[i].childNodes[0]);
779    }
780  }
781
782  return this;
783}
784
785function next(selector) {
786  if (this.length > 0) {
787    if (selector) {
788      if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {
789        return $([this[0].nextElementSibling]);
790      }
791
792      return $([]);
793    }
794
795    if (this[0].nextElementSibling) return $([this[0].nextElementSibling]);
796    return $([]);
797  }
798
799  return $([]);
800}
801
802function nextAll(selector) {
803  const nextEls = [];
804  let el = this[0];
805  if (!el) return $([]);
806
807  while (el.nextElementSibling) {
808    const next = el.nextElementSibling; // eslint-disable-line
809
810    if (selector) {
811      if ($(next).is(selector)) nextEls.push(next);
812    } else nextEls.push(next);
813
814    el = next;
815  }
816
817  return $(nextEls);
818}
819
820function prev(selector) {
821  if (this.length > 0) {
822    const el = this[0];
823
824    if (selector) {
825      if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {
826        return $([el.previousElementSibling]);
827      }
828
829      return $([]);
830    }
831
832    if (el.previousElementSibling) return $([el.previousElementSibling]);
833    return $([]);
834  }
835
836  return $([]);
837}
838
839function prevAll(selector) {
840  const prevEls = [];
841  let el = this[0];
842  if (!el) return $([]);
843
844  while (el.previousElementSibling) {
845    const prev = el.previousElementSibling; // eslint-disable-line
846
847    if (selector) {
848      if ($(prev).is(selector)) prevEls.push(prev);
849    } else prevEls.push(prev);
850
851    el = prev;
852  }
853
854  return $(prevEls);
855}
856
857function parent(selector) {
858  const parents = []; // eslint-disable-line
859
860  for (let i = 0; i < this.length; i += 1) {
861    if (this[i].parentNode !== null) {
862      if (selector) {
863        if ($(this[i].parentNode).is(selector)) parents.push(this[i].parentNode);
864      } else {
865        parents.push(this[i].parentNode);
866      }
867    }
868  }
869
870  return $(parents);
871}
872
873function parents(selector) {
874  const parents = []; // eslint-disable-line
875
876  for (let i = 0; i < this.length; i += 1) {
877    let parent = this[i].parentNode; // eslint-disable-line
878
879    while (parent) {
880      if (selector) {
881        if ($(parent).is(selector)) parents.push(parent);
882      } else {
883        parents.push(parent);
884      }
885
886      parent = parent.parentNode;
887    }
888  }
889
890  return $(parents);
891}
892
893function closest(selector) {
894  let closest = this; // eslint-disable-line
895
896  if (typeof selector === 'undefined') {
897    return $([]);
898  }
899
900  if (!closest.is(selector)) {
901    closest = closest.parents(selector).eq(0);
902  }
903
904  return closest;
905}
906
907function find(selector) {
908  const foundElements = [];
909
910  for (let i = 0; i < this.length; i += 1) {
911    const found = this[i].querySelectorAll(selector);
912
913    for (let j = 0; j < found.length; j += 1) {
914      foundElements.push(found[j]);
915    }
916  }
917
918  return $(foundElements);
919}
920
921function children(selector) {
922  const children = []; // eslint-disable-line
923
924  for (let i = 0; i < this.length; i += 1) {
925    const childNodes = this[i].children;
926
927    for (let j = 0; j < childNodes.length; j += 1) {
928      if (!selector || $(childNodes[j]).is(selector)) {
929        children.push(childNodes[j]);
930      }
931    }
932  }
933
934  return $(children);
935}
936
937function remove() {
938  for (let i = 0; i < this.length; i += 1) {
939    if (this[i].parentNode) this[i].parentNode.removeChild(this[i]);
940  }
941
942  return this;
943}
944
945const Methods = {
946  addClass,
947  removeClass,
948  hasClass,
949  toggleClass,
950  attr,
951  removeAttr,
952  transform,
953  transition: transition$1,
954  on,
955  off,
956  trigger,
957  transitionEnd: transitionEnd$1,
958  outerWidth,
959  outerHeight,
960  styles,
961  offset,
962  css,
963  each,
964  html,
965  text,
966  is,
967  index,
968  eq,
969  append,
970  prepend,
971  next,
972  nextAll,
973  prev,
974  prevAll,
975  parent,
976  parents,
977  closest,
978  find,
979  children,
980  filter,
981  remove
982};
983Object.keys(Methods).forEach(methodName => {
984  Object.defineProperty($.fn, methodName, {
985    value: Methods[methodName],
986    writable: true
987  });
988});
989
990function deleteProps(obj) {
991  const object = obj;
992  Object.keys(object).forEach(key => {
993    try {
994      object[key] = null;
995    } catch (e) {// no getter for object
996    }
997
998    try {
999      delete object[key];
1000    } catch (e) {// something got wrong
1001    }
1002  });
1003}
1004
1005function nextTick(callback, delay = 0) {
1006  return setTimeout(callback, delay);
1007}
1008
1009function now() {
1010  return Date.now();
1011}
1012
1013function getComputedStyle$1(el) {
1014  const window = getWindow();
1015  let style;
1016
1017  if (window.getComputedStyle) {
1018    style = window.getComputedStyle(el, null);
1019  }
1020
1021  if (!style && el.currentStyle) {
1022    style = el.currentStyle;
1023  }
1024
1025  if (!style) {
1026    style = el.style;
1027  }
1028
1029  return style;
1030}
1031
1032function getTranslate(el, axis = 'x') {
1033  const window = getWindow();
1034  let matrix;
1035  let curTransform;
1036  let transformMatrix;
1037  const curStyle = getComputedStyle$1(el);
1038
1039  if (window.WebKitCSSMatrix) {
1040    curTransform = curStyle.transform || curStyle.webkitTransform;
1041
1042    if (curTransform.split(',').length > 6) {
1043      curTransform = curTransform.split(', ').map(a => a.replace(',', '.')).join(', ');
1044    } // Some old versions of Webkit choke when 'none' is passed; pass
1045    // empty string instead in this case
1046
1047
1048    transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
1049  } else {
1050    transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
1051    matrix = transformMatrix.toString().split(',');
1052  }
1053
1054  if (axis === 'x') {
1055    // Latest Chrome and webkits Fix
1056    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41; // Crazy IE10 Matrix
1057    else if (matrix.length === 16) curTransform = parseFloat(matrix[12]); // Normal Browsers
1058    else curTransform = parseFloat(matrix[4]);
1059  }
1060
1061  if (axis === 'y') {
1062    // Latest Chrome and webkits Fix
1063    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42; // Crazy IE10 Matrix
1064    else if (matrix.length === 16) curTransform = parseFloat(matrix[13]); // Normal Browsers
1065    else curTransform = parseFloat(matrix[5]);
1066  }
1067
1068  return curTransform || 0;
1069}
1070
1071function isObject(o) {
1072  return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';
1073}
1074
1075function isNode(node) {
1076  // eslint-disable-next-line
1077  if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
1078    return node instanceof HTMLElement;
1079  }
1080
1081  return node && (node.nodeType === 1 || node.nodeType === 11);
1082}
1083
1084function extend(...args) {
1085  const to = Object(args[0]);
1086  const noExtend = ['__proto__', 'constructor', 'prototype'];
1087
1088  for (let i = 1; i < args.length; i += 1) {
1089    const nextSource = args[i];
1090
1091    if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
1092      const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);
1093
1094      for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
1095        const nextKey = keysArray[nextIndex];
1096        const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
1097
1098        if (desc !== undefined && desc.enumerable) {
1099          if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1100            if (nextSource[nextKey].__swiper__) {
1101              to[nextKey] = nextSource[nextKey];
1102            } else {
1103              extend(to[nextKey], nextSource[nextKey]);
1104            }
1105          } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1106            to[nextKey] = {};
1107
1108            if (nextSource[nextKey].__swiper__) {
1109              to[nextKey] = nextSource[nextKey];
1110            } else {
1111              extend(to[nextKey], nextSource[nextKey]);
1112            }
1113          } else {
1114            to[nextKey] = nextSource[nextKey];
1115          }
1116        }
1117      }
1118    }
1119  }
1120
1121  return to;
1122}
1123
1124function setCSSProperty(el, varName, varValue) {
1125  el.style.setProperty(varName, varValue);
1126}
1127
1128function animateCSSModeScroll({
1129  swiper,
1130  targetPosition,
1131  side
1132}) {
1133  const window = getWindow();
1134  const startPosition = -swiper.translate;
1135  let startTime = null;
1136  let time;
1137  const duration = swiper.params.speed;
1138  swiper.wrapperEl.style.scrollSnapType = 'none';
1139  window.cancelAnimationFrame(swiper.cssModeFrameID);
1140  const dir = targetPosition > startPosition ? 'next' : 'prev';
1141
1142  const isOutOfBound = (current, target) => {
1143    return dir === 'next' && current >= target || dir === 'prev' && current <= target;
1144  };
1145
1146  const animate = () => {
1147    time = new Date().getTime();
1148
1149    if (startTime === null) {
1150      startTime = time;
1151    }
1152
1153    const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
1154    const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;
1155    let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
1156
1157    if (isOutOfBound(currentPosition, targetPosition)) {
1158      currentPosition = targetPosition;
1159    }
1160
1161    swiper.wrapperEl.scrollTo({
1162      [side]: currentPosition
1163    });
1164
1165    if (isOutOfBound(currentPosition, targetPosition)) {
1166      swiper.wrapperEl.style.overflow = 'hidden';
1167      swiper.wrapperEl.style.scrollSnapType = '';
1168      setTimeout(() => {
1169        swiper.wrapperEl.style.overflow = '';
1170        swiper.wrapperEl.scrollTo({
1171          [side]: currentPosition
1172        });
1173      });
1174      window.cancelAnimationFrame(swiper.cssModeFrameID);
1175      return;
1176    }
1177
1178    swiper.cssModeFrameID = window.requestAnimationFrame(animate);
1179  };
1180
1181  animate();
1182}
1183
1184let support;
1185
1186function calcSupport() {
1187  const window = getWindow();
1188  const document = getDocument();
1189  return {
1190    smoothScroll: document.documentElement && 'scrollBehavior' in document.documentElement.style,
1191    touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch),
1192    passiveListener: function checkPassiveListener() {
1193      let supportsPassive = false;
1194
1195      try {
1196        const opts = Object.defineProperty({}, 'passive', {
1197          // eslint-disable-next-line
1198          get() {
1199            supportsPassive = true;
1200          }
1201
1202        });
1203        window.addEventListener('testPassiveListener', null, opts);
1204      } catch (e) {// No support
1205      }
1206
1207      return supportsPassive;
1208    }(),
1209    gestures: function checkGestures() {
1210      return 'ongesturestart' in window;
1211    }()
1212  };
1213}
1214
1215function getSupport() {
1216  if (!support) {
1217    support = calcSupport();
1218  }
1219
1220  return support;
1221}
1222
1223let deviceCached;
1224
1225function calcDevice({
1226  userAgent
1227} = {}) {
1228  const support = getSupport();
1229  const window = getWindow();
1230  const platform = window.navigator.platform;
1231  const ua = userAgent || window.navigator.userAgent;
1232  const device = {
1233    ios: false,
1234    android: false
1235  };
1236  const screenWidth = window.screen.width;
1237  const screenHeight = window.screen.height;
1238  const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
1239
1240  let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
1241  const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
1242  const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
1243  const windows = platform === 'Win32';
1244  let macos = platform === 'MacIntel'; // iPadOs 13 fix
1245
1246  const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
1247
1248  if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
1249    ipad = ua.match(/(Version)\/([\d.]+)/);
1250    if (!ipad) ipad = [0, 1, '13_0_0'];
1251    macos = false;
1252  } // Android
1253
1254
1255  if (android && !windows) {
1256    device.os = 'android';
1257    device.android = true;
1258  }
1259
1260  if (ipad || iphone || ipod) {
1261    device.os = 'ios';
1262    device.ios = true;
1263  } // Export object
1264
1265
1266  return device;
1267}
1268
1269function getDevice(overrides = {}) {
1270  if (!deviceCached) {
1271    deviceCached = calcDevice(overrides);
1272  }
1273
1274  return deviceCached;
1275}
1276
1277let browser;
1278
1279function calcBrowser() {
1280  const window = getWindow();
1281
1282  function isSafari() {
1283    const ua = window.navigator.userAgent.toLowerCase();
1284    return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
1285  }
1286
1287  return {
1288    isSafari: isSafari(),
1289    isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)
1290  };
1291}
1292
1293function getBrowser() {
1294  if (!browser) {
1295    browser = calcBrowser();
1296  }
1297
1298  return browser;
1299}
1300
1301function Resize({
1302  swiper,
1303  on,
1304  emit
1305}) {
1306  const window = getWindow();
1307  let observer = null;

1308  let animationFrame = null;
1309
1310  const resizeHandler = () => {
1311    if (!swiper || swiper.destroyed || !swiper.initialized) return;
1312    emit('beforeResize');
1313    emit('resize');
1314  };
1315
1316  const createObserver = () => {
1317    if (!swiper || swiper.destroyed || !swiper.initialized) return;
1318    observer = new ResizeObserver(entries => {
1319      animationFrame = window.requestAnimationFrame(() => {
1320        const {
1321          width,
1322          height
1323        } = swiper;
1324        let newWidth = width;
1325        let newHeight = height;
1326        entries.forEach(({
1327          contentBoxSize,
1328          contentRect,
1329          target
1330        }) => {
1331          if (target && target !== swiper.el) return;
1332          newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
1333          newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
1334        });
1335
1336        if (newWidth !== width || newHeight !== height) {
1337          resizeHandler();
1338        }
1339      });
1340    });
1341    observer.observe(swiper.el);
1342  };
1343
1344  const removeObserver = () => {
1345    if (animationFrame) {
1346      window.cancelAnimationFrame(animationFrame);
1347    }
1348
1349    if (observer && observer.unobserve && swiper.el) {
1350      observer.unobserve(swiper.el);
1351      observer = null;
1352    }
1353  };
1354
1355  const orientationChangeHandler = () => {
1356    if (!swiper || swiper.destroyed || !swiper.initialized) return;
1357    emit('orientationchange');
1358  };
1359
1360  on('init', () => {
1361    if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
1362      createObserver();
1363      return;
1364    }
1365
1366    window.addEventListener('resize', resizeHandler);
1367    window.addEventListener('orientationchange', orientationChangeHandler);
1368  });
1369  on('destroy', () => {
1370    removeObserver();
1371    window.removeEventListener('resize', resizeHandler);
1372    window.removeEventListener('orientationchange', orientationChangeHandler);
1373  });
1374}
1375
1376function Observer({
1377  swiper,
1378  extendParams,
1379  on,
1380  emit
1381}) {
1382  const observers = [];
1383  const window = getWindow();
1384
1385  const attach = (target, options = {}) => {
1386    const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
1387    const observer = new ObserverFunc(mutations => {
1388      // The observerUpdate event should only be triggered
1389      // once despite the number of mutations.  Additional
1390      // triggers are redundant and are very costly
1391      if (mutations.length === 1) {
1392        emit('observerUpdate', mutations[0]);
1393        return;
1394      }
1395
1396      const observerUpdate = function observerUpdate() {
1397        emit('observerUpdate', mutations[0]);
1398      };
1399
1400      if (window.requestAnimationFrame) {
1401        window.requestAnimationFrame(observerUpdate);
1402      } else {
1403        window.setTimeout(observerUpdate, 0);
1404      }
1405    });
1406    observer.observe(target, {
1407      attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
1408      childList: typeof options.childList === 'undefined' ? true : options.childList,
1409      characterData: typeof options.characterData === 'undefined' ? true : options.characterData
1410    });
1411    observers.push(observer);
1412  };
1413
1414  const init = () => {
1415    if (!swiper.params.observer) return;
1416
1417    if (swiper.params.observeParents) {
1418      const containerParents = swiper.$el.parents();
1419
1420      for (let i = 0; i < containerParents.length; i += 1) {
1421        attach(containerParents[i]);
1422      }
1423    } // Observe container
1424
1425
1426    attach(swiper.$el[0], {
1427      childList: swiper.params.observeSlideChildren
1428    }); // Observe wrapper
1429
1430    attach(swiper.$wrapperEl[0], {
1431      attributes: false
1432    });
1433  };
1434
1435  const destroy = () => {

1436    observers.forEach(observer => {
1437      observer.disconnect();
1438    });
1439    observers.splice(0, observers.length);
1440  };
1441
1442  extendParams({
1443    observer: false,
1444    observeParents: false,
1445    observeSlideChildren: false
1446  });
1447  on('init', init);
1448  on('destroy', destroy);
1449}
1450
1451/* eslint-disable no-underscore-dangle */
1452var eventsEmitter = {
1453  on(events, handler, priority) {
1454    const self = this;
1455    if (!self.eventsListeners || self.destroyed) return self;
1456    if (typeof handler !== 'function') return self;
1457    const method = priority ? 'unshift' : 'push';
1458    events.split(' ').forEach(event => {
1459      if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
1460      self.eventsListeners[event][method](handler);
1461    });
1462    return self;
1463  },
1464
1465  once(events, handler, priority) {
1466    const self = this;
1467    if (!self.eventsListeners || self.destroyed) return self;
1468    if (typeof handler !== 'function') return self;
1469
1470    function onceHandler(...args) {
1471      self.off(events, onceHandler);
1472
1473      if (onceHandler.__emitterProxy) {
1474        delete onceHandler.__emitterProxy;
1475      }
1476
1477      handler.apply(self, args);
1478    }
1479
1480    onceHandler.__emitterProxy = handler;
1481    return self.on(events, onceHandler, priority);
1482  },
1483
1484  onAny(handler, priority) {
1485    const self = this;
1486    if (!self.eventsListeners || self.destroyed) return self;
1487    if (typeof handler !== 'function') return self;
1488    const method = priority ? 'unshift' : 'push';
1489
1490    if (self.eventsAnyListeners.indexOf(handler) < 0) {
1491      self.eventsAnyListeners[method](handler);
1492    }
1493
1494    return self;
1495  },
1496
1497  offAny(handler) {
1498    const self = this;
1499    if (!self.eventsListeners || self.destroyed) return self;
1500    if (!self.eventsAnyListeners) return self;
1501    const index = self.eventsAnyListeners.indexOf(handler);
1502
1503    if (index >= 0) {
1504      self.eventsAnyListeners.splice(index, 1);
1505    }
1506
1507    return self;
1508  },
1509
1510  off(events, handler) {
1511    const self = this;
1512    if (!self.eventsListeners || self.destroyed) return self;
1513    if (!self.eventsListeners) return self;
1514    events.split(' ').forEach(event => {
1515      if (typeof handler === 'undefined') {
1516        self.eventsListeners[event] = [];
1517      } else if (self.eventsListeners[event]) {
1518        self.eventsListeners[event].forEach((eventHandler, index) => {
1519          if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
1520            self.eventsListeners[event].splice(index, 1);
1521          }
1522        });
1523      }
1524    });
1525    return self;
1526  },
1527
1528  emit(...args) {
1529    const self = this;
1530    if (!self.eventsListeners || self.destroyed) return self

1530;
1531    if (!self.eventsListeners) return self;
1532    let events;
1533    let data;
1534    let context;
1535
1536    if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1537      events = args[0];
1538      data = args.slice(1, args.length);
1539      context = self;
1540    } else {
1541      events = args[0].events;
1542      data = args[0].data;
1543      context = args[0].context || self;
1544    }
1545
1546    data.unshift(context);
1547    const eventsArray = Array.isArray(events) ? events : events.split(' ');
1548    eventsArray.forEach(event => {
1549      if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
1550        self.eventsAnyListeners.forEach(eventHandler => {
1551          eventHandler.apply(context, [event, ...data]);
1552        });
1553      }
1554
1555      if (self.eventsListeners && self.eventsListeners[event]) {
1556        self.eventsListeners[event].forEach(eventHandler => {
1557          eventHandler.apply(context, data);
1558        });
1559      }
1560    });
1561    return self;
1562  }
1563
1564};
1565
1566function updateSize() {
1567  const swiper = this;
1568  let width;
1569  let height;
1570  const $el = swiper.$el;
1571
1572  if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
1573    width = swiper.params.width;
1574  } else {
1575    width = $el[0].clientWidth;
1576  }
1577
1578  if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
1579    height = swiper.params.height;
1580  } else {
1581    height = $el[0].clientHeight;
1582  }
1583
1584  if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
1585    return;
1586  } // Subtract paddings
1587
1588
1589  width = width - parseInt($el.css('padding-left') || 0, 10) - parseInt($el.css('padding-right') || 0, 10);
1590  height = height - parseInt($el.css('padding-top') || 0, 10) - parseInt($el.css('padding-bottom') || 0, 10);
1591  if (Number.isNaN(width)) width = 0;
1592  if (Number.isNaN(height)) height = 0;
1593  Object.assign(swiper, {
1594    width,
1595    height,
1596    size: swiper.isHorizontal() ? width : height
1597  });
1598}
1599
1600function updateSlides() {
1601  const swiper = this;
1602
1603  function getDirectionLabel(property) {
1604    if (swiper.isHorizontal()) {
1605      return property;
1606    } // prettier-ignore
1607
1608
1609    return {
1610      'width': 'height',
1611      'margin-top': 'margin-left',
1612      'margin-bottom ': 'margin-right',
1613      'margin-left': 'margin-top',
1614      'margin-right': 'margin-bottom',
1615      'padding-left': 'padding-top',
1616      'padding-right': 'padding-bottom',
1617      'marginRight': 'marginBottom'
1618    }[property];
1619  }
1620
1621  function getDirectionPropertyValue(node, label) {
1622    return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);
1623  }
1624
1625  const params = swiper.params;
1626  const {
1627    $wrapperEl,
1628    size: swiperSize,
1629    rtlTranslate: rtl,
1630    wrongRTL
1631  } = swiper;
1632  const isVirtual = swiper.virtual && params.virtual.enabled;
1633  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1634  const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);
1635  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1636  let snapGrid = [];
1637  const slidesGrid = [];
1638  const slidesSizesGrid = [];
1639  let offsetBefore = params.slidesOffsetBefore;
1640
1641  if (typeof offsetBefore === 'function') {
1642    offsetBefore = params.slidesOffsetBefore.call(swiper);
1643  }
1644
1645  let offsetAfter = params.slidesOffsetAfter;
1646
1647  if (typeof offsetAfter === 'function') {
1648    offsetAfter = params.slidesOffsetAfter.call(swiper);
1649  }
1650
1651  const previousSnapGridLength = swiper.snapGrid.length;
1652  const previousSlidesGridLength = swiper.slidesGrid.length;
1653  let spaceBetween = params.spaceBetween;
1654  let slidePosition = -offsetBefore;
1655  let prevSlideSize = 0;
1656  let index = 0;
1657
1658  if (typeof swiperSize === 'undefined') {
1659    return;
1660  }
1661
1662  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1663    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
1664  }
1665
1666  swiper.virtualSize = -spaceBetween; // reset margins
1667
1668  if (rtl) slides.css({
1669    marginLeft: '',
1670    marginBottom: '',
1671    marginTop: ''
1672  });else slides.css({
1673    marginRight: '',
1674    marginBottom: '',
1675    marginTop: ''
1676  }); // reset cssMode offsets
1677
1678  if (params.centeredSlides && params.cssMode) {
1679    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', '');
1680    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', '');
1681  }
1682
1683  const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
1684
1685  if (gridEnabled) {
1686    swiper.grid.initSlides(slidesLength);
1687  } // Calc slides
1688
1689
1690  let slideSize;
1691  const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
1692    return typeof params.breakpoints[key].slidesPerView !== 'undefined';
1693  }).length > 0;
1694
1695  for (let i = 0; i < slidesLength; i += 1) {
1696    slideSize = 0;
1697    const slide = slides.eq(i);
1698
1699    if (gridEnabled) {
1700      swiper.grid.updateSlide(i, slide, slidesLength, getDirectionLabel);
1701    }
1702
1703    if (slide.css('display') === 'none') continue; // eslint-disable-line
1704
1705    if (params.slidesPerView === 'auto') {
1706      if (shouldResetSlideSize) {
1707        slides[i].style[getDirectionLabel('width')] = ``;
1708      }
1709
1710      const slideStyles = getComputedStyle(slide[0]);
1711      const currentTransform = slide[0].style.transform;
1712      const currentWebKitTransform = slide[0].style.webkitTransform;
1713
1714      if (currentTransform) {
1715        slide[0].style.transform = 'none';
1716      }
1717
1718      if (currentWebKitTransform) {
1719        slide[0].style.webkitTransform = 'none';
1720      }
1721
1722      if (params.roundLengths) {
1723        slideSize = swiper.isHorizontal() ? slide.outerWidth(true) : slide.outerHeight(true);
1724      } else {
1725        // eslint-disable-next-line
1726        const width = getDirectionPropertyValue(slideStyles, 'width');
1727        const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
1728        const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
1729        const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
1730        const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
1731        const boxSizing = slideStyles.getPropertyValue('box-sizing');
1732
1733        if (boxSizing && boxSizing === 'border-box') {
1734          slideSize = width + marginLeft + marginRight;
1735        } else {
1736          const {
1737            clientWidth,
1738            offsetWidth
1739          } = slide[0];
1740          slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1741        }
1742      }
1743
1744      if (currentTransform) {
1745        slide[0].style.transform = currentTransform;
1746      }
1747
1748      if (currentWebKitTransform) {
1749        slide[0].style.webkitTransform = currentWebKitTransform;
1750      }
1751
1752      if (params.roundLengths) slideSize = Math.floor(slideSize);
1753    } else {
1754      slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
1755      if (params.roundLengths) slideSize = Math.floor(slideSize);
1756
1757      if (slides[i]) {
1758        slides[i].style[getDirectionLabel('width')] = `${slideSize}px`;
1759      }
1760    }
1761
1762    if (slides[i]) {
1763      slides[i].swiperSlideSize = slideSize;
1764    }
1765
1766    slidesSizesGrid.push(slideSize);
1767
1768    if (params.centeredSlides) {
1769      slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1770      if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1771      if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1772      if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
1773      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1774      if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1775      slidesGrid.push(slidePosition);
1776    } else {
1777      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1778      if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1779      slidesGrid.push(slidePosition);
1780      slidePosition = slidePosition + slideSize + spaceBetween;
1781    }
1782
1783    swiper.virtualSize += slideSize + spaceBetween;
1784    prevSlideSize = slideSize;
1785    index += 1;
1786  }
1787
1788  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1789
1790  if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1791    $wrapperEl.css({
1792      width: `${swiper.virtualSize + params.spaceBetween}px`
1793    });
1794  }
1795
1796  if (params.setWrapperSize) {
1797    $wrapperEl.css({
1798      [getDirectionLabel('width')]: `${swiper.virtualSize + params.spaceBetween}px`
1799    });
1800  }
1801
1802  if (gridEnabled) {
1803    swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);
1804  } // Remove last grid elements depending on width
1805
1806
1807  if (!params.centeredSlides) {
1808    const newSlidesGrid = [];
1809
1810    for (let i = 0; i < snapGrid.length; i += 1) {
1811      let slidesGridItem = snapGrid[i];
1812      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1813
1814      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1815        newSlidesGrid.push(slidesGridItem);
1816      }
1817    }
1818
1819    snapGrid = newSlidesGrid;
1820
1821    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1822      snapGrid.push(swiper.virtualSize - swiperSize);
1823    }
1824  }
1825
1826  if (snapGrid.length === 0) snapGrid = [0];
1827
1828  if (params.spaceBetween !== 0) {
1829    const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');
1830    slides.filter((_, slideIndex) => {
1831      if (!params.cssMode) return true;
1832
1833      if (slideIndex === slides.length - 1) {
1834        return false;
1835      }
1836
1837      return true;
1838    }).css({
1839      [key]: `${spaceBetween}px`
1840    });
1841  }
1842
1843  if (params.centeredSlides && params.centeredSlidesBounds) {
1844    let allSlidesSize = 0;
1845    slidesSizesGrid.forEach(slideSizeValue => {
1846      allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1847    });
1848    allSlidesSize -= params.spaceBetween;
1849    const maxSnap = allSlidesSize - swiperSize;
1850    snapGrid = snapGrid.map(snap => {
1851      if (snap < 0) return -offsetBefore;
1852      if (snap > maxSnap) return maxSnap + offsetAfter;
1853      return snap;
1854    });
1855  }
1856
1857  if (params.centerInsufficientSlides) {
1858    let allSlidesSize = 0;
1859    slidesSizesGrid.forEach(slideSizeValue => {
1860      allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1861    });
1862    allSlidesSize -= params.spaceBetween;
1863
1864    if (allSlidesSize < swiperSize) {
1865      const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1866      snapGrid.forEach((snap, snapIndex) => {
1867        snapGrid[snapIndex] = snap - allSlidesOffset;
1868      });
1869      slidesGrid.forEach((snap, snapIndex) => {
1870        slidesGrid[snapIndex] = snap + allSlidesOffset;
1871      });
1872    }
1873  }
1874
1875  Object.assign(swiper, {
1876    slides,
1877    snapGrid,
1878    slidesGrid,
1879    slidesSizesGrid
1880  });
1881
1882  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1883    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
1884    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1885    const addToSnapGrid = -swiper.snapGrid[0];
1886    const addToSlidesGrid = -swiper.slidesGrid[0];
1887    swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1888    swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1889  }
1890
1891  if (slidesLength !== previousSlidesLength) {
1892    swiper.emit('slidesLengthChange');
1893  }
1894
1895  if (snapGrid.length !== previousSnapGridLength) {
1896    if (swiper.params.watchOverflow) swiper.checkOverflow();
1897    swiper.emit('snapGridLengthChange');
1898  }
1899
1900  if (slidesGrid.length !== previousSlidesGridLength) {
1901    swiper.emit('slidesGridLengthChange');
1902  }
1903
1904  if (params.watchSlidesProgress) {
1905    swiper.updateSlidesOffset();
1906  }

1907
1908  if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1909    const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1910    const hasClassBackfaceClassAdded = swiper.$el.hasClass(backFaceHiddenClass);
1911
1912    if (slidesLength <= params.maxBackfaceHiddenSlides) {
1913      if (!hasClassBackfaceClassAdded) swiper.$el.addClass(backFaceHiddenClass);
1914    } else if (hasClassBackfaceClassAdded) {
1915      swiper.$el.removeClass(backFaceHiddenClass);
1916    }
1917  }
1918}
1919
1920function updateAutoHeight(speed) {
1921  const swiper = this;
1922  const activeSlides = [];
1923  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1924  let newHeight = 0;
1925  let i;
1926
1927  if (typeof speed === 'number') {
1928    swiper.setTransition(speed);
1929  } else if (speed === true) {
1930    swiper.setTransition(swiper.params.speed);
1931  }
1932
1933  const getSlideByIndex = index => {
1934    if (isVirtual) {
1935      return swiper.slides.filter(el => parseInt(el.getAttribute('data-swiper-slide-index'), 10) === index)[0];
1936    }
1937
1938    return swiper.slides.eq(index)[0];
1939  }; // Find slides currently in view
1940
1941
1942  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1943    if (swiper.params.centeredSlides) {
1944      (swiper.visibleSlides || $([])).each(slide => {
1945        activeSlides.push(slide);
1946      });
1947    } else {
1948      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1949        const index = swiper.activeIndex + i;
1950        if (index > swiper.slides.length && !isVirtual) break;
1951        activeSlides.push(getSlideByIndex(index));
1952      }
1953    }
1954  } else {
1955    activeSlides.push(getSlideByIndex(swiper.activeIndex));
1956  } // Find new height from highest slide in view
1957
1958
1959  for (i = 0; i < activeSlides.length; i += 1) {
1960    if (typeof activeSlides[i] !== 'undefined') {
1961      const height = activeSlides[i].offsetHeight;
1962      newHeight = height > newHeight ? height : newHeight;
1963    }
1964  } // Update Height
1965
1966
1967  if (newHeight || newHeight === 0) swiper.$wrapperEl.css('height', `${newHeight}px`);
1968}
1969
1970function updateSlidesOffset() {
1971  const swiper = this;
1972  const slides = swiper.slides;
1973
1974  for (let i = 0; i < slides.length; i += 1) {
1975    slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;
1976  }
1977}
1978
1979function updateSlidesProgress(translate = this && this.translate || 0) {
1980  const swiper = this;
1981  const params = swiper.params;
1982  const {
1983    slides,
1984    rtlTranslate: rtl,
1985    snapGrid
1986  } = swiper;
1987  if (slides.length === 0) return;
1988  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
1989  let offsetCenter = -translate;
1990  if (rtl) offsetCenter = translate; // Visible Slides
1991
1992  slides.removeClass(params.slideVisibleClass);
1993  swiper.visibleSlidesIndexes = [];
1994  swiper.visibleSlides = [];
1995
1996  for (let i = 0; i < slides.length; i += 1) {
1997    const slide = slides[i];
1998    let slideOffset = slide.swiperSlideOffset;
1999
2000    if (params.cssMode && params.centeredSlides) {
2001      slideOffset -= slides[0].swiperSlideOffset;
2002    }
2003
2004    const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2005    const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2006    const slideBefore = -(offsetCenter - slideOffset);
2007    const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
2008    const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
2009
2010    if (isVisible) {
2011      swiper.visibleSlides.push(slide);
2012      swiper.visibleSlidesIndexes.push(i);
2013      slides.eq(i).addClass(params.slideVisibleClass);
2014    }
2015
2016    slide.progress = rtl ? -slideProgress : slideProgress;
2017    slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
2018  }
2019
2020  swiper.visibleSlides = $(swiper.visibleSlides);
2021}
2022
2023function updateProgress(translate) {
2024  const swiper = this;
2025
2026  if (typeof translate === 'undefined') {
2027    const multiplier = swiper.rtlTranslate ? -1 : 1; // eslint-disable-next-line
2028
2029    translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
2030  }
2031
2032  const params = swiper.params;
2033  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2034  let {
2035    progress,
2036    isBeginning,
2037    isEnd
2038  } = swiper;
2039  const wasBeginning = isBeginning;
2040  const wasEnd = isEnd;
2041
2042  if (translatesDiff === 0) {
2043    progress = 0;
2044    isBeginning = true;
2045    isEnd = true;
2046  } else {
2047    progress = (translate - swiper.minTranslate()) / translatesDiff;
2048    isBeginning = progress <= 0;
2049    isEnd = progress >= 1;
2050  }
2051
2052  Object.assign(swiper, {
2053    progress,
2054    isBeginning,
2055    isEnd
2056  });
2057  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
2058
2059  if (isBeginning && !wasBeginning) {
2060    swiper.emit('reachBeginning toEdge');
2061  }
2062
2063  if (isEnd && !wasEnd) {
2064    swiper.emit('reachEnd toEdge');
2065  }
2066
2067  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
2068    swiper.emit('fromEdge');
2069  }
2070
2071  swiper.emit('progress', progress);
2072}
2073
2074function updateSlidesClasses() {
2075  const swiper = this;
2076  const {
2077    slides,
2078    params,
2079    $wrapperEl,
2080    activeIndex,
2081    realIndex
2082  } = swiper;
2083  const isVirtual = swiper.virtual && params.virtual.enabled;
2084  slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);
2085  let activeSlide;
2086
2087  if (isVirtual) {
2088    activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index="${activeIndex}"]`);
2089  } else {
2090    activeSlide = slides.eq(activeIndex);
2091  } // Active classes
2092
2093
2094  activeSlide.addClass(params.slideActiveClass);
2095
2096  if (params.loop) {
2097    // Duplicate to all looped slides
2098    if (activeSlide.hasClass(params.slideDuplicateClass)) {
2099      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
2100    } else {
2101      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
2102    }
2103  } // Next Slide
2104
2105
2106  let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);
2107
2108  if (params.loop && nextSlide.length === 0) {
2109    nextSlide = slides.eq(0);
2110    nextSlide.addClass(params.slideNextClass);
2111  } // Prev Slide
2112
2113
2114  let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);
2115
2116  if (params.loop && prevSlide.length === 0) {
2117    prevSlide = slides.eq(-1);
2118    prevSlide.addClass(params.slidePrevClass);
2119  }
2120
2121  if (params.loop) {
2122    // Duplicate to all looped slides
2123    if (nextSlide.hasClass(params.slideDuplicateClass)) {
2124      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicateNextClass);
2125    } else {
2126      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicateNextClass);
2127    }
2128
2129    if (prevSlide.hasClass(params.slideDuplicateClass)) {
2130      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicatePrevClass);
2131    } else {
2132      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicatePrevClass);
2133    }
2134  }
2135
2136  swiper.emitSlidesClasses();
2137}
2138
2139function updateActiveIndex(newActiveIndex) {
2140  const swiper = this;
2141  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2142  const {
2143    slidesGrid,
2144    snapGrid,
2145    params,
2146    activeIndex: previousIndex,
2147    realIndex: previousRealIndex,
2148    snapIndex: previousSnapIndex
2149  } = swiper;
2150  let activeIndex = newActiveIndex;
2151  let snapIndex;
2152
2153  if (typeof activeIndex === 'undefined') {
2154    for (let i = 0; i < slidesGrid.length; i += 1) {
2155      if (typeof slidesGrid[i + 1] !== 'undefined') {
2156        if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
2157          activeIndex = i;
2158        } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
2159          activeIndex = i + 1;
2160        }
2161      } else if (translate >= slidesGrid[i]) {
2162        activeIndex = i;
2163      }
2164    } // Normalize slideIndex
2165
2166
2167    if (params.normalizeSlideIndex) {
2168      if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
2169    }
2170  }
2171
2172  if (snapGrid.indexOf(translate) >= 0) {
2173    snapIndex = snapGrid.indexOf(translate);
2174  } else {
2175    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
2176    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
2177  }
2178
2179  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2180
2181  if (activeIndex === previousIndex) {
2182    if (snapIndex !== previousSnapIndex) {
2183      swiper.snapIndex = snapIndex;
2184      swiper.emit('snapIndexChange');
2185    }
2186
2187    return;
2188  } // Get real index
2189
2190
2191  const realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);
2192  Object.assign(swiper, {
2193    snapIndex,
2194    realIndex,
2195    previousIndex,
2196    activeIndex
2197  });
2198  swiper.emit('activeIndexChange');
2199  swiper.emit('snapIndexChange');
2200
2201  if (previousRealIndex !== realIndex) {
2202    swiper.emit('realIndexChange');
2203  }
2204
2205  if (swiper.initialized || swiper.params.runCallbacksOnInit) {
2206    swiper.emit('slideChange');
2207  }
2208}
2209
2210function updateClickedSlide(e) {
2211  const swiper = this;
2212  const params = swiper.params;
2213  const slide = $(e).closest(`.${params.slideClass}`)[0];
2214  let slideFound = false;
2215  let slideIndex;
2216
2217  if (slide) {
2218    for (let i = 0; i < swiper.slides.length; i += 1) {
2219      if (swiper.slides[i] === slide) {
2220        slideFound = true;
2221        slideIndex = i;
2222        break;
2223      }
2224    }
2225  }
2226
2227  if (slide && slideFound) {
2228    swiper.clickedSlide = slide;
2229
2230    if (swiper.virtual && swiper.params.virtual.enabled) {
2231      swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);
2232    } else {
2233      swiper.clickedIndex = slideIndex;
2234    }
2235  } else {
2236    swiper.clickedSlide = undefined;
2237    swiper.clickedIndex = undefined;
2238    return;
2239  }
2240
2241  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
2242    swiper.slideToClickedSlide();
2243  }
2244}
2245
2246var update = {
2247  updateSize,
2248  updateSlides,
2249  updateAutoHeight,
2250  updateSlidesOffset,
2251  updateSlidesProgress,
2252  updateProgress,
2253  updateSlidesClasses,
2254  updateActiveIndex,
2255  updateClickedSlide
2256};
2257
2258function getSwiperTranslate(axis = this.isHorizontal() ? 'x' : 'y') {
2259  const swiper = this;
2260  const {
2261    params,
2262    rtlTranslate: rtl,
2263    translate,
2264    $wrapperEl
2265  } = swiper;
2266
2267  if (params.virtualTranslate) {
2268    return rtl ? -translate : translate;
2269  }
2270
2271  if (params.cssMode) {
2272    return translate;
2273  }
2274
2275  let currentTranslate = getTranslate($wrapperEl[0], axis);
2276  if (rtl) currentTranslate = -currentTranslate;
2277  return currentTranslate || 0;
2278}
2279
2280function setTranslate(translate, byController) {
2281  const swiper = this;
2282  const {
2283    rtlTranslate: rtl,
2284    params,
2285    $wrapperEl,
2286    wrapperEl,
2287    progress
2288  } = swiper;
2289  let x = 0;
2290  let y = 0;
2291  const z = 0;
2292
2293  if (swiper.isHorizontal()) {
2294    x = rtl ? -translate : translate;
2295  } else {
2296    y = translate;
2297  }
2298
2299  if (params.roundLengths) {
2300    x = Math.floor(x);
2301    y = Math.floor(y);
2302  }
2303
2304  if (params.cssMode) {
2305    wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
2306  } else if (!params.virtualTranslate) {
2307    $wrapperEl.transform(`translate3d(${x}px, ${y}px, ${z}px)`);
2308  }
2309
2310  swiper.previousTranslate = swiper.translate;
2311  swiper.translate = swiper.isHorizontal() ? x : y; // Check if we need to update progress
2312
2313  let newProgress;
2314  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2315
2316  if (translatesDiff === 0) {
2317    newProgress = 0;
2318  } else {
2319    newProgress = (translate - swiper.minTranslate()) / translatesDiff;
2320  }
2321
2322  if (newProgress !== progress) {
2323    swiper.updateProgress(translate);
2324  }
2325
2326  swiper.emit('setTranslate', swiper.translate, byController);
2327}
2328
2329function minTranslate() {
2330  return -this.snapGrid[0];
2331}
2332
2333function maxTranslate() {
2334  return -this.snapGrid[this.snapGrid.length - 1];
2335}
2336
2337function translateTo(translate = 0, speed = this.params.speed, runCallbacks = true, translateBounds = true, internal) {
2338  const swiper = this;
2339  const {
2340    params,
2341    wrapperEl
2342  } = swiper;
2343
2344  if (swiper.animating && params.preventInteractionOnTransition) {
2345    return false;
2346  }
2347
2348  const minTranslate = swiper.minTranslate();
2349  const maxTranslate = swiper.maxTranslate();
2350  let newTranslate;
2351  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate; // Update progress
2352
2353  swiper.updateProgress(newTranslate);
2354
2355  if (params.cssMode) {
2356    const isH = swiper.isHorizontal();
2357
2358    if (speed === 0) {
2359      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
2360    } else {
2361      if (!swiper.support.smoothScroll) {
2362        animateCSSModeScroll({
2363          swiper,
2364          targetPosition: -newTranslate,
2365          side: isH ? 'left' : 'top'
2366        });
2367        return true;
2368      }
2369
2370      wrapperEl.scrollTo({
2371        [isH ? 'left' : 'top']: -newTranslate,
2372        behavior: 'smooth'
2373      });
2374    }
2375
2376    return true;
2377  }
2378
2379  if (speed === 0) {
2380    swiper.setTransition(0);
2381    swiper.setTranslate(newTranslate);
2382
2383    if (runCallbacks) {
2384      swiper.emit('beforeTransitionStart', speed, internal);
2385      swiper.emit('transitionEnd');
2386    }
2387  } else {
2388    swiper.setTransition(speed);
2389    swiper.setTranslate(newTranslate);
2390
2391    if (runCallbacks) {
2392      swiper.emit('beforeTransitionStart', speed, internal);
2393      swiper.emit('transitionStart');
2394    }
2395
2396    if (!swiper.animating) {
2397      swiper.animating = true;
2398
2399      if (!swiper.onTranslateToWrapperTransitionEnd) {
2400        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
2401          if (!swiper || swiper.destroyed) return;
2402          if (e.target !== this) return;
2403          swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2404          swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2405          swiper.onTranslateToWrapperTransitionEnd = null;
2406          delete swiper.onTranslateToWrapperTransitionEnd;
2407
2408          if (runCallbacks) {
2409            swiper.emit('transitionEnd');
2410          }
2411        };
2412      }
2413
2414      swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2415      swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2416    }
2417  }
2418
2419  return true;
2420}
2421
2422var translate = {
2423  getTranslate: getSwiperTranslate,
2424  setTranslate,
2425  minTranslate,
2426  maxTranslate,
2427  translateTo
2428};
2429
2430function setTransition(duration, byController) {
2431  const swiper = this;
2432
2433  if (!swiper.params.cssMode) {
2434    swiper.$wrapperEl.transition(duration);
2435  }
2436
2437  swiper.emit('setTransition', duration, byController);
2438}
2439
2440function transitionEmit({
2441  swiper,
2442  runCallbacks,
2443  direction,
2444  step
2445}) {
2446  const {
2447    activeIndex,
2448    previousIndex
2449  } = swiper;
2450  let dir = direction;
2451
2452  if (!dir) {
2453    if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
2454  }
2455
2456  swiper.emit(`transition${step}`);
2457
2458  if (runCallbacks && activeIndex !== previousIndex) {
2459    if (dir === 'reset') {
2460      swiper.emit(`slideResetTransition${step}`);
2461      return;
2462    }
2463
2464    swiper.emit(`slideChangeTransition${step}`);
2465
2466    if (dir === 'next') {
2467      swiper.emit(`slideNextTransition${step}`);
2468    } else {
2469      swiper.emit(`slidePrevTransition${step}`);
2470    }
2471  }
2472}
2473
2474function transitionStart(runCallbacks = true, direction) {
2475  const swiper = this;
2476  const {
2477    params
2478  } = swiper;
2479  if (params.cssMode) return;
2480
2481  if (params.autoHeight) {
2482    swiper.updateAutoHeight();
2483  }
2484
2485  transitionEmit({
2486    swiper,
2487    runCallbacks,
2488    direction,
2489    step: 'Start'
2490  });
2491}
2492
2493function transitionEnd(runCallbacks = true, direction) {
2494  const swiper = this;
2495  const {
2496    params
2497  } = swiper;
2498  swiper.animating = false;
2499  if (params.cssMode) return;
2500  swiper.setTransition(0);
2501  transitionEmit({
2502    swiper,
2503    runCallbacks,
2504    direction,
2505    step: 'End'
2506  });
2507}
2508
2509var transition = {
2510  setTransition,
2511  transitionStart,
2512  transitionEnd
2513};
2514
2515function slideTo(index = 0, speed = this.params.speed, runCallbacks = true, internal, initial) {
2516  if (typeof index !== 'number' && typeof index !== 'string') {
2517    throw new Error(`The 'index' argument cannot have type other than 'number' or 'string'. [${typeof index}] given.`);
2518  }
2519
2520  if (typeof index === 'string') {
2521    /**
2522     * The `index` argument converted from `string` to `number`.
2523     * @type {number}
2524     */
2525    const indexAsNumber = parseInt(index, 10);
2526    /**
2527     * Determines whether the `index` argument is a valid `number`
2528     * after being converted from the `string` type.
2529     * @type {boolean}
2530     */
2531
2532    const isValidNumber = isFinite(indexAsNumber);
2533
2534    if (!isValidNumber) {
2535      throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);
2536    } // Knowing that the converted `index` is a valid number,
2537    // we can update the original argument's value.
2538
2539
2540    index = indexAsNumber;
2541  }
2542
2543  const swiper = this;
2544  let slideIndex = index;
2545  if (slideIndex < 0) slideIndex = 0;
2546  const {
2547    params,
2548    snapGrid,
2549    slidesGrid,
2550    previousIndex,
2551    activeIndex,
2552    rtlTranslate: rtl,
2553    wrapperEl,
2554    enabled
2555  } = swiper;
2556
2557  if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
2558    return false;
2559  }
2560
2561  const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
2562  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
2563  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2564  const translate = -snapGrid[snapIndex]; // Normalize slideIndex
2565
2566  if (params.normalizeSlideIndex) {
2567    for (let i = 0; i < slidesGrid.length; i += 1) {
2568      const normalizedTranslate = -Math.floor(translate * 100);
2569      const normalizedGrid = Math.floor(slidesGrid[i] * 100);
2570      const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
2571
2572      if (typeof slidesGrid[i + 1] !== 'undefined') {
2573        if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
2574          slideIndex = i;
2575        } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
2576          slideIndex = i + 1;
2577        }
2578      } else if (normalizedTranslate >= normalizedGrid) {
2579        slideIndex = i;
2580      }
2581    }
2582  } // Directions locks
2583
2584
2585  if (swiper.initialized && slideIndex !== activeIndex) {
2586    if (!swiper.allowSlideNext && translate < swiper.translate && translate < swiper.minTranslate()) {
2587      return false;
2588    }
2589
2590    if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
2591      if ((activeIndex || 0) !== slideIndex) return false;
2592    }
2593  }
2594
2595  if (slideIndex !== (previousIndex || 0) && runCallbacks) {
2596    swiper.emit('beforeSlideChangeStart');
2597  } // Update progress
2598
2599
2600  swiper.updateProgress(translate);
2601  let direction;
2602  if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset'; // Update Index
2603
2604  if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {
2605    swiper.updateActiveIndex(slideIndex); // Update Height
2606
2607    if (params.autoHeight) {
2608      swiper.updateAutoHeight();
2609    }
2610
2611    swiper.updateSlidesClasses();
2612
2613    if (params.effect !== 'slide') {
2614      swiper.setTranslate(translate);
2615    }
2616
2617    if (direction !== 'reset') {
2618      swiper.transitionStart(runCallbacks, direction);
2619      swiper.transitionEnd(runCallbacks, direction);
2620    }
2621
2622    return false;
2623  }
2624
2625  if (params.cssMode) {
2626    const isH = swiper.isHorizontal();
2627    const t = rtl ? translate : -translate;
2628
2629    if (speed === 0) {
2630      const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2631
2632      if (isVirtual) {
2633        swiper.wrapperEl.style.scrollSnapType = 'none';
2634        swiper._immediateVirtual = true;
2635      }
2636
2637      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
2638
2639      if (isVirtual) {
2640        requestAnimationFrame(() => {
2641          swiper.wrapperEl.style.scrollSnapType = '';
2642          swiper._swiperImmediateVirtual = false;
2643        });
2644      }
2645    } else {
2646      if (!swiper.support.smoothScroll) {
2647        animateCSSModeScroll({
2648          swiper,
2649          targetPosition: t,
2650          side: isH ? 'left' : 'top'
2651        });
2652        return true;
2653      }
2654
2655      wrapperEl.scrollTo({
2656        [isH ? 'left' : 'top']: t,
2657        behavior: 'smooth'
2658      });
2659    }
2660
2661    return true;
2662  }
2663
2664  swiper.setTransition(speed);
2665  swiper.setTranslate(translate);
2666  swiper.updateActiveIndex(slideIndex);
2667  swiper.updateSlidesClasses();
2668  swiper.emit('beforeTransitionStart', speed, internal);
2669  swiper.transitionStart(runCallbacks, direction);
2670
2671  if (speed === 0) {
2672    swiper.transitionEnd(runCallbacks, direction);
2673  } else if (!swiper.animating) {
2674    swiper.animating = true;
2675
2676    if (!swiper.onSlideToWrapperTransitionEnd) {
2677      swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2678        if (!swiper || swiper.destroyed) return;
2679        if (e.target !== this) return;
2680        swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2681        swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2682        swiper.onSlideToWrapperTransitionEnd = null;
2683        delete swiper.onSlideToWrapperTransitionEnd;
2684        swiper.transitionEnd(runCallbacks, direction);
2685      };
2686    }
2687
2688    swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2689    swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2690  }
2691
2692  return true;
2693}
2694
2695function slideToLoop(index = 0, speed = this.params.speed, runCallbacks = true, internal) {
2696  if (typeof index === 'string') {
2697    /**
2698     * The `index` argument converted from `string` to `number`.
2699     * @type {number}
2700     */
2701    const indexAsNumber = parseInt(index, 10);
2702    /**
2703     * Determines whether the `index` argument is a valid `number`
2704     * after being converted from the `string` type.
2705     * @type {boolean}
2706     */
2707
2708    const isValidNumber = isFinite(indexAsNumber);
2709
2710    if (!isValidNumber) {
2711      throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);
2712    } // Knowing that the converted `index` is a valid number,
2713    // we can update the original argument's value.
2714
2715
2716    index = indexAsNumber;
2717  }
2718
2719  const swiper = this;
2720  let newIndex = index;
2721
2722  if (swiper.params.loop) {
2723    newIndex += swiper.loopedSlides;
2724  }
2725
2726  return swiper.slideTo(newIndex, speed, runCallbacks, internal);
2727}
2728
2729/* eslint no-unused-vars: "off" */
2730function slideNext(speed = this.params.speed, runCallbacks = true, internal) {
2731  const swiper = this;
2732  const {
2733    animating,
2734    enabled,
2735    params
2736  } = swiper;
2737  if (!enabled) return swiper;
2738  let perGroup = params.slidesPerGroup;
2739
2740  if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2741    perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
2742  }
2743
2744  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2745
2746  if (params.loop) {
2747    if (animating && params.loopPreventsSlide) return false;
2748    swiper.loopFix(); // eslint-disable-next-line
2749
2750    swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2751  }
2752
2753  if (params.rewind && swiper.isEnd) {
2754    return swiper.slideTo(0, speed, runCallbacks, internal);
2755  }
2756
2757  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2758}
2759
2760/* eslint no-unused-vars: "off" */
2761function slidePrev(speed = this.params.speed, runCallbacks = true, internal) {
2762  const swiper = this;
2763  const {
2764    params,
2765    animating,
2766    snapGrid,
2767    slidesGrid,
2768    rtlTranslate,
2769    enabled
2770  } = swiper;
2771  if (!enabled) return swiper;
2772
2773  if (params.loop) {
2774    if (animating && params.loopPreventsSlide) return false;
2775    swiper.loopFix(); // eslint-disable-next-line
2776
2777    swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2778  }
2779
2780  const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2781
2782  function normalize(val) {
2783    if (val < 0) return -Math.floor(Math.abs(val));
2784    return Math.floor(val);
2785  }
2786
2787  const normalizedTranslate = normalize(translate);
2788  const normalizedSnapGrid = snapGrid.map(val => normalize(val));
2789  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2790
2791  if (typeof prevSnap === 'undefined' && params.cssMode) {
2792    let prevSnapIndex;
2793    snapGrid.forEach((snap, snapIndex) => {
2794      if (normalizedTranslate >= snap) {
2795        // prevSnap = snap;
2796        prevSnapIndex = snapIndex;
2797      }
2798    });
2799
2800    if (typeof prevSnapIndex !== 'undefined') {
2801      prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2802    }
2803  }
2804
2805  let prevIndex = 0;
2806
2807  if (typeof prevSnap !== 'undefined') {
2808    prevIndex = slidesGrid.indexOf(prevSnap);
2809    if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2810
2811    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2812      prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2813      prevIndex = Math.max(prevIndex, 0);
2814    }
2815  }
2816
2817  if (params.rewind && swiper.isBeginning) {
2818    const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2819    return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2820  }
2821
2822  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2823}
2824
2825/* eslint no-unused-vars: "off" */
2826function slideReset(speed = this.params.speed, runCallbacks = true, internal) {
2827  const swiper = this;
2828  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2829}
2830
2831/* eslint no-unused-vars: "off" */
2832function slideToClosest(speed = this.params.speed, runCallbacks = true, internal, threshold = 0.5) {
2833  const swiper = this;
2834  let index = swiper.activeIndex;
2835  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2836  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2837  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2838
2839  if (translate >= swiper.snapGrid[snapIndex]) {
2840    // The current translate is on or after the current snap index, so the choice
2841    // is between the current index and the one after it.
2842    const currentSnap = swiper.snapGrid[snapIndex];
2843    const nextSnap = swiper.snapGrid[snapIndex + 1];
2844
2845    if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
2846      index += swiper.params.slidesPerGroup;
2847    }
2848  } else {
2849    // The current translate is before the current snap index, so the choice
2850    // is between the current index and the one before it.
2851    const prevSnap = swiper.snapGrid[snapIndex - 1];
2852    const currentSnap = swiper.snapGrid[snapIndex];
2853
2854    if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
2855      index -= swiper.params.slidesPerGroup;
2856    }
2857  }
2858
2859  index = Math.max(index, 0);
2860  index = Math.min(index, swiper.slidesGrid.length - 1);
2861  return swiper.slideTo(index, speed, runCallbacks, internal);
2862}
2863
2864function slideToClickedSlide() {
2865  const swiper = this;
2866  const {
2867    params,
2868    $wrapperEl
2869  } = swiper;
2870  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2871  let slideToIndex = swiper.clickedIndex;
2872  let realIndex;
2873
2874  if (params.loop) {
2875    if (swiper.animating) return;
2876    realIndex = parseInt($(swiper.clickedSlide).attr('data-swiper-slide-index'), 10);
2877
2878    if (params.centeredSlides) {
2879      if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2880        swiper.loopFix();
2881        slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
2882        nextTick(() => {
2883          swiper.slideTo(slideToIndex);
2884        });
2885      } else {
2886        swiper.slideTo(slideToIndex);
2887      }
2888    } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2889      swiper.loopFix();
2890      slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
2891      nextTick(() => {
2892        swiper.slideTo(slideToIndex);
2893      });
2894    } else {
2895      swiper.slideTo(slideToIndex);
2896    }
2897  } else {
2898    swiper.slideTo(slideToIndex);
2899  }
2900}
2901
2902var slide = {
2903  slideTo,
2904  slideToLoop,
2905  slideNext,
2906  slidePrev,
2907  slideReset,
2908  slideToClosest,
2909  slideToClickedSlide
2910};
2911
2912function loopCreate() {
2913  const swiper = this;
2914  const document = getDocument();
2915  const {
2916    params,
2917    $wrapperEl
2918  } = swiper; // Remove duplicated slides
2919
2920  const $selector = $wrapperEl.children().length > 0 ? $($wrapperEl.children()[0].parentNode) : $wrapperEl;
2921  $selector.children(`.${params.slideClass}.${params.slideDuplicateClass}`).remove();
2922  let slides = $selector.children(`.${params.slideClass}`);
2923
2924  if (params.loopFillGroupWithBlank) {
2925    const blankSlidesNum = params.slidesPerGroup - slides.length % params.slidesPerGroup;
2926
2927    if (blankSlidesNum !== params.slidesPerGroup) {
2928      for (let i = 0; i < blankSlidesNum; i += 1) {
2929        const blankNode = $(document.createElement('div')).addClass(`${params.slideClass} ${params.slideBlankClass}`);
2930        $selector.append(blankNode);
2931      }
2932
2933      slides = $selector.children(`.${params.slideClass}`);
2934    }
2935  }
2936
2937  if (params.slidesPerView === 'auto' && !params.loopedSlides) params.loopedSlides = slides.length;
2938  swiper.loopedSlides = Math.ceil(parseFloat(params.loopedSlides || params.slidesPerView, 10));
2939  swiper.loopedSlides += params.loopAdditionalSlides;
2940
2941  if (swiper.loopedSlides > slides.length && swiper.params.loopedSlidesLimit) {
2942    swiper.loopedSlides = slides.length;
2943  }
2944
2945  const prependSlides = [];
2946  const appendSlides = [];
2947  slides.each((el, index) => {
2948    const slide = $(el);
2949    slide.attr('data-swiper-slide-index', index);
2950  });
2951
2952  for (let i = 0; i < swiper.loopedSlides; i += 1) {
2953    const index = i - Math.floor(i / slides.length) * slides.length;
2954    appendSlides.push(slides.eq(index)[0]);
2955    prependSlides.unshift(slides.eq(slides.length - index - 1)[0]);
2956  }
2957
2958  for (let i = 0; i < appendSlides.length; i += 1) {
2959    $selector.append($(appendSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
2960  }
2961
2962  for (let i = prependSlides.length - 1; i >= 0; i -= 1) {
2963    $selector.prepend($(prependSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
2964  }
2965}
2966
2967function loopFix() {
2968  const swiper = this;
2969  swiper.emit('beforeLoopFix');
2970  const {
2971    activeIndex,
2972    slides,
2973    loopedSlides,
2974    allowSlidePrev,
2975    allowSlideNext,
2976    snapGrid,
2977    rtlTranslate: rtl
2978  } = swiper;
2979  let newIndex;
2980  swiper.allowSlidePrev = true;
2981  swiper.allowSlideNext = true;
2982  const snapTranslate = -snapGrid[activeIndex];
2983  const diff = snapTranslate - swiper.getTranslate(); // Fix For Negative Oversliding
2984
2985  if (activeIndex < loopedSlides) {
2986    newIndex = slides.length - loopedSlides * 3 + activeIndex;
2987    newIndex += loopedSlides;
2988    const slideChanged = swiper.slideTo(newIndex, 0, false, true);
2989
2990    if (slideChanged && diff !== 0) {
2991      swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
2992    }
2993  } else if (activeIndex >= slides.length - loopedSlides) {
2994    // Fix For Positive Oversliding
2995    newIndex = -slides.length + activeIndex + loopedSlides;
2996    newIndex += loopedSlides;
2997    const slideChanged = swiper.slideTo(newIndex, 0, false, true);
2998
2999    if (slideChanged && diff !== 0) {
3000      swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
3001    }
3002  }
3003
3004  swiper.allowSlidePrev = allowSlidePrev;
3005  swiper.allowSlideNext = allowSlideNext;
3006  swiper.emit('loopFix');
3007}
3008
3009function loopDestroy() {
3010  const swiper = this;
3011  const {
3012    $wrapperEl,
3013    params,
3014    slides
3015  } = swiper;
3016  $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass},.${params.slideClass}.${params.slideBlankClass}`).remove();
3017  slides.removeAttr('data-swiper-slide-index');
3018}
3019
3020var loop = {
3021  loopCreate,
3022  loopFix,
3023  loopDestroy
3024};
3025
3026function setGrabCursor(moving) {
3027  const swiper = this;
3028  if (swiper.support.touch || !swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
3029  const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
3030  el.style.cursor = 'move';
3031  el.style.cursor = moving ? 'grabbing' : 'grab';
3032}
3033
3034function unsetGrabCursor() {
3035  const swiper = this;
3036
3037  if (swiper.support.touch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
3038    return;
3039  }
3040
3041  swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
3042}
3043
3044var grabCursor = {
3045  setGrabCursor,
3046  unsetGrabCursor
3047};
3048
3049function closestElement(selector, base = this) {
3050  function __closestFrom(el) {
3051    if (!el || el === getDocument() || el === getWindow()) return null;
3052    if (el.assignedSlot) el = el.assignedSlot;
3053    const found = el.closest(selector);
3054
3055    if (!found && !el.getRootNode) {
3056      return null;
3057    }
3058
3059    return found || __closestFrom(el.getRootNode().host);
3060  }
3061
3062  return __closestFrom(base);
3063}
3064
3065function onTouchStart(event) {
3066  const swiper = this;
3067  const document = getDocument();
3068  const window = getWindow();
3069  const data = swiper.touchEventsData;
3070  const {
3071    params,
3072    touches,
3073    enabled
3074  } = swiper;
3075  if (!enabled) return;
3076
3077  if (swiper.animating && params.preventInteractionOnTransition) {
3078    return;
3079  }
3080
3081  if (!swiper.animating && params.cssMode && params.loop) {
3082    swiper.loopFix();
3083  }
3084
3085  let e = event;
3086  if (e.originalEvent) e = e.originalEvent;
3087  let $targetEl = $(e.target);
3088
3089  if (params.touchEventsTarget === 'wrapper') {
3090    if (!$targetEl.closest(swiper.wrapperEl).length) return;
3091  }
3092
3093  data.isTouchEvent = e.type === 'touchstart';
3094  if (!data.isTouchEvent && 'which' in e && e.which === 3) return;
3095  if (!data.isTouchEvent && 'button' in e && e.button > 0) return;
3096  if (data.isTouched && data.isMoved) return; // change target el for shadow root component
3097
3098  const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== ''; // eslint-disable-next-line
3099
3100  const eventPath = event.composedPath ? event.composedPath() : event.path;
3101
3102  if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
3103    $targetEl = $(eventPath[0]);
3104  }
3105
3106  const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
3107  const isTargetShadow = !!(e.target && e.target.shadowRoot); // use closestElement for shadow root element to get the actual closest for nested shadow root element
3108
3109  if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, $targetEl[0]) : $targetEl.closest(noSwipingSelector)[0])) {
3110    swiper.allowClick = true;
3111    return;
3112  }
3113
3114  if (params.swipeHandler) {
3115    if (!$targetEl.closest(params.swipeHandler)[0]) return;
3116  }
3117
3118  touches.currentX = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
3119  touches.currentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
3120  const startX = touches.currentX;
3121  const startY = touches.currentY; // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
3122
3123  const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
3124  const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
3125
3126  if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
3127    if (edgeSwipeDetection === 'prevent') {
3128      event.preventDefault();
3129    } else {
3130      return;
3131    }
3132  }
3133
3134  Object.assign(data, {
3135    isTouched: true,
3136    isMoved: false,
3137    allowTouchCallbacks: true,
3138    isScrolling: undefined,
3139    startMoving: undefined
3140  });
3141  touches.startX = startX;
3142  touches.startY = startY;
3143  data.touchStartTime = now();
3144  swiper.allowClick = true;
3145  swiper.updateSize();
3146  swiper.swipeDirection = undefined;
3147  if (params.threshold > 0) data.allowThresholdMove = false;
3148
3149  if (e.type !== 'touchstart') {
3150    let preventDefault = true;
3151
3152    if ($targetEl.is(data.focusableElements)) {
3153      preventDefault = false;
3154
3155      if ($targetEl[0].nodeName === 'SELECT') {
3156        data.isTouched = false;
3157      }
3158    }
3159
3160    if (document.activeElement && $(document.activeElement).is(data.focusableElements) && document.activeElement !== $targetEl[0]) {
3161      document.activeElement.blur();
3162    }
3163
3164    const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
3165
3166    if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !$targetEl[0].isContentEditable) {
3167      e.preventDefault();
3168    }
3169  }
3170
3171  if (swiper.params.freeMode && swiper.params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
3172    swiper.freeMode.onTouchStart();
3173  }
3174
3175  swiper.emit('touchStart', e);
3176}
3177
3178function onTouchMove(event) {
3179  const document = getDocument();
3180  const swiper = this;
3181  const data = swiper.touchEventsData;
3182  const {
3183    params,
3184    touches,
3185    rtlTranslate: rtl,
3186    enabled
3187  } = swiper;
3188  if (!enabled) return;
3189  let e = event;
3190  if (e.originalEvent) e = e.originalEvent;
3191
3192  if (!data.isTouched) {
3193    if (data.startMoving && data.isScrolling) {
3194      swiper.emit('touchMoveOpposite', e);
3195    }
3196
3197    return;
3198  }
3199
3200  if (data.isTouchEvent && e.type !== 'touchmove') return;
3201  const targetTouch = e.type === 'touchmove' && e.targetTouches && (e.targetTouches[0] || e.changedTouches[0]);
3202  const pageX = e.type === 'touchmove' ? targetTouch.pageX : e.pageX;
3203  const pageY = e.type === 'touchmove' ? targetTouch.pageY : e.pageY;
3204
3205  if (e.preventedByNestedSwiper) {
3206    touches.startX = pageX;
3207    touches.startY = pageY;
3208    return;
3209  }
3210
3211  if (!swiper.allowTouchMove) {
3212    if (!$(e.target).is(data.focusableElements)) {
3213      swiper.allowClick = false;
3214    }
3215
3216    if (data.isTouched) {
3217      Object.assign(touches, {
3218        startX: pageX,
3219        startY: pageY,
3220        currentX: pageX,
3221        currentY: pageY
3222      });
3223      data.touchStartTime = now();
3224    }
3225
3226    return;
3227  }
3228
3229  if (data.isTouchEvent && params.touchReleaseOnEdges && !params.loop) {
3230    if (swiper.isVertical()) {
3231      // Vertical
3232      if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {
3233        data.isTouched = false;
3234        data.isMoved = false;
3235        return;
3236      }
3237    } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) {
3238      return;
3239    }
3240  }
3241
3242  if (data.isTouchEvent && document.activeElement) {
3243    if (e.target === document.activeElement && $(e.target).is(data.focusableElements)) {
3244      data.isMoved = true;
3245      swiper.allowClick = false;
3246      return;
3247    }
3248  }
3249
3250  if (data.allowTouchCallbacks) {
3251    swiper.emit('touchMove', e);
3252  }
3253
3254  if (e.targetTouches && e.targetTouches.length > 1) return;
3255  touches.currentX = pageX;
3256  touches.currentY = pageY;
3257  const diffX = touches.currentX - touches.startX;
3258  const diffY = touches.currentY - touches.startY;
3259  if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;
3260
3261  if (typeof data.isScrolling === 'undefined') {
3262    let touchAngle;
3263
3264    if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {
3265      data.isScrolling = false;
3266    } else {
3267      // eslint-disable-next-line
3268      if (diffX * diffX + diffY * diffY >= 25) {
3269        touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
3270        data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
3271      }
3272    }
3273  }
3274
3275  if (data.isScrolling) {
3276    swiper.emit('touchMoveOpposite', e);
3277  }
3278
3279  if (typeof data.startMoving === 'undefined') {
3280    if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
3281      data.startMoving = true;
3282    }
3283  }
3284
3285  if (data.isScrolling) {
3286    data.isTouched = false;
3287    return;
3288  }
3289
3290  if (!data.startMoving) {
3291    return;
3292  }
3293
3294  swiper.allowClick = false;
3295
3296  if (!params.cssMode && e.cancelable) {
3297    e.preventDefault();
3298  }
3299
3300  if (params.touchMoveStopPropagation && !params.nested) {
3301    e.stopPropagation();
3302  }
3303
3304  if (!data.isMoved) {
3305    if (params.loop && !params.cssMode) {
3306      swiper.loopFix();
3307    }
3308
3309    data.startTranslate = swiper.getTranslate();
3310    swiper.setTransition(0);
3311
3312    if (swiper.animating) {
3313      swiper.$wrapperEl.trigger('webkitTransitionEnd transitionend');
3314    }
3315
3316    data.allowMomentumBounce = false; // Grab Cursor
3317
3318    if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
3319      swiper.setGrabCursor(true);
3320    }
3321
3322    swiper.emit('sliderFirstMove', e);
3323  }
3324
3325  swiper.emit('sliderMove', e);
3326  data.isMoved = true;
3327  let diff = swiper.isHorizontal() ? diffX : diffY;
3328  touches.diff = diff;
3329  diff *= params.touchRatio;
3330  if (rtl) diff = -diff;
3331  swiper.swipeDirection = diff > 0 ? 'prev' : 'next';
3332  data.currentTranslate = diff + data.startTranslate;
3333  let disableParentSwiper = true;
3334  let resistanceRatio = params.resistanceRatio;
3335
3336  if (params.touchReleaseOnEdges) {
3337    resistanceRatio = 0;
3338  }
3339
3340  if (diff > 0 && data.currentTranslate > swiper.minTranslate()) {
3341    disableParentSwiper = false;
3342    if (params.resistance) data.currentTranslate = swiper.minTranslate() - 1 + (-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio;
3343  } else if (diff < 0 && data.currentTranslate < swiper.maxTranslate()) {
3344    disableParentSwiper = false;
3345    if (params.resistance) data.currentTranslate = swiper.maxTranslate() + 1 - (swiper.maxTranslate() - data.startTranslate - diff) ** resistanceRatio;
3346  }
3347
3348  if (disableParentSwiper) {
3349    e.preventedByNestedSwiper = true;
3350  } // Directions locks
3351
3352
3353  if (!swiper.allowSlideNext && swiper.swipeDirection === 'next' && data.currentTranslate < data.startTranslate) {
3354    data.currentTranslate = data.startTranslate;
3355  }
3356
3357  if (!swiper.allowSlidePrev && swiper.swipeDirection === 'prev' && data.currentTranslate > data.startTranslate) {
3358    data.currentTranslate = data.startTranslate;
3359  }
3360
3361  if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {
3362    data.currentTranslate = data.startTranslate;
3363  } // Threshold
3364
3365
3366  if (params.threshold > 0) {
3367    if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
3368      if (!data.allowThresholdMove) {
3369        data.allowThresholdMove = true;
3370        touches.startX = touches.currentX;
3371        touches.startY = touches.currentY;
3372        data.currentTranslate = data.startTranslate;
3373        touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;
3374        return;
3375      }
3376    } else {
3377      data.currentTranslate = data.startTranslate;
3378      return;
3379    }
3380  }
3381
3382  if (!params.followFinger || params.cssMode) return; // Update active index in free mode
3383
3384  if (params.freeMode && params.freeMode.enabled && swiper.freeMode || params.watchSlidesProgress) {
3385    swiper.updateActiveIndex();
3386    swiper.updateSlidesClasses();
3387  }
3388
3389  if (swiper.params.freeMode && params.freeMode.enabled && swiper.freeMode) {
3390    swiper.freeMode.onTouchMove();
3391  } // Update progress
3392
3393
3394  swiper.updateProgress(data.currentTranslate); // Update translate
3395
3396  swiper.setTranslate(data.currentTranslate);
3397}
3398
3399function onTouchEnd(event) {
3400  const swiper = this;
3401  const data = swiper.touchEventsData;
3402  const {
3403    params,
3404    touches,
3405    rtlTranslate: rtl,
3406    slidesGrid,
3407    enabled
3408  } = swiper;
3409  if (!enabled) return;
3410  let e = event;
3411  if (e.originalEvent) e = e.originalEvent;
3412
3413  if (data.allowTouchCallbacks) {
3414    swiper.emit('touchEnd', e);
3415  }
3416
3417  data.allowTouchCallbacks = false;
3418
3419  if (!data.isTouched) {
3420    if (data.isMoved && params.grabCursor) {
3421      swiper.setGrabCursor(false);
3422    }
3423
3424    data.isMoved = false;
3425    data.startMoving = false;
3426    return;
3427  } // Return Grab Cursor
3428
3429
3430  if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
3431    swiper.setGrabCursor(false);
3432  } // Time diff
3433
3434
3435  const touchEndTime = now();
3436  const timeDiff = touchEndTime - data.touchStartTime; // Tap, doubleTap, Click
3437
3438  if (swiper.allowClick) {
3439    const pathTree = e.path || e.composedPath && e.composedPath();
3440    swiper.updateClickedSlide(pathTree && pathTree[0] || e.target);
3441    swiper.emit('tap click', e);
3442
3443    if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {
3444      swiper.emit('doubleTap doubleClick', e);
3445    }
3446  }
3447
3448  data.lastClickTime = now();
3449  nextTick(() => {
3450    if (!swiper.destroyed) swiper.allowClick = true;
3451  });
3452
3453  if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 || data.currentTranslate === data.startTranslate) {
3454    data.isTouched = false;
3455    data.isMoved = false;
3456    data.startMoving = false;
3457    return;
3458  }
3459
3460  data.isTouched = false;
3461  data.isMoved = false;
3462  data.startMoving = false;
3463  let currentPos;
3464
3465  if (params.followFinger) {
3466    currentPos = rtl ? swiper.translate : -swiper.translate;
3467  } else {
3468    currentPos = -data.currentTranslate;
3469  }
3470
3471  if (params.cssMode) {
3472    return;
3473  }
3474
3475  if (swiper.params.freeMode && params.freeMode.enabled) {
3476    swiper.freeMode.onTouchEnd({
3477      currentPos
3478    });
3479    return;
3480  } // Find current slide
3481
3482
3483  let stopIndex = 0;
3484  let groupSize = swiper.slidesSizesGrid[0];
3485
3486  for (let i = 0; i < slidesGrid.length; i += i < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup) {
3487    const increment = i < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
3488
3489    if (typeof slidesGrid[i + increment] !== 'undefined') {
3490      if (currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + increment]) {
3491        stopIndex = i;
3492        groupSize = slidesGrid[i + increment] - slidesGrid[i];
3493      }
3494    } else if (currentPos >= slidesGrid[i]) {
3495      stopIndex = i;
3496      groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];
3497    }
3498  }
3499
3500  let rewindFirstIndex = null;
3501  let rewindLastIndex = null;
3502
3503  if (params.rewind) {
3504    if (swiper.isBeginning) {
3505      rewindLastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
3506    } else if (swiper.isEnd) {
3507      rewindFirstIndex = 0;
3508    }
3509  } // Find current slide size
3510
3511
3512  const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;
3513  const increment = stopIndex < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
3514
3515  if (timeDiff > params.longSwipesMs) {
3516    // Long touches
3517    if (!params.longSwipes) {
3518      swiper.slideTo(swiper.activeIndex);
3519      return;
3520    }
3521
3522    if (swiper.swipeDirection === 'next') {
3523      if (ratio >= params.longSwipesRatio) swiper.slideTo(params.rewind && swiper.isEnd ? rewindFirstIndex : stopIndex + increment);else swiper.slideTo(stopIndex);
3524    }
3525
3526    if (swiper.swipeDirection === 'prev') {
3527      if (ratio > 1 - params.longSwipesRatio) {
3528        swiper.slideTo(stopIndex + increment);
3529      } else if (rewindLastIndex !== null && ratio < 0 && Math.abs(ratio) > params.longSwipesRatio) {
3530        swiper.slideTo(rewindLastIndex);
3531      } else {
3532        swiper.slideTo(stopIndex);
3533      }
3534    }
3535  } else {
3536    // Short swipes
3537    if (!params.shortSwipes) {
3538      swiper.slideTo(swiper.activeIndex);
3539      return;
3540    }
3541
3542    const isNavButtonTarget = swiper.navigation && (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);
3543
3544    if (!isNavButtonTarget) {
3545      if (swiper.swipeDirection === 'next') {
3546        swiper.slideTo(rewindFirstIndex !== null ? rewindFirstIndex : stopIndex + increment);
3547      }
3548
3549      if (swiper.swipeDirection === 'prev') {
3550        swiper.slideTo(rewindLastIndex !== null ? rewindLastIndex : stopIndex);
3551      }
3552    } else if (e.target === swiper.navigation.nextEl) {
3553      swiper.slideTo(stopIndex + increment);
3554    } else {
3555      swiper.slideTo(stopIndex);
3556    }
3557  }
3558}
3559
3560function onResize() {
3561  const swiper = this;
3562  const {
3563    params,
3564    el
3565  } = swiper;
3566  if (el && el.offsetWidth === 0) return; // Breakpoints
3567
3568  if (params.breakpoints) {
3569    swiper.setBreakpoint();
3570  } // Save locks
3571
3572
3573  const {
3574    allowSlideNext,
3575    allowSlidePrev,
3576    snapGrid
3577  } = swiper; // Disable locks on resize
3578
3579  swiper.allowSlideNext = true;
3580  swiper.allowSlidePrev = true;
3581  swiper.updateSize();
3582  swiper.updateSlides();
3583  swiper.updateSlidesClasses();
3584
3585  if ((params.slidesPerView === 'auto' || params.slidesPerView > 1) && swiper.isEnd && !swiper.isBeginning && !swiper.params.centeredSlides) {
3586    swiper.slideTo(swiper.slides.length - 1, 0, false, true);
3587  } else {
3588    swiper.slideTo(swiper.activeIndex, 0, false, true);
3589  }
3590
3591  if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
3592    swiper.autoplay.run();
3593  } // Return locks after resize
3594
3595
3596  swiper.allowSlidePrev = allowSlidePrev;
3597  swiper.allowSlideNext = allowSlideNext;
3598
3599  if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {
3600    swiper.checkOverflow();
3601  }
3602}
3603
3604function onClick(e) {
3605  const swiper = this;
3606  if (!swiper.enabled) return;
3607
3608  if (!swiper.allowClick) {
3609    if (swiper.params.preventClicks) e.preventDefault();
3610
3611    if (swiper.params.preventClicksPropagation && swiper.animating) {
3612      e.stopPropagation();
3613      e.stopImmediatePropagation();
3614    }
3615  }
3616}
3617
3618function onScroll() {
3619  const swiper = this;
3620  const {
3621    wrapperEl,
3622    rtlTranslate,
3623    enabled
3624  } = swiper;
3625  if (!enabled) return;
3626  swiper.previousTranslate = swiper.translate;
3627
3628  if (swiper.isHorizontal()) {
3629    swiper.translate = -wrapperEl.scrollLeft;
3630  } else {
3631    swiper.translate = -wrapperEl.scrollTop;
3632  } // eslint-disable-next-line
3633
3634
3635  if (swiper.translate === 0) swiper.translate = 0;
3636  swiper.updateActiveIndex();
3637  swiper.updateSlidesClasses();
3638  let newProgress;
3639  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
3640
3641  if (translatesDiff === 0) {
3642    newProgress = 0;
3643  } else {
3644    newProgress = (swiper.translate - swiper.minTranslate()) / translatesDiff;
3645  }
3646
3647  if (newProgress !== swiper.progress) {
3648    swiper.updateProgress(rtlTranslate ? -swiper.translate : swiper.translate);
3649  }
3650
3651  swiper.emit('setTranslate', swiper.translate, false);
3652}
3653
3654let dummyEventAttached = false;
3655
3656function dummyEventListener() {}
3657
3658const events = (swiper, method) => {
3659  const document = getDocument();
3660  const {
3661    params,
3662    touchEvents,
3663    el,
3664    wrapperEl,
3665    device,
3666    support
3667  } = swiper;
3668  const capture = !!params.nested;
3669  const domMethod = method === 'on' ? 'addEventListener' : 'removeEventListener';
3670  const swiperMethod = method; // Touch Events
3671
3672  if (!support.touch) {
3673    el[domMethod](touchEvents.start, swiper.onTouchStart, false);
3674    document[domMethod](touchEvents.move, swiper.onTouchMove, capture);
3675    document[domMethod](touchEvents.end, swiper.onTouchEnd, false);
3676  } else {
3677    const passiveListener = touchEvents.start === 'touchstart' && support.passiveListener && params.passiveListeners ? {
3678      passive: true,
3679      capture: false
3680    } : false;
3681    el[domMethod](touchEvents.start, swiper.onTouchStart, passiveListener);
3682    el[domMethod](touchEvents.move, swiper.onTouchMove, support.passiveListener ? {
3683      passive: false,
3684      capture
3685    } : capture);
3686    el[domMethod](touchEvents.end, swiper.onTouchEnd, passiveListener);
3687
3688    if (touchEvents.cancel) {
3689      el[domMethod](touchEvents.cancel, swiper.onTouchEnd, passiveListener);
3690    }
3691  } // Prevent Links Clicks
3692
3693
3694  if (params.preventClicks || params.preventClicksPropagation) {
3695    el[domMethod]('click', swiper.onClick, true);
3696  }
3697
3698  if (params.cssMode) {
3699    wrapperEl[domMethod]('scroll', swiper.onScroll);
3700  } // Resize handler
3701
3702
3703  if (params.updateOnWindowResize) {
3704    swiper[swiperMethod](device.ios || device.android ? 'resize orientationchange observerUpdate' : 'resize observerUpdate', onResize, true);
3705  } else {
3706    swiper[swiperMethod]('observerUpdate', onResize, true);
3707  }
3708};
3709
3710function attachEvents() {
3711  const swiper = this;
3712  const document = getDocument();
3713  const {
3714    params,
3715    support
3716  } = swiper;
3717  swiper.onTouchStart = onTouchStart.bind(swiper);
3718  swiper.onTouchMove = onTouchMove.bind(swiper);
3719  swiper.onTouchEnd = onTouchEnd.bind(swiper);
3720
3721  if (params.cssMode) {
3722    swiper.onScroll = onScroll.bind(swiper);
3723  }
3724
3725  swiper.onClick = onClick.bind(swiper);
3726
3727  if (support.touch && !dummyEventAttached) {
3728    document.addEventListener('touchstart', dummyEventListener);
3729    dummyEventAttached = true;
3730  }
3731
3732  events(swiper, 'on');
3733}
3734
3735function detachEvents() {
3736  const swiper = this;
3737  events(swiper, 'off');
3738}
3739
3740var events$1 = {
3741  attachEvents,
3742  detachEvents
3743};
3744
3745const isGridEnabled = (swiper, params) => {
3746  return swiper.grid && params.grid && params.grid.rows > 1;
3747};
3748
3749function setBreakpoint() {
3750  const swiper = this;
3751  const {
3752    activeIndex,
3753    initialized,
3754    loopedSlides = 0,
3755    params,
3756    $el
3757  } = swiper;
3758  const breakpoints = params.breakpoints;
3759  if (!breakpoints || breakpoints && Object.keys(breakpoints).length === 0) return; // Get breakpoint for window width and update parameters
3760
3761  const breakpoint = swiper.getBreakpoint(breakpoints, swiper.params.breakpointsBase, swiper.el);
3762  if (!breakpoint || swiper.currentBreakpoint === breakpoint) return;
3763  const breakpointOnlyParams = breakpoint in breakpoints ? breakpoints[breakpoint] : undefined;
3764  const breakpointParams = breakpointOnlyParams || swiper.originalParams;
3765  const wasMultiRow = isGridEnabled(swiper, params);
3766  const isMultiRow = isGridEnabled(swiper, breakpointParams);
3767  const wasEnabled = params.enabled;
3768
3769  if (wasMultiRow && !isMultiRow) {
3770    $el.removeClass(`${params.containerModifierClass}grid ${params.containerModifierClass}grid-column`);
3771    swiper.emitContainerClasses();
3772  } else if (!wasMultiRow && isMultiRow) {
3773    $el.addClass(`${params.containerModifierClass}grid`);
3774
3775    if (breakpointParams.grid.fill && breakpointParams.grid.fill === 'column' || !breakpointParams.grid.fill && params.grid.fill === 'column') {
3776      $el.addClass(`${params.containerModifierClass}grid-column`);
3777    }
3778
3779    swiper.emitContainerClasses();
3780  } // Toggle navigation, pagination, scrollbar
3781
3782
3783  ['navigation', 'pagination', 'scrollbar'].forEach(prop => {
3784    const wasModuleEnabled = params[prop] && params[prop].enabled;
3785    const isModuleEnabled = breakpointParams[prop] && breakpointParams[prop].enabled;
3786
3787    if (wasModuleEnabled && !isModuleEnabled) {
3788      swiper[prop].disable();
3789    }
3790
3791    if (!wasModuleEnabled && isModuleEnabled) {
3792      swiper[prop].enable();
3793    }
3794  });
3795  const directionChanged = breakpointParams.direction && breakpointParams.direction !== params.direction;
3796  const needsReLoop = params.loop && (breakpointParams.slidesPerView !== params.slidesPerView || directionChanged);
3797
3798  if (directionChanged && initialized) {
3799    swiper.changeDirection();
3800  }
3801
3802  extend(swiper.params, breakpointParams);
3803  const isEnabled = swiper.params.enabled;
3804  Object.assign(swiper, {
3805    allowTouchMove: swiper.params.allowTouchMove,
3806    allowSlideNext: swiper.params.allowSlideNext,
3807    allowSlidePrev: swiper.params.allowSlidePrev
3808  });
3809
3810  if (wasEnabled && !isEnabled) {
3811    swiper.disable();
3812  } else if (!wasEnabled && isEnabled) {
3813    swiper.enable();
3814  }
3815
3816  swiper.currentBreakpoint = breakpoint;
3817  swiper.emit('_beforeBreakpoint', breakpointParams);
3818
3819  if (needsReLoop && initialized) {
3820    swiper.loopDestroy();
3821    swiper.loopCreate();
3822    swiper.updateSlides();
3823    swiper.slideTo(activeIndex - loopedSlides + swiper.loopedSlides, 0, false);
3824  }
3825
3826  swiper.emit('breakpoint', breakpointParams);
3827}
3828
3829function getBreakpoint(breakpoints, base = 'window', containerEl) {
3830  if (!breakpoints || base === 'container' && !containerEl) return undefined;
3831  let breakpoint = false;
3832  const window = getWindow();
3833  const currentHeight = base === 'window' ? window.innerHeight : containerEl.clientHeight;
3834  const points = Object.keys(breakpoints).map(point => {
3835    if (typeof point === 'string' && point.indexOf('@') === 0) {
3836      const minRatio = parseFloat(point.substr(1));
3837      const value = currentHeight * minRatio;
3838      return {
3839        value,
3840        point
3841      };
3842    }
3843
3844    return {
3845      value: point,
3846      point
3847    };
3848  });
3849  points.sort((a, b) => parseInt(a.value, 10) - parseInt(b.value, 10));
3850
3851  for (let i = 0; i < points.length; i += 1) {
3852    const {
3853      point,
3854      value
3855    } = points[i];
3856
3857    if (base === 'window') {
3858      if (window.matchMedia(`(min-width: ${value}px)`).matches) {
3859        breakpoint = point;
3860      }
3861    } else if (value <= containerEl.clientWidth) {
3862      breakpoint = point;
3863    }
3864  }
3865
3866  return breakpoint || 'max';
3867}
3868
3869var breakpoints = {
3870  setBreakpoint,
3871  getBreakpoint
3872};
3873
3874function prepareClasses(entries, prefix) {
3875  const resultClasses = [];
3876  entries.forEach(item => {
3877    if (typeof item === 'object') {
3878      Object.keys(item).forEach(classNames => {
3879        if (item[classNames]) {
3880          resultClasses.push(prefix + classNames);
3881        }
3882      });
3883    } else if (typeof item === 'string') {
3884      resultClasses.push(prefix + item);
3885    }
3886  });
3887  return resultClasses;
3888}
3889
3890function addClasses() {
3891  const swiper = this;
3892  const {
3893    classNames,
3894    params,
3895    rtl,
3896    $el,
3897    device,
3898    support
3899  } = swiper; // prettier-ignore
3900
3901  const suffixes = prepareClasses(['initialized', params.direction, {
3902    'pointer-events': !support.touch
3903  }, {
3904    'free-mode': swiper.params.freeMode && params.freeMode.enabled
3905  }, {
3906    'autoheight': params.autoHeight
3907  }, {
3908    'rtl': rtl
3909  }, {
3910    'grid': params.grid && params.grid.rows > 1
3911  }, {
3912    'grid-column': params.grid && params.grid.rows > 1 && params.grid.fill === 'column'
3913  }, {
3914    'android': device.android
3915  }, {
3916    'ios': device.ios
3917  }, {
3918    'css-mode': params.cssMode
3919  }, {
3920    'centered': params.cssMode && params.centeredSlides
3921  }, {
3922    'watch-progress': params.watchSlidesProgress
3923  }], params.containerModifierClass);
3924  classNames.push(...suffixes);
3925  $el.addClass([...classNames].join(' '));
3926  swiper.emitContainerClasses();
3927}
3928
3929function removeClasses() {
3930  const swiper = this;
3931  const {
3932    $el,
3933    classNames
3934  } = swiper;
3935  $el.removeClass(classNames.join(' '));
3936  swiper.emitContainerClasses();
3937}
3938
3939var classes = {
3940  addClasses,
3941  removeClasses
3942};
3943
3944function loadImage(imageEl, src, srcset, sizes, checkForComplete, callback) {
3945  const window = getWindow();
3946  let image;
3947
3948  function onReady() {
3949    if (callback) callback();
3950  }
3951
3952  const isPicture = $(imageEl).parent('picture')[0];
3953
3954  if (!isPicture && (!imageEl.complete || !checkForComplete)) {
3955    if (src) {
3956      image = new window.Image();
3957      image.onload = onReady;
3958      image.onerror = onReady;
3959
3960      if (sizes) {
3961        image.sizes = sizes;
3962      }
3963
3964      if (srcset) {
3965        image.srcset = srcset;
3966      }
3967
3968      if (src) {
3969        image.src = src;
3970      }
3971    } else {
3972      onReady();
3973    }
3974  } else {
3975    // image already loaded...
3976    onReady();
3977  }
3978}
3979
3980function preloadImages() {
3981  const swiper = this;
3982  swiper.imagesToLoad = swiper.$el.find('img');
3983
3984  function onReady() {
3985    if (typeof swiper === 'undefined' || swiper === null || !swiper || swiper.destroyed) return;
3986    if (swiper.imagesLoaded !== undefined) swiper.imagesLoaded += 1;
3987
3988    if (swiper.imagesLoaded === swiper.imagesToLoad.length) {
3989      if (swiper.params.updateOnImagesReady) swiper.update();
3990      swiper.emit('imagesReady');
3991    }
3992  }
3993
3994  for (let i = 0; i < swiper.imagesToLoad.length; i += 1) {
3995    const imageEl = swiper.imagesToLoad[i];
3996    swiper.loadImage(imageEl, imageEl.currentSrc || imageEl.getAttribute('src'), imageEl.srcset || imageEl.getAttribute('srcset'), imageEl.sizes || imageEl.getAttribute('sizes'), true, onReady);
3997  }
3998}
3999
4000var images = {
4001  loadImage,
4002  preloadImages
4003};
4004
4005function checkOverflow() {
4006  const swiper = this;
4007  const {
4008    isLocked: wasLocked,
4009    params
4010  } = swiper;
4011  const {
4012    slidesOffsetBefore
4013  } = params;
4014
4015  if (slidesOffsetBefore) {
4016    const lastSlideIndex = swiper.slides.length - 1;
4017    const lastSlideRightEdge = swiper.slidesGrid[lastSlideIndex] + swiper.slidesSizesGrid[lastSlideIndex] + slidesOffsetBefore * 2;
4018    swiper.isLocked = swiper.size > lastSlideRightEdge;
4019  } else {
4020    swiper.isLocked = swiper.snapGrid.length === 1;
4021  }
4022
4023  if (params.allowSlideNext === true) {
4024    swiper.allowSlideNext = !swiper.isLocked;
4025  }
4026
4027  if (params.allowSlidePrev === true) {
4028    swiper.allowSlidePrev = !swiper.isLocked;
4029  }
4030
4031  if (wasLocked && wasLocked !== swiper.isLocked) {
4032    swiper.isEnd = false;
4033  }
4034
4035  if (wasLocked !== swiper.isLocked) {
4036    swiper.emit(swiper.isLocked ? 'lock' : 'unlock');
4037  }
4038}
4039
4040var checkOverflow$1 = {
4041  checkOverflow
4042};
4043
4044var defaults = {
4045  init: true,
4046  direction: 'horizontal',
4047  touchEventsTarget: 'wrapper',
4048  initialSlide: 0,
4049  speed: 300,
4050  cssMode: false,
4051  updateOnWindowResize: true,
4052  resizeObserver: true,
4053  nested: false,
4054  createElements: false,
4055  enabled: true,
4056  focusableElements: 'input, select, option, textarea, button, video, label',
4057  // Overrides
4058  width: null,
4059  height: null,
4060  //
4061  preventInteractionOnTransition: false,
4062  // ssr
4063  userAgent: null,
4064  url: null,
4065  // To support iOS's swipe-to-go-back gesture (when being used in-app).
4066  edgeSwipeDetection: false,
4067  edgeSwipeThreshold: 20,
4068  // Autoheight
4069  autoHeight: false,
4070  // Set wrapper width
4071  setWrapperSize: false,
4072  // Virtual Translate
4073  virtualTranslate: false,
4074  // Effects
4075  effect: 'slide',
4076  // 'slide' or 'fade' or 'cube' or 'coverflow' or 'flip'
4077  // Breakpoints
4078  breakpoints: undefined,
4079  breakpointsBase: 'window',
4080  // Slides grid
4081  spaceBetween: 0,
4082  slidesPerView: 1,
4083  slidesPerGroup: 1,
4084  slidesPerGroupSkip: 0,
4085  slidesPerGroupAuto: false,
4086  centeredSlides: false,
4087  centeredSlidesBounds: false,
4088  slidesOffsetBefore: 0,
4089  // in px
4090  slidesOffsetAfter: 0,
4091  // in px
4092  normalizeSlideIndex: true,
4093  centerInsufficientSlides: false,
4094  // Disable swiper and hide navigation when container not overflow
4095  watchOverflow: true,
4096  // Round length
4097  roundLengths: false,
4098  // Touches
4099  touchRatio: 1,
4100  touchAngle: 45,
4101  simulateTouch: true,
4102  shortSwipes: true,
4103  longSwipes: true,
4104  longSwipesRatio: 0.5,
4105  longSwipesMs: 300,
4106  followFinger: true,
4107  allowTouchMove: true,
4108  threshold: 0,
4109  touchMoveStopPropagation: false,
4110  touchStartPreventDefault: true,
4111  touchStartForcePreventDefault: false,
4112  touchReleaseOnEdges: false,
4113  // Unique Navigation Elements
4114  uniqueNavElements: true,
4115  // Resistance
4116  resistance: true,
4117  resistanceRatio: 0.85,
4118  // Progress
4119  watchSlidesProgress: false,
4120  // Cursor
4121  grabCursor: false,
4122  // Clicks
4123  preventClicks: true,
4124  preventClicksPropagation: true,
4125  slideToClickedSlide: false,
4126  // Images
4127  preloadImages: true,
4128  updateOnImagesReady: true,
4129  // loop
4130  loop: false,
4131  loopAdditionalSlides: 0,
4132  loopedSlides: null,
4133  loopedSlidesLimit: true,
4134  loopFillGroupWithBlank: false,
4135  loopPreventsSlide: true,
4136  // rewind
4137  rewind: false,
4138  // Swiping/no swiping
4139  allowSlidePrev: true,
4140  allowSlideNext: true,
4141  swipeHandler: null,
4142  // '.swipe-handler',
4143  noSwiping: true,
4144  noSwipingClass: 'swiper-no-swiping',
4145  noSwipingSelector: null,
4146  // Passive Listeners
4147  passiveListeners: true,
4148  maxBackfaceHiddenSlides: 10,
4149  // NS
4150  containerModifierClass: 'swiper-',
4151  // NEW
4152  slideClass: 'swiper-slide',
4153  slideBlankClass: 'swiper-slide-invisible-blank',
4154  slideActiveClass: 'swiper-slide-active',
4155  slideDuplicateActiveClass: 'swiper-slide-duplicate-active',
4156  slideVisibleClass: 'swiper-slide-visible',
4157  slideDuplicateClass: 'swiper-slide-duplicate',
4158  slideNextClass: 'swiper-slide-next',
4159  slideDuplicateNextClass: 'swiper-slide-duplicate-next',
4160  slidePrevClass: 'swiper-slide-prev',
4161  slideDuplicatePrevClass: 'swiper-slide-duplicate-prev',
4162  wrapperClass: 'swiper-wrapper',
4163  // Callbacks
4164  runCallbacksOnInit: true,
4165  // Internals
4166  _emitClasses: false
4167};
4168
4169function moduleExtendParams(params, allModulesParams) {
4170  return function extendParams(obj = {}) {
4171    const moduleParamName = Object.keys(obj)[0];
4172    const moduleParams = obj[moduleParamName];
4173
4174    if (typeof moduleParams !== 'object' || moduleParams === null) {
4175      extend(allModulesParams, obj);
4176      return;
4177    }
4178
4179    if (['navigation', 'pagination', 'scrollbar'].indexOf(moduleParamName) >= 0 && params[moduleParamName] === true) {
4180      params[moduleParamName] = {
4181        auto: true
4182      };
4183    }
4184
4185    if (!(moduleParamName in params && 'enabled' in moduleParams)) {
4186      extend(allModulesParams, obj);
4187      return;
4188    }
4189
4190    if (params[moduleParamName] === true) {
4191      params[moduleParamName] = {
4192        enabled: true
4193      };
4194    }
4195
4196    if (typeof params[moduleParamName] === 'object' && !('enabled' in params[moduleParamName])) {
4197      params[moduleParamName].enabled = true;
4198    }
4199
4200    if (!params[moduleParamName]) params[moduleParamName] = {
4201      enabled: false
4202    };
4203    extend(allModulesParams, obj);
4204  };
4205}
4206
4207/* eslint no-param-reassign: "off" */
4208const prototypes = {
4209  eventsEmitter,
4210  update,
4211  translate,
4212  transition,
4213  slide,
4214  loop,
4215  grabCursor,
4216  events: events$1,
4217  breakpoints,
4218  checkOverflow: checkOverflow$1,
4219  classes,
4220  images
4221};
4222const extendedDefaults = {};
4223
4224class Swiper {
4225  constructor(...args) {
4226    let el;
4227    let params;
4228
4229    if (args.length === 1 && args[0].constructor && Object.prototype.toString.call(args[0]).slice(8, -1) === 'Object') {
4230      params = args[0];
4231    } else {
4232      [el, params] = args;
4233    }
4234
4235    if (!params) params = {};
4236    params = extend({}, params);
4237    if (el && !params.el) params.el = el;
4238
4239    if (params.el && $(params.el).length > 1) {
4240      const swipers = [];
4241      $(params.el).each(containerEl => {
4242        const newParams = extend({}, params, {
4243          el: containerEl
4244        });
4245        swipers.push(new Swiper(newParams));
4246      }); // eslint-disable-next-line no-constructor-return
4247
4248      return swipers;
4249    } // Swiper Instance
4250
4251
4252    const swiper = this;
4253    swiper.__swiper__ = true;