https://euresurs.ba/wp-content/plugins/lastudio-element-kit/assets/js/lib/swiper.min.js?ver=8.4.5

1/**
2 * Swiper 8.4.5
3 * Most modern mobile touch slider and framework with hardware accelerated transitions
4 * https://swiperjs.com
5 *
6 * Copyright 2014-2022 Vladimir Kharlampidi
7 *
8 * Released under the MIT License
9 *
10 * Released on: November 21, 2022
11 */
12
13(function (global, factory) {
14 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
15     typeof define === 'function' && define.amd ? define(factory) :
16         (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Swiper = factory());
17})(this, (function () { 'use strict';
18
19 /**
20  * SSR Window 4.0.2
21  * Better handling for window object in SSR environment
22  * https://github.com/nolimits4web/ssr-window
23  *
24  * Copyright 2021, Vladimir Kharlampidi
25  *
26  * Licensed under MIT
27  *
28  * Released on: December 13, 2021
29  */
30
31 /* eslint-disable no-param-reassign */
32 function isObject$1(obj) {
33  return obj !== null && typeof obj === 'object' && 'constructor' in obj && obj.constructor === Object;
34 }
35
36 function extend$1(target, src) {
37  if (target === void 0) {
38   target = {};
39  }
40
41  if (src === void 0) {
42   src = {};
43  }
44
45  Object.keys(src).forEach(key => {
46   if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject$1(src[key]) && isObject$1(target[key]) && Object.keys(src[key]).length > 0) {
47    extend$1(target[key], src[key]);
48   }
49  });
50 }
51
52 const ssrDocument = {
53  body: {},
54
55  addEventListener() {},
56
57  removeEventListener() {},
58
59  activeElement: {
60   blur() {},
61
62   nodeName: ''
63  },
64
65  querySelector() {
66   return null;
67  },
68
69  querySelectorAll() {
70   return [];
71  },
72
73  getElementById() {
74   return null;
75  },
76
77  createEvent() {
78   return {
79    initEvent() {}
80
81   };
82  },
83
84  createElement() {
85   return {
86    children: [],
87    childNodes: [],
88    style: {},
89
90    setAttribute() {},
91
92    getElementsByTagName() {
93     return [];
94    }
95
96   };
97  },
98
99  createElementNS() {
100   return {};
101  },
102
103  importNode() {
104   return null;
105  },
106
107  location: {
108   hash: '',
109   host: '',
110   hostname: '',
111   href: '',
112   origin: '',
113   pathname: '',
114   protocol: '',
115   search: ''
116  }
117 };
118
119 function getDocument() {
120  const doc = typeof document !== 'undefined' ? document : {};
121  extend$1(doc, ssrDocument);
122  return doc;
123 }
124
125 const ssrWindow = {
126  document: ssrDocument,
127  navigator: {
128   userAgent: ''
129  },
130  location: {
131   hash: '',
132   host: '',
133   hostname: '',
134   href: '',
135   origin: '',
136   pathname: '',
137   protocol: '',
138   search: ''
139  },
140  history: {
141   replaceState() {},
142
143   pushState() {},
144
145   go() {},
146
147   back() {}
148
149  },
150  CustomEvent: function CustomEvent() {
151   return this;
152  },
153
154  addEventListener() {},
155
156  removeEventListener() {},
157
158  getComputedStyle() {
159   return {
160    getPropertyValue() {
161     return '';
162    }
163
164   };
165  },
166
167  Image() {},
168
169  Date() {},
170
171  screen: {},
172
173  setTimeout() {},
174
175  clearTimeout() {},
176
177  matchMedia() {
178   return {};
179  },
180
181  requestAnimationFrame(callback) {
182   if (typeof setTimeout === 'undefined') {
183    callback();
184    return null;
185   }
186
187   return setTimeout(callback, 0);
188  },
189
190  cancelAnimationFrame(id) {
191   if (typeof setTimeout === 'undefined') {
192    return;
193   }
194
195   clearTimeout(id);
196  }
197
198 };
199
200 function getWindow() {
201  const win = typeof window !== 'undefined' ? window : {};
202  extend$1(win, ssrWindow);
203  return win;
204 }
205
206 /**
207  * Dom7 4.0.4
208  * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API
209  * https://framework7.io/docs/dom7.html
210  *
211  * Copyright 2022, Vladimir Kharlampidi
212  *
213  * Licensed under MIT
214  *
215  * Released on: January 11, 2022
216  */
217 /* eslint-disable no-proto */
218
219 function makeReactive(obj) {
220  const proto = obj.__proto__;
221  Object.defineProperty(obj, '__proto__', {
222   get() {
223    return proto;
224   },
225
226   set(value) {
227    proto.__proto__ = value;
228   }
229
230  });
231 }
232
233 class Dom7 extends Array {
234  constructor(items) {
235   if (typeof items === 'number') {
236    super(items);
237   } else {
238    super(...(items || []));
239    makeReactive(this);
240   }
241  }
242
243 }
244
245 function arrayFlat(arr) {
246  if (arr === void 0) {
247   arr = [];
248  }
249
250  const res = [];
251  arr.forEach(el => {
252   if (Array.isArray(el)) {
253    res.push(...arrayFlat(el));
254   } else {
255    res.push(el);
256   }
257  });
258  return res;
259 }
260
261 function arrayFilter(arr, callback) {
262  return Array.prototype.filter.call(arr, callback);
263 }
264
265 function arrayUnique(arr) {
266  const uniqueArray = [];
267
268  for (let i = 0; i < arr.length; i += 1) {

269   if (uniqueArray.indexOf(arr[i]) === -1) uniqueArray.push(arr[i]);
270  }
271
272  return uniqueArray;
273 }
274
275
276 function qsa(selector, context) {
277  if (typeof selector !== 'string') {
278   return [selector];
279  }
280
281  const a = [];
282  const res = context.querySelectorAll(selector);
283
284  for (let i = 0; i < res.length; i += 1) {
285   a.push(res[i]);
286  }
287
288  return a;
289 }
290
291 function $(selector, context) {
292  const window = getWindow();
293  const document = getDocument();
294  let arr = [];
295
296  if (!context && selector instanceof Dom7) {
297   return selector;
298  }
299
300  if (!selector) {
301   return new Dom7(arr);
302  }
303
304  if (typeof selector === 'string') {
305   const html = selector.trim();
306
307   if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {
308    let toCreate = 'div';
309    if (html.indexOf('<li') === 0) toCreate = 'ul';
310    if (html.indexOf('<tr') === 0) toCreate = 'tbody';
311    if (html.indexOf('<td') === 0 || html.indexOf('<th') === 0) toCreate = 'tr';
312    if (html.indexOf('<tbody') === 0) toCreate = 'table';
313    if (html.indexOf('<option') === 0) toCreate = 'select';
314    const tempParent = document.createElement(toCreate);
315    tempParent.innerHTML = html;
316
317    for (let i = 0; i < tempParent.childNodes.length; i += 1) {
318     arr.push(tempParent.childNodes[i]);
319    }
320   } else {
321    arr = qsa(selector.trim(), context || document);
322   } // arr = qsa(selector, document);
323
324  } else if (selector.nodeType || selector === window || selector === document) {
325   arr.push(selector);
326  } else if (Array.isArray(selector)) {
327   if (selector instanceof Dom7) return selector;
328   arr = selector;
329  }
330
331  return new Dom7(arrayUnique(arr));
332 }
333
334 $.fn = Dom7.prototype; // eslint-disable-next-line
335
336 function addClass() {
337  for (var _len = arguments.length, classes = new Array(_len), _key = 0; _key < _len; _key++) {
338   classes[_key] = arguments[_key];
339  }
340
341  const classNames = arrayFlat(classes.map(c => c.split(' ')));
342  this.forEach(el => {
343   el.classList.add(...classNames);
344  });
345  return this;
346 }
347
348 function removeClass() {
349  for (var _len2 = arguments.length, classes = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
350   classes[_key2] = arguments[_key2];
351  }
352
353  const classNames = arrayFlat(classes.map(c => c.split(' ')));
354  this.forEach(el => {
355   el.classList.remove(...classNames);
356  });
357  return this;
358 }
359
360 function toggleClass() {
361  for (var _len3 = arguments.length, classes = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
362   classes[_key3] = arguments[_key3];
363  }
364
365  const classNames = arrayFlat(classes.map(c => c.split(' ')));
366  this.forEach(el => {
367   classNames.forEach(className => {
368    el.classList.toggle(className);
369   });
370  });
371 }
372
373 function hasClass() {
374  for (var _len4 = arguments.length, classes = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
375   classes[_key4] = arguments[_key4];
376  }
377
378  const classNames = arrayFlat(classes.map(c => c.split(' ')));
379  return arrayFilter(this, el => {
380   return classNames.filter(className => el.classList.contains(className)).length > 0;
381  }).length > 0;
382 }
383
384 function attr(attrs, value) {
385  if (arguments.length === 1 && typeof attrs === 'string') {
386   // Get attr
387   if (this[0]) return this[0].getAttribute(attrs);
388   return undefined;
389  } // Set attrs
390
391
392  for (let i = 0; i < this.length; i += 1) {
393   if (arguments.length === 2) {
394    // String
395    this[i].setAttribute(attrs, value);
396   } else {
397    // Object
398    for (const attrName in attrs) {
399     this[i][attrName] = attrs[attrName];
400     this[i].setAttribute(attrName, attrs[attrName]);
401    }
402   }
403  }
404
405  return this;
406 }
407
408 function removeAttr(attr) {
409  for (let i = 0; i < this.length; i += 1) {
410   this[i].removeAttribute(attr);
411  }
412
413  return this;
414 }
415
416 function transform(transform) {
417  for (let i = 0; i < this.length; i += 1) {
418   this[i].style.transform = transform;
419  }
420
421  return this;
422 }
423
424 function transition$1(duration) {
425  for (let i = 0; i < this.length; i += 1) {
426   this[i].style.transitionDuration = typeof duration !== 'string' ? `${duration}ms` : duration;
427  }
428
429  return this;
430 }
431
432 function on() {
433  for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
434   args[_key5] = arguments[_key5];
435  }
436
437  let [eventType, targetSelector, listener, capture] = args;
438
439  if (typeof args[1] === 'function') {
440   [eventType, listener, capture] = args;
441   targetSelector = undefined;
442  }
443
444  if (!capture) capture = false;
445
446  function handleLiveEvent(e) {
447   const target = e.target;
448   if (!target) return;
449   const eventData = e.target.dom7EventData || [];
450
451   if (eventData.indexOf(e) < 0) {
452    eventData.unshift(e);
453   }
454
455   if ($(target).is(targetSelector)) listener.apply(target, eventData);else {
456    const parents = $(target).parents(); // eslint-disable-line
457
458    for (let k = 0; k < parents.length; k += 1) {
459     if ($(parents[k]).is(targetSelector)) listener.apply(parents[k], eventData);
460    }
461   }
462  }
463
464  function handleEvent(e) {
465   const eventData = e && e.target ? e.target.dom7EventData || [] : [];
466
467   if (eventData.indexOf(e) < 0) {
468    eventData.unshift(e);
469   }
470
471   listener.apply(this, eventData);
472  }
473
474  const events = eventType.split(' ');
475  let j;
476
477  for (let i = 0; i < this.length; i += 1) {
478   const el = this[i];
479
480   if (!targetSelector) {
481    for (j = 0; j < events.length; j += 1) {
482     const event = events[j];
483     if (!el.dom7Listeners) el.dom7Listeners = {};
484     if (!el.dom7Listeners[event]) el.dom7Listeners[event] = [];
485     el.dom7Listeners[event].push({
486      listener,
487      proxyListener: handleEvent
488     });
489     el.addEventListener(event, handleEvent, capture);
490    }
491   } else {
492    // Live events
493    for (j = 0; j < events.length; j += 1) {
494     const event = events[j];
495     if (!el.dom7LiveListeners) el.dom7LiveListeners = {};
496     if (!el.dom7LiveListeners[event]) el.dom7LiveListeners[event] = [];
497     el.dom7LiveListeners[event].push({
498      listener,
499      proxyListener: handleLiveEvent
500     });
501     el.addEventListener(event, handleLiveEvent, capture);
502    }
503   }
504  }
505
506  return this;
507 }
508
509 function off() {
510  for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
511   args[_key6] = arguments[_key6];
512  }
513
514  let [eventType, targetSelector, listener, capture] = args;
515
516  if (typeof args[1] === 'function') {
517   [eventType, listener, capture] = args;
518   targetSelector = undefined;
519  }
520
521  if (!capture) capture = false;
522  const events = eventType.split(' ');
523
524  for (let i = 0; i < events.length; i += 1) {
525   const event = events[i];
526
527   for (let j = 0; j < this.length; j += 1) {
528    const el = this[j];
529    let handlers;
530
531    if (!targetSelector && el.dom7Listeners) {
532     handlers = el.dom7Listeners[event];
533    } else if (targetSelector && el.dom7LiveListeners) {
534     handlers = el.dom7LiveListeners[event];
535    }
536
537    if (handlers && handlers.length) {
538     for (let k = handlers.length - 1; k >= 0; k -= 1) {
539      const handler = handlers[k];
540
541      if (listener && handler.listener === listener) {
542       el.removeEventListener(event, handler.proxyListener, capture);
543       handlers.splice(k, 1);
544      } else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) {
545       el.removeEventListener(event, handler.proxyListener, capture);
546       handlers.splice(k, 1);
547      } else if (!listener) {
548       el.removeEventListener(event, handler.proxyListener, capture);
549       handlers.splice(k, 1);
550      }
551     }
552    }
553   }
554  }
555
556  return this;
557 }
558
559 function trigger() {
560  const window = getWindow();
561
562  for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
563   args[_key9] = arguments[_key9];
564  }
565
566  const events = args[0].split(' ');
567  const eventData = args[1];
568
569  for (let i = 0; i < events.length; i += 1) {
570   const event = events[i];
571
572   for (let j = 0; j < this.length; j += 1) {
573    const el = this[j];
574
575    if (window.CustomEvent) {
576     const evt = new window.CustomEvent(event, {
577      detail: eventData,
578      bubbles: true,
579      cancelable: true
580     });
581     el.dom7EventData = args.filter((data, dataIndex) => dataIndex > 0);
582     el.dispatchEvent(evt);
583     el.dom7EventData = [];
584     delete el.dom7EventData;
585    }
586   }
587  }
588
589  return this;
590 }
591
592 function transitionEnd$1(callback) {
593  const dom = this;
594
595  function fireCallBack(e) {
596   if (e.target !== this) return;
597   callback.call(this, e);
598   dom.off('transitionend', fireCallBack);
599  }
600
601  if (callback) {
602   dom.on('transitionend', fireCallBack);
603  }
604
605  return this;
606 }
607
608 function outerWidth(includeMargins) {
609  if (this.length > 0) {
610   if (includeMargins) {
611    const styles = this.styles();
612    return this[0].offsetWidth + parseFloat(styles.getPropertyValue('margin-right')) + parseFloat(styles.getPropertyValue('margin-left'));
613   }
614
615   return this[0].offsetWidth;
616  }
617
618  return null;
619 }
620
621 function outerHeight(includeMargins) {
622  if (this.length > 0) {
623   if (includeMargins) {
624    const styles = this.styles();
625    return this[0].offsetHeight + parseFloat(styles.getPropertyValue('margin-top')) + parseFloat(styles.getPropertyValue('margin-bottom'));
626   }
627
628   return this[0].offsetHeight;
629  }
630
631  return null;
632 }
633
634 function offset() {
635  if (this.length > 0) {
636   const window = getWindow();
637   const document = getDocument();
638   const el = this[0];
639   const box = el.getBoundingClientRect();
640   const body = document.body;
641   const clientTop = el.clientTop || body.clientTop || 0;
642   const clientLeft = el.clientLeft || body.clientLeft || 0;
643   const scrollTop = el === window ? window.scrollY : el.scrollTop;
644   const scrollLeft = el === window ? window.scrollX : el.scrollLeft;
645   return {
646    top: box.top + scrollTop - clientTop,
647    left: box.left + scrollLeft - clientLeft
648   };
649  }
650
651  return null;
652 }
653
654 function styles() {
655  const window = getWindow();
656  if (this[0]) return window.getComputedStyle(this[0], null);
657  return {};
658 }
659
660 function css(props, value) {
661  const window = getWindow();
662  let i;
663
664  if (arguments.length === 1) {
665   if (typeof props === 'string') {
666    // .css('width')
667    if (this[0]) return window.getComputedStyle(this[0], null).getPropertyValue(props);
668   } else {
669    // .css({ width: '100px' })
670    for (i = 0; i < this.length; i += 1) {
671     for (const prop in props) {
672      this[i].style[prop] = props[prop];
673     }
674    }
675
676    return this;
677   }
678  }
679
680  if (arguments.length === 2 && typeof props === 'string') {
681   // .css('width', '100px')
682   for (i = 0; i < this.length; i += 1) {
683    this[i].style[props] = value;
684   }
685
686   return this;
687  }
688
689  return this;
690 }
691
692 function each(callback) {
693  if (!callback) return this;
694  this.forEach((el, index) => {
695   callback.apply(el, [el, index]);
696  });
697  return this;
698 }
699
700 function filter(callback) {
701  const result = arrayFilter(this, callback);
702  return $(result);
703 }
704
705 function html(html) {
706  if (typeof html === 'undefined') {
707   return this[0] ? this[0].innerHTML : null;
708  }
709
710  for (let i = 0; i < this.length; i += 1) {
711   this[i].innerHTML = html;
712  }
713
714  return this;
715 }
716
717 function text(text) {
718  if (typeof text === 'undefined') {
719   return this[0] ? this[0].textContent.trim() : null;
720  }
721
722  for (let i = 0; i < this.length; i += 1) {
723   this[i].textContent = text;
724  }
725
726  return this;
727 }
728
729 function is(selector) {
730  const window = getWindow();
731  const document = getDocument();
732  const el = this[0];
733  let compareWith;
734  let i;
735  if (!el || typeof selector === 'undefined') return false;

736
737  if (typeof selector === 'string') {
738   if (el.matches) return el.matches(selector);
739   if (el.webkitMatchesSelector) return el.webkitMatchesSelector(selector);
740   if (el.msMatchesSelector) return el.msMatchesSelector(selector);
741   compareWith = $(selector);
742
743   for (i = 0; i < compareWith.length; i += 1) {
744    if (compareWith[i] === el) return true;
745   }
746
747   return false;
748  }
749
750  if (selector === document) {
751   return el === document;
752  }
753
754  if (selector === window) {
755   return el === window;
756  }
757
758  if (selector.nodeType || selector instanceof Dom7) {
759   compareWith = selector.nodeType ? [selector] : selector;
760
761   for (i = 0; i < compareWith.length; i += 1) {
762    if (compareWith[i] === el) return true;
763   }
764
765   return false;
766  }
767
768  return false;
769 }
770
771 function index() {
772  let child = this[0];
773  let i;
774
775  if (child) {
776   i = 0; // eslint-disable-next-line
777
778   while ((child = child.previousSibling) !== null) {
779    if (child.nodeType === 1) i += 1;
780   }
781
782   return i;
783  }
784
785  return undefined;
786 }
787
788 function eq(index) {
789  if (typeof index === 'undefined') return this;
790  const length = this.length;
791
792  if (index > length - 1) {
793   return $([]);
794  }
795
796  if (index < 0) {
797   const returnIndex = length + index;
798   if (returnIndex < 0) return $([]);
799   return $([this[returnIndex]]);
800  }
801
802  return $([this[index]]);
803 }
804
805 function append() {
806  let newChild;
807  const document = getDocument();
808
809  for (let k = 0; k < arguments.length; k += 1) {
810   newChild = k < 0 || arguments.length <= k ? undefined : arguments[k];
811
812   for (let i = 0; i < this.length; i += 1) {
813    if (typeof newChild === 'string') {
814     const tempDiv = document.createElement('div');
815     tempDiv.innerHTML = newChild;
816
817     while (tempDiv.firstChild) {
818      this[i].appendChild(tempDiv.firstChild);
819     }
820    } else if (newChild instanceof Dom7) {
821     for (let j = 0; j < newChild.length; j += 1) {
822      this[i].appendChild(newChild[j]);
823     }
824    } else {
825     this[i].appendChild(newChild);
826    }
827   }
828  }
829
830  return this;
831 }
832
833 function prepend(newChild) {
834  const document = getDocument();
835  let i;
836  let j;
837
838  for (i = 0; i < this.length; i += 1) {
839   if (typeof newChild === 'string') {
840    const tempDiv = document.createElement('div');
841    tempDiv.innerHTML = newChild;
842
843    for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
844     this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
845    }
846   } else if (newChild instanceof Dom7) {
847    for (j = 0; j < newChild.length; j += 1) {
848     this[i].insertBefore(newChild[j], this[i].childNodes[0]);
849    }
850   } else {
851    this[i].insertBefore(newChild, this[i].childNodes[0]);
852   }
853  }
854
855  return this;
856 }
857
858 function next(selector) {
859  if (this.length > 0) {
860   if (selector) {
861    if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {
862     return $([this[0].nextElementSibling]);
863    }
864
865    return $([]);
866   }
867
868   if (this[0].nextElementSibling) return $([this[0].nextElementSibling]);
869   return $([]);
870  }
871
872  return $([]);
873 }
874
875 function nextAll(selector) {
876  const nextEls = [];
877  let el = this[0];
878  if (!el) return $([]);
879
880  while (el.nextElementSibling) {
881   const next = el.nextElementSibling; // eslint-disable-line
882
883   if (selector) {
884    if ($(next).is(selector)) nextEls.push(next);
885   } else nextEls.push(next);
886
887   el = next;
888  }
889
890  return $(nextEls);
891 }
892
893 function prev(selector) {
894  if (this.length > 0) {
895   const el = this[0];
896
897   if (selector) {
898    if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {
899     return $([el.previousElementSibling]);
900    }
901
902    return $([]);
903   }
904
905   if (el.previousElementSibling) return $([el.previousElementSibling]);
906   return $([]);
907  }
908
909  return $([]);
910 }
911
912 function prevAll(selector) {
913  const prevEls = [];
914  let el = this[0];
915  if (!el) return $([]);
916
917  while (el.previousElementSibling) {
918   const prev = el.previousElementSibling; // eslint-disable-line
919
920   if (selector) {
921    if ($(prev).is(selector)) prevEls.push(prev);
922   } else prevEls.push(prev);
923
924   el = prev;
925  }
926
927  return $(prevEls);
928 }
929
930 function parent(selector) {
931  const parents = []; // eslint-disable-line
932
933  for (let i = 0; i < this.length; i += 1) {
934   if (this[i].parentNode !== null) {
935    if (selector) {
936     if ($(this[i].parentNode).is(selector)) parents.push(this[i].parentNode);
937    } else {
938     parents.push(this[i].parentNode);
939    }
940   }
941  }
942
943  return $(parents);
944 }
945
946 function parents(selector) {
947  const parents = []; // eslint-disable-line
948
949  for (let i = 0; i < this.length; i += 1) {
950   let parent = this[i].parentNode; // eslint-disable-line
951
952   while (parent) {
953    if (selector) {
954     if ($(parent).is(selector)) parents.push(parent);
955    } else {
956     parents.push(parent);
957    }
958
959    parent = parent.parentNode;
960   }
961  }
962
963  return $(parents);
964 }
965
966 function closest(selector) {
967  let closest = this; // eslint-disable-line
968
969  if (typeof selector === 'undefined') {
970   return $([]);
971  }
972

973  if (!closest.is(selector)) {
974   closest = closest.parents(selector).eq(0);
975  }
976
977  return closest;
978 }
979
980 function find(selector) {
981  const foundElements = [];
982
983  for (let i = 0; i < this.length; i += 1) {
984   const found = this[i].querySelectorAll(selector);
985
986   for (let j = 0; j < found.length; j += 1) {
987    foundElements.push(found[j]);
988   }
989  }
990
991  return $(foundElements);
992 }
993
994 function children(selector) {
995  const children = []; // eslint-disable-line
996
997  for (let i = 0; i < this.length; i += 1) {
998   const childNodes = this[i].children;
999
1000   for (let j = 0; j < childNodes.length; j += 1) {
1001    if (!selector || $(childNodes[j]).is(selector)) {
1002     children.push(childNodes[j]);
1003    }
1004   }
1005  }
1006
1007  return $(children);
1008 }
1009
1010 function remove() {
1011  for (let i = 0; i < this.length; i += 1) {
1012   if (this[i].parentNode) this[i].parentNode.removeChild(this[i]);
1013  }
1014
1015  return this;
1016 }
1017
1018 const Methods = {
1019  addClass,
1020  removeClass,
1021  hasClass,
1022  toggleClass,
1023  attr,
1024  removeAttr,
1025  transform,
1026  transition: transition$1,
1027  on,
1028  off,
1029  trigger,
1030  transitionEnd: transitionEnd$1,
1031  outerWidth,
1032  outerHeight,
1033  styles,
1034  offset,
1035  css,
1036  each,
1037  html,
1038  text,
1039  is,
1040  index,
1041  eq,
1042  append,
1043  prepend,
1044  next,
1045  nextAll,
1046  prev,
1047  prevAll,
1048  parent,
1049  parents,
1050  closest,
1051  find,
1052  children,
1053  filter,
1054  remove
1055 };
1056 Object.keys(Methods).forEach(methodName => {
1057  Object.defineProperty($.fn, methodName, {
1058   value: Methods[methodName],
1059   writable: true
1060  });
1061 });
1062
1063 function deleteProps(obj) {
1064  const object = obj;
1065  Object.keys(object).forEach(key => {
1066   try {
1067    object[key] = null;
1068   } catch (e) {// no getter for object
1069   }
1070
1071   try {
1072    delete object[key];
1073   } catch (e) {// something got wrong
1074   }
1075  });
1076 }
1077
1078 function nextTick(callback, delay) {
1079  if (delay === void 0) {
1080   delay = 0;
1081  }
1082
1083  return setTimeout(callback, delay);
1084 }
1085
1086 function now() {
1087  return Date.now();
1088 }
1089
1090 function getComputedStyle$1(el) {
1091  const window = getWindow();
1092  let style;
1093
1094  if (window.getComputedStyle) {
1095   style = window.getComputedStyle(el, null);
1096  }
1097
1098  if (!style && el.currentStyle) {
1099   style = el.currentStyle;
1100  }
1101
1102  if (!style) {
1103   style = el.style;
1104  }
1105
1106  return style;
1107 }
1108
1109 function getTranslate(el, axis) {
1110  if (axis === void 0) {
1111   axis = 'x';
1112  }
1113
1114  const window = getWindow();
1115  let matrix;
1116  let curTransform;
1117  let transformMatrix;
1118  const curStyle = getComputedStyle$1(el);
1119
1120  if (window.WebKitCSSMatrix) {
1121   curTransform = curStyle.transform || curStyle.webkitTransform;
1122
1123   if (curTransform.split(',').length > 6) {
1124    curTransform = curTransform.split(', ').map(a => a.replace(',', '.')).join(', ');
1125   } // Some old versions of Webkit choke when 'none' is passed; pass
1126   // empty string instead in this case
1127
1128
1129   transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
1130  } else {
1131   transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
1132   matrix = transformMatrix.toString().split(',');
1133  }
1134
1135  if (axis === 'x') {
1136   // Latest Chrome and webkits Fix
1137   if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41; // Crazy IE10 Matrix
1138   else if (matrix.length === 16) curTransform = parseFloat(matrix[12]); // Normal Browsers
1139   else curTransform = parseFloat(matrix[4]);
1140  }
1141
1142  if (axis === 'y') {
1143   // Latest Chrome and webkits Fix
1144   if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42; // Crazy IE10 Matrix
1145   else if (matrix.length === 16) curTransform = parseFloat(matrix[13]); // Normal Browsers
1146   else curTransform = parseFloat(matrix[5]);
1147  }
1148
1149  return curTransform || 0;
1150 }
1151
1152 function isObject(o) {
1153  return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';
1154 }
1155
1156 function isNode(node) {
1157  // eslint-disable-next-line
1158  if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
1159   return node instanceof HTMLElement;
1160  }
1161
1162  return node && (node.nodeType === 1 || node.nodeType === 11);
1163 }
1164
1165 function extend() {
1166  const to = Object(arguments.length <= 0 ? undefined : arguments[0]);
1167  const noExtend = ['__proto__', 'constructor', 'prototype'];
1168
1169  for (let i = 1; i < arguments.length; i += 1) {
1170   const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
1171
1172   if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
1173    const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);
1174
1175    for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
1176     const nextKey = keysArray[nextIndex];
1177     const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
1178
1179     if (desc !== undefined && desc.enumerable) {
1180      if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1181       if (nextSource[nextKey].__swiper__) {
1182        to[nextKey] = nextSource[nextKey];
1183       } else {
1184        extend(to[nextKey], nextSource[nextKey]);
1185       }
1186      } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1187       to[nextKey] = {};
1188
1189       if (nextSource[nextKey].__swiper__) {
1190        to[nextKey] = nextSource[nextKey];
1191       } else {
1192        extend(to[nextKey], nextSource[nextKey]);
1193       }
1194      } else {
1195       to[nextKey] = nextSource[nextKey];
1196      }
1197     }
1198    }
1199   }
1200  }
1201
1202  return to;
1203 }
1204
1205 function setCSSProperty(el, varName, varValue) {
1206  el.style.setProperty(varName, varValue);
1207 }
1208
1209 function animateCSSModeScroll(_ref) {
1210  let {
1211   swiper,
1212   targetPosition,
1213   side
1214  } = _ref;
1215  const window = getWindow();
1216  const startPosition = -swiper.translate;
1217  let startTime = null;
1218  let time;
1219  const duration = swiper.params.speed;
1220  swiper.wrapperEl.style.scrollSnapType = 'none';
1221  window.cancelAnimationFrame(swiper.cssModeFrameID);
1222  const dir = targetPosition > startPosition ? 'next' : 'prev';
1223
1224  const isOutOfBound = (current, target) => {
1225   return dir === 'next' && current >= target || dir === 'prev' && current <= target;
1226  };
1227
1228  const animate = () => {
1229   time = new Date().getTime();
1230
1231   if (startTime === null) {
1232    startTime = time;
1233   }
1234
1235   const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
1236   const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;
1237   let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
1238
1239   if (isOutOfBound(currentPosition, targetPosition)) {
1240    currentPosition = targetPosition;
1241   }
1242
1243   swiper.wrapperEl.scrollTo({
1244    [side]: currentPosition
1245   });
1246
1247   if (isOutOfBound(currentPosition, targetPosition)) {
1248    swiper.wrapperEl.style.overflow = 'hidden';
1249    swiper.wrapperEl.style.scrollSnapType = '';
1250    setTimeout(() => {
1251     swiper.wrapperEl.style.overflow = '';
1252     swiper.wrapperEl.scrollTo({
1253      [side]: currentPosition
1254     });
1255    });
1256    window.cancelAnimationFrame(swiper.cssModeFrameID);
1257    return;
1258   }
1259
1260   swiper.cssModeFrameID = window.requestAnimationFrame(animate);
1261  };
1262
1263  animate();
1264 }
1265
1266 let support;
1267
1268 function calcSupport() {
1269  const window = getWindow();
1270  const document = getDocument();
1271  return {
1272   smoothScroll: document.documentElement && 'scrollBehavior' in document.documentElement.style,
1273   touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch),
1274   passiveListener: function checkPassiveListener() {
1275    let supportsPassive = false;
1276
1277    try {
1278     const opts = Object.defineProperty({}, 'passive', {
1279      // eslint-disable-next-line
1280      get() {
1281       supportsPassive = true;
1282      }
1283
1284     });
1285     window.addEventListener('testPassiveListener', null, opts);
1286    } catch (e) {// No support
1287    }
1288
1289    return supportsPassive;
1290   }(),
1291   gestures: function checkGestures() {
1292    return 'ongesturestart' in window;
1293   }()
1294  };
1295 }
1296
1297 function getSupport() {
1298  if (!support) {
1299   support = calcSupport();
1300  }
1301
1302  return support;
1303 }
1304
1305 let deviceCached;
1306
1307 function calcDevice(_temp) {
1308  let {
1309   userAgent
1310  } = _temp === void 0 ? {} : _temp;

1311  const support = getSupport();
1312  const window = getWindow();
1313  const platform = window.navigator.platform;
1314  const ua = userAgent || window.navigator.userAgent;
1315  const device = {
1316   ios: false,
1317   android: false
1318  };
1319  const screenWidth = window.screen.width;
1320  const screenHeight = window.screen.height;
1321  const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
1322
1323  let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
1324  const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
1325  const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
1326  const windows = platform === 'Win32';
1327  let macos = platform === 'MacIntel'; // iPadOs 13 fix
1328
1329  const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
1330
1331  if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
1332   ipad = ua.match(/(Version)\/([\d.]+)/);
1333   if (!ipad) ipad = [0, 1, '13_0_0'];
1334   macos = false;
1335  } // Android
1336
1337
1338  if (android && !windows) {
1339   device.os = 'android';
1340   device.android = true;
1341  }
1342
1343  if (ipad || iphone || ipod) {
1344   device.os = 'ios';
1345   device.ios = true;
1346  } // Export object
1347
1348
1349  return device;
1350 }
1351
1352 function getDevice(overrides) {
1353  if (overrides === void 0) {
1354   overrides = {};
1355  }
1356
1357  if (!deviceCached) {
1358   deviceCached = calcDevice(overrides);
1359  }
1360
1361  return deviceCached;
1362 }
1363
1364 let browser;
1365
1366 function calcBrowser() {
1367  const window = getWindow();
1368
1369  function isSafari() {
1370   const ua = window.navigator.userAgent.toLowerCase();
1371   return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
1372  }
1373
1374  return {
1375   isSafari: isSafari(),
1376   isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)
1377  };
1378 }
1379
1380 function getBrowser() {
1381  if (!browser) {
1382   browser = calcBrowser();
1383  }
1384
1385  return browser;
1386 }
1387
1388 function Resize(_ref) {
1389  let {
1390   swiper,
1391   on,
1392   emit
1393  } = _ref;
1394  const window = getWindow();
1395  let observer = null;
1396  let animationFrame = null;
1397
1398  const resizeHandler = () => {
1399   if (!swiper || swiper.destroyed || !swiper.initialized) return;
1400   emit('beforeResize');
1401   emit('resize');
1402  };
1403
1404  const createObserver = () => {
1405   if (!swiper || swiper.destroyed || !swiper.initialized) return;
1406   observer = new ResizeObserver(entries => {
1407    animationFrame = window.requestAnimationFrame(() => {
1408     const {
1409      width,
1410      height
1411     } = swiper;
1412     let newWidth = width;
1413     let newHeight = height;
1414     entries.forEach(_ref2 => {
1415      let {
1416       contentBoxSize,
1417       contentRect,
1418       target
1419      } = _ref2;
1420      if (target && target !== swiper.el) return;
1421      newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
1422      newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
1423     });
1424
1425     if (newWidth !== width || newHeight !== height) {
1426      resizeHandler();
1427     }
1428    });
1429   });
1430   observer.observe(swiper.el);
1431  };
1432
1433  const removeObserver = () => {
1434   if (animationFrame) {
1435    window.cancelAnimationFrame(animationFrame);
1436   }
1437
1438   if (observer && observer.unobserve && swiper.el) {
1439    observer.unobserve(swiper.el);
1440    observer = null;
1441   }
1442  };
1443
1444  const orientationChangeHandler = () => {
1445   if (!swiper || swiper.destroyed || !swiper.initialized) return;
1446   emit('orientationchange');
1447  };
1448
1449  on('init', () => {
1450   if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
1451    createObserver();
1452    return;
1453   }
1454
1455   window.addEventListener('resize', resizeHandler);
1456   window.addEventListener('orientationchange', orientationChangeHandler);
1457  });
1458  on('destroy', () => {
1459   removeObserver();
1460   window.removeEventListener('resize', resizeHandler);
1461   window.removeEventListener('orientationchange', orientationChangeHandler);
1462  });
1463 }
1464
1465 function Observer(_ref) {
1466  let {
1467   swiper,
1468   extendParams,
1469   on,
1470   emit
1471  } = _ref;
1472  const observers = [];
1473  const window = getWindow();
1474
1475  const attach = function (target, options) {
1476   if (options === void 0) {
1477    options = {};
1478   }
1479
1480   const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
1481   const observer = new ObserverFunc(mutations => {
1482    // The observerUpdate event should only be triggered
1483    // once despite the number of mutations.  Additional
1484    // triggers are redundant and are very costly
1485    if (mutations.length === 1) {
1486     emit('observerUpdate', mutations[0]);
1487     return;
1488    }
1489
1490    const observerUpdate = function observerUpdate() {
1491     emit('observerUpdate', mutations[0]);
1492    };
1493
1494    if (window.requestAnimationFrame) {
1495     window.requestAnimationFrame(observerUpdate);
1496    } else {
1497     window.setTimeout(observerUpdate, 0);
1498    }
1499   });
1500   observer.observe(target, {
1501    attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
1502    childList: typeof options.childList === 'undefined' ? true : options.childList,
1503    characterData: typeof options.characterData === 'undefined' ? true : options.characterData
1504   });
1505   observers.push(observer);
1506  };
1507
1508  const init = () => {
1509   if (!swiper.params.observer) return;
1510
1511   if (swiper.params.observeParents) {
1512    const containerParents = swiper.$el.parents();
1513
1514    for (let i = 0; i < containerParents.length; i += 1) {
1515     attach(containerParents[i]);
1516    }
1517   } // Observe container
1518
1519
1520   attach(swiper.$el[0], {
1521    childList: swiper.params.observeSlideChildren
1522   }); // Observe wrapper
1523
1524   attach(swiper.$wrapperEl[0], {
1525    attributes: false
1526   });
1527  };
1528
1529  const destroy = () => {

1530   observers.forEach(observer => {
1531    observer.disconnect();
1532   });
1533   observers.splice(0, observers.length);
1534  };
1535
1536  extendParams({
1537   observer: false,
1538   observeParents: false,
1539   observeSlideChildren: false
1540  });
1541  on('init', init);
1542  on('destroy', destroy);
1543 }
1544
1545 /* eslint-disable no-underscore-dangle */
1546 var eventsEmitter = {
1547  on(events, handler, priority) {
1548   const self = this;
1549   if (!self.eventsListeners || self.destroyed) return self;
1550   if (typeof handler !== 'function') return self;
1551   const method = priority ? 'unshift' : 'push';
1552   events.split(' ').forEach(event => {
1553    if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
1554    self.eventsListeners[event][method](handler);
1555   });
1556   return self;
1557  },
1558
1559  once(events, handler, priority) {
1560   const self = this;
1561   if (!self.eventsListeners || self.destroyed) return self;
1562   if (typeof handler !== 'function') return self;
1563
1564   function onceHandler() {
1565    self.off(events, onceHandler);
1566
1567    if (onceHandler.__emitterProxy) {
1568     delete onceHandler.__emitterProxy;
1569    }
1570
1571    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1572     args[_key] = arguments[_key];
1573    }
1574
1575    handler.apply(self, args);
1576   }
1577
1578   onceHandler.__emitterProxy = handler;
1579   return self.on(events, onceHandler, priority);
1580  },
1581
1582  onAny(handler, priority) {
1583   const self = this;
1584   if (!self.eventsListeners || self.destroyed) return self;
1585   if (typeof handler !== 'function') return self;
1586   const method = priority ? 'unshift' : 'push';
1587
1588   if (self.eventsAnyListeners.indexOf(handler) < 0) {
1589    self.eventsAnyListeners[method](handler);
1590   }
1591
1592   return self;
1593  },
1594
1595  offAny(handler) {
1596   const self = this;
1597   if (!self.eventsListeners || self.destroyed) return self;
1598   if (!self.eventsAnyListeners) return self;
1599   const index = self.eventsAnyListeners.indexOf(handler);
1600
1601   if (index >= 0) {
1602    self.eventsAnyListeners.splice(index, 1);
1603   }
1604
1605   return self;
1606  },
1607
1608  off(events, handler) {
1609   const self = this;
1610   if (!self.eventsListeners || self.destroyed) return self;
1611   if (!self.eventsListeners) return self;
1612   events.split(' ').forEach(event => {
1613    if (typeof handler === 'undefined') {
1614     self.eventsListeners[event] = [];
1615    } else if (self.eventsListeners[event]) {
1616     self.eventsListeners[event].forEach((eventHandler, index) => {
1617      if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
1618       self.eventsListeners[event].splice(index, 1);
1619      }
1620     });
1621    }
1622   });
1623   return self;
1624  },
1625
1626  emit() {
1627   const self = this;
1628   if (!self.eventsListeners || self.destroyed) return self;
1629   if (!self.eventsListeners) return self;
1630   let events;
1631   let data;
1632   let context;
1633
1634   for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
1635    args[_key2] = arguments[_key2];
1636   }
1637
1638   if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1639    events = args[0];
1640    data = args.slice(1, args.length);
1641    context = self;
1642   } else {
1643    events = args[0].events;
1644    data = args[0].data;
1645    context = args[0].context || self;
1646   }
1647
1648   data.unshift(context);
1649   const eventsArray = Array.isArray(events) ? events : events.split(' ');
1650   eventsArray.forEach(event => {
1651    if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
1652     self.eventsAnyListeners.forEach(eventHandler => {
1653      eventHandler.apply(context, [event, ...data]);
1654     });
1655    }
1656
1657    if (self.eventsListeners && self.eventsListeners[event]) {
1658     self.eventsListeners[event].forEach(eventHandler => {
1659      eventHandler.apply(context, data);
1660     });
1661    }
1662   });
1663   return self;
1664  }
1665
1666 };
1667
1668 function updateSize() {
1669  const swiper = this;
1670  let width;
1671  let height;
1672  const $el = swiper.$el;
1673
1674  if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
1675   width = swiper.params.width;
1676  } else {
1677   width = $el[0].clientWidth;
1678  }
1679
1680  if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
1681   height = swiper.params.height;
1682  } else {
1683   height = $el[0].clientHeight;
1684  }
1685
1686  if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
1687   return;
1688  } // Subtract paddings
1689
1690
1691  width = width - parseInt($el.css('padding-left') || 0, 10) - parseInt($el.css('padding-right') || 0, 10);
1692  height = height - parseInt($el.css('padding-top') || 0, 10) - parseInt($el.css('padding-bottom') || 0, 10);
1693  if (Number.isNaN(width)) width = 0;
1694  if (Number.isNaN(height)) height = 0;
1695  Object.assign(swiper, {
1696   width,
1697   height,
1698   size: swiper.isHorizontal() ? width : height
1699  });
1700 }
1701
1702 function updateSlides() {
1703  const swiper = this;
1704
1705  function getDirectionLabel(property) {
1706   if (swiper.isHorizontal()) {
1707    return property;
1708   } // prettier-ignore
1709
1710
1711   return {
1712    'width': 'height',
1713    'margin-top': 'margin-left',
1714    'margin-bottom ': 'margin-right',
1715    'margin-left': 'margin-top',
1716    'margin-right': 'margin-bottom',
1717    'padding-left': 'padding-top',
1718    'padding-right': 'padding-bottom',
1719    'marginRight': 'marginBottom'
1720   }[property];
1721  }
1722
1723  function getDirectionPropertyValue(node, label) {
1724   return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);
1725  }
1726
1727  const params = swiper.params;
1728  const {
1729   $wrapperEl,
1730   size: swiperSize,
1731   rtlTranslate: rtl,
1732   wrongRTL
1733  } = swiper;
1734  const isVirtual = swiper.virtual && params.virtual.enabled;
1735  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1736  const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);
1737  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1738  let snapGrid = [];
1739  const slidesGrid = [];
1740  const slidesSizesGrid = [];
1741  let offsetBefore = params.slidesOffsetBefore;
1742
1743  if (typeof offsetBefore === 'function') {

1744   offsetBefore = params.slidesOffsetBefore.call(swiper);
1745  }
1746
1747  let offsetAfter = params.slidesOffsetAfter;
1748
1749  if (typeof offsetAfter === 'function') {
1750   offsetAfter = params.slidesOffsetAfter.call(swiper);
1751  }
1752
1753  const previousSnapGridLength = swiper.snapGrid.length;
1754  const previousSlidesGridLength = swiper.slidesGrid.length;
1755  let spaceBetween = params.spaceBetween;
1756  let slidePosition = -offsetBefore;
1757  let prevSlideSize = 0;
1758  let index = 0;
1759
1760  if (typeof swiperSize === 'undefined') {
1761   return;
1762  }
1763
1764  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1765   spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
1766  }
1767
1768  swiper.virtualSize = -spaceBetween; // reset margins
1769
1770  if (rtl) slides.css({
1771   marginLeft: '',
1772   marginBottom: '',
1773   marginTop: ''
1774  });else slides.css({
1775   marginRight: '',
1776   marginBottom: '',
1777   marginTop: ''
1778  }); // reset cssMode offsets
1779
1780  if (params.centeredSlides && params.cssMode) {
1781   setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', '');
1782   setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', '');
1783  }
1784
1785  const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
1786
1787  if (gridEnabled) {
1788   swiper.grid.initSlides(slidesLength);
1789  } // Calc slides
1790
1791
1792  let slideSize;
1793  const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
1794   return typeof params.breakpoints[key].slidesPerView !== 'undefined';
1795  }).length > 0;
1796
1797  for (let i = 0; i < slidesLength; i += 1) {
1798   slideSize = 0;
1799   const slide = slides.eq(i);
1800
1801   if (gridEnabled) {
1802    swiper.grid.updateSlide(i, slide, slidesLength, getDirectionLabel);
1803   }
1804
1805   if (slide.css('display') === 'none') continue; // eslint-disable-line
1806
1807   if (params.slidesPerView === 'auto') {
1808    if (shouldResetSlideSize) {
1809     slides[i].style[getDirectionLabel('width')] = ``;
1810    }
1811
1812    const slideStyles = getComputedStyle(slide[0]);
1813    const currentTransform = slide[0].style.transform;
1814    const currentWebKitTransform = slide[0].style.webkitTransform;
1815
1816    if (currentTransform) {
1817     slide[0].style.transform = 'none';
1818    }
1819
1820    if (currentWebKitTransform) {
1821     slide[0].style.webkitTransform = 'none';
1822    }
1823
1824    if (params.roundLengths) {
1825     slideSize = swiper.isHorizontal() ? slide.outerWidth(true) : slide.outerHeight(true);
1826    } else {
1827     // eslint-disable-next-line
1828     const width = getDirectionPropertyValue(slideStyles, 'width');
1829     const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
1830     const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
1831     const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
1832     const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
1833     const boxSizing = slideStyles.getPropertyValue('box-sizing');
1834
1835     if (boxSizing && boxSizing === 'border-box') {
1836      slideSize = width + marginLeft + marginRight;
1837     } else {
1838      const {
1839       clientWidth,
1840       offsetWidth
1841      } = slide[0];
1842      slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1843     }
1844    }
1845
1846    if (currentTransform) {
1847     slide[0].style.transform = currentTransform;
1848    }
1849
1850    if (currentWebKitTransform) {
1851     slide[0].style.webkitTransform = currentWebKitTransform;
1852    }
1853
1854    if (params.roundLengths) slideSize = Math.floor(slideSize);
1855   } else {
1856    slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
1857    if (params.roundLengths) slideSize = Math.floor(slideSize);
1858
1859    if (slides[i]) {
1860     slides[i].style[getDirectionLabel('width')] = `${slideSize}px`;
1861    }
1862   }
1863
1864   if (slides[i]) {
1865    slides[i].swiperSlideSize = slideSize;
1866   }
1867
1868   slidesSizesGrid.push(slideSize);
1869
1870   if (params.centeredSlides) {
1871    slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1872    if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1873    if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1874    if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
1875    if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1876    if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1877    slidesGrid.push(slidePosition);
1878   } else {
1879    if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1880    if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1881    slidesGrid.push(slidePosition);
1882    slidePosition = slidePosition + slideSize + spaceBetween;
1883   }
1884
1885   swiper.virtualSize += slideSize + spaceBetween;
1886   prevSlideSize = slideSize;
1887   index += 1;
1888  }
1889
1890  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1891
1892  if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1893   $wrapperEl.css({
1894    width: `${swiper.virtualSize + params.spaceBetween}px`
1895   });
1896  }
1897
1898  if (params.setWrapperSize) {
1899   $wrapperEl.css({
1900    [getDirectionLabel('width')]: `${swiper.virtualSize + params.spaceBetween}px`
1901   });
1902  }
1903
1904  if (gridEnabled) {
1905   swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);
1906  } // Remove last grid elements depending on width
1907
1908
1909  if (!params.centeredSlides) {
1910   const newSlidesGrid = [];
1911
1912   for (let i = 0; i < snapGrid.length; i += 1) {
1913    let slidesGridItem = snapGrid[i];
1914    if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1915
1916    if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1917     newSlidesGrid.push(slidesGridItem);
1918    }
1919   }
1920
1921   snapGrid = newSlidesGrid;
1922
1923   if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1924    snapGrid.push(swiper.virtualSize - swiperSize);
1925   }
1926  }
1927
1928  if (snapGrid.length === 0) snapGrid = [0];
1929
1930  if (params.spaceBetween !== 0) {
1931   const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');
1932   slides.filter((_, slideIndex) => {
1933    if (!params.cssMode) return true;
1934
1935    if (slideIndex === slides.length - 1) {
1936     return false;
1937    }
1938
1939    return true;
1940   }).css({
1941    [key]: `${spaceBetween}px`
1942   });
1943  }
1944
1945  if (params.centeredSlides && params.centeredSlidesBounds) {
1946   let allSlidesSize = 0;
1947   slidesSizesGrid.forEach(slideSizeValue => {
1948    allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1949   });
1950   allSlidesSize -= params.spaceBetween;
1951   const maxSnap = allSlidesSize - swiperSize;
1952   snapGrid = snapGrid.map(snap => {
1953    if (snap < 0) return -offsetBefore;
1954    if (snap > maxSnap) return maxSnap + offsetAfter;
1955    return snap;
1956   });
1957  }
1958
1959  if (params.centerInsufficientSlides) {
1960   let allSlidesSize = 0;

1961   slidesSizesGrid.forEach(slideSizeValue => {
1962    allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1963   });
1964   allSlidesSize -= params.spaceBetween;
1965
1966   if (allSlidesSize < swiperSize) {
1967    const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1968    snapGrid.forEach((snap, snapIndex) => {
1969     snapGrid[snapIndex] = snap - allSlidesOffset;
1970    });
1971    slidesGrid.forEach((snap, snapIndex) => {
1972     slidesGrid[snapIndex] = snap + allSlidesOffset;
1973    });
1974   }
1975  }
1976
1977  Object.assign(swiper, {
1978   slides,
1979   snapGrid,
1980   slidesGrid,
1981   slidesSizesGrid
1982  });
1983
1984  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1985   setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
1986   setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1987   const addToSnapGrid = -swiper.snapGrid[0];
1988   const addToSlidesGrid = -swiper.slidesGrid[0];
1989   swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1990   swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1991  }
1992
1993  if (slidesLength !== previousSlidesLength) {
1994   swiper.emit('slidesLengthChange');
1995  }
1996
1997  if (snapGrid.length !== previousSnapGridLength) {
1998   if (swiper.params.watchOverflow) swiper.checkOverflow();
1999   swiper.emit('snapGridLengthChange');
2000  }
2001
2002  if (slidesGrid.length !== previousSlidesGridLength) {
2003   swiper.emit('slidesGridLengthChange');
2004  }
2005
2006  if (params.watchSlidesProgress) {
2007   swiper.updateSlidesOffset();
2008  }
2009
2010  if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
2011   const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
2012   const hasClassBackfaceClassAdded = swiper.$el.hasClass(backFaceHiddenClass);
2013
2014   if (slidesLength <= params.maxBackfaceHiddenSlides) {
2015    if (!hasClassBackfaceClassAdded) swiper.$el.addClass(backFaceHiddenClass);
2016   } else if (hasClassBackfaceClassAdded) {
2017    swiper.$el.removeClass(backFaceHiddenClass);
2018   }
2019  }
2020 }
2021
2022 function updateAutoHeight(speed) {
2023  const swiper = this;
2024  const activeSlides = [];
2025  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2026  let newHeight = 0;
2027  let i;
2028
2029  if (typeof speed === 'number') {
2030   swiper.setTransition(speed);
2031  } else if (speed === true) {
2032   swiper.setTransition(swiper.params.speed);
2033  }
2034
2035  const getSlideByIndex = index => {
2036   if (isVirtual) {
2037    return swiper.slides.filter(el => parseInt(el.getAttribute('data-swiper-slide-index'), 10) === index)[0];
2038   }
2039
2040   return swiper.slides.eq(index)[0];
2041  }; // Find slides currently in view
2042
2043
2044  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
2045   if (swiper.params.centeredSlides) {
2046    (swiper.visibleSlides || $([])).each(slide => {
2047     activeSlides.push(slide);
2048    });
2049   } else {
2050    for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
2051     const index = swiper.activeIndex + i;
2052     if (index > swiper.slides.length && !isVirtual) break;
2053     activeSlides.push(getSlideByIndex(index));
2054    }
2055   }
2056  } else {
2057   activeSlides.push(getSlideByIndex(swiper.activeIndex));
2058  } // Find new height from highest slide in view
2059
2060
2061  for (i = 0; i < activeSlides.length; i += 1) {
2062   if (typeof activeSlides[i] !== 'undefined') {
2063    const height = activeSlides[i].offsetHeight;
2064    newHeight = height > newHeight ? height : newHeight;
2065   }
2066  } // Update Height
2067
2068
2069  if (newHeight || newHeight === 0) swiper.$wrapperEl.css('height', `${newHeight}px`);
2070 }
2071
2072 function updateSlidesOffset() {
2073  const swiper = this;
2074  const slides = swiper.slides;
2075
2076  for (let i = 0; i < slides.length; i += 1) {
2077   slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;
2078  }
2079 }
2080
2081 function updateSlidesProgress(translate) {
2082  if (translate === void 0) {
2083   translate = this && this.translate || 0;
2084  }
2085
2086  const swiper = this;
2087  const params = swiper.params;
2088  const {
2089   slides,
2090   rtlTranslate: rtl,
2091   snapGrid
2092  } = swiper;
2093  if (slides.length === 0) return;
2094  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
2095  let offsetCenter = -translate;
2096  if (rtl) offsetCenter = translate; // Visible Slides
2097
2098  slides.removeClass(params.slideVisibleClass);
2099  swiper.visibleSlidesIndexes = [];
2100  swiper.visibleSlides = [];
2101
2102  for (let i = 0; i < slides.length; i += 1) {
2103   const slide = slides[i];
2104   let slideOffset = slide.swiperSlideOffset;
2105
2106   if (params.cssMode && params.centeredSlides) {
2107    slideOffset -= slides[0].swiperSlideOffset;
2108   }
2109
2110   const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2111   const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2112   const slideBefore = -(offsetCenter - slideOffset);
2113   const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
2114   const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
2115
2116   if (isVisible) {
2117    swiper.visibleSlides.push(slide);
2118    swiper.visibleSlidesIndexes.push(i);
2119    slides.eq(i).addClass(params.slideVisibleClass);
2120   }
2121
2122   slide.progress = rtl ? -slideProgress : slideProgress;
2123   slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
2124  }
2125
2126  swiper.visibleSlides = $(swiper.visibleSlides);
2127 }
2128
2129 function updateProgress(translate) {
2130  const swiper = this;
2131
2132  if (typeof translate === 'undefined') {
2133   const multiplier = swiper.rtlTranslate ? -1 : 1; // eslint-disable-next-line
2134
2135   translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
2136  }
2137
2138  const params = swiper.params;
2139  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2140  let {
2141   progress,
2142   isBeginning,
2143   isEnd
2144  } = swiper;
2145  const wasBeginning = isBeginning;
2146  const wasEnd = isEnd;
2147
2148  if (translatesDiff === 0) {
2149   progress = 0;
2150   isBeginning = true;
2151   isEnd = true;
2152  } else {
2153   progress = (translate - swiper.minTranslate()) / translatesDiff;
2154   isBeginning = progress <= 0;
2155   isEnd = progress >= 1;
2156  }
2157
2158  Object.assign(swiper, {
2159   progress,
2160   isBeginning,
2161   isEnd
2162  });
2163  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
2164
2165  if (isBeginning && !wasBeginning) {
2166   swiper.emit('reachBeginning toEdge');
2167  }
2168
2169  if (isEnd && !wasEnd) {
2170   swiper.emit('reachEnd toEdge');
2171  }
2172
2173  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
2174   swiper.emit('fromEdge');
2175  }
2176
2177  swiper.emit('progress', progress);
2178 }
2179
2180 function updateSlidesClasses() {
2181  const swiper = this;
2182  const {
2183   slides,
2184   params,
2185   $wrapperEl,
2186   activeIndex,
2187   realIndex
2188  } = swiper;
2189  const isVirtual = swiper.virtual && params.virtual.enabled;
2190  slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);
2191  let activeSlide;
2192
2193  if (isVirtual) {
2194   activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index="${activeIndex}"]`);
2195  } else {
2196   activeSlide = slides.eq(activeIndex);
2197  } // Active classes
2198
2199
2200  activeSlide.addClass(params.slideActiveClass);
2201
2202  if (params.loop) {
2203   // Duplicate to all looped slides
2204   if (activeSlide.hasClass(params.slideDuplicateClass)) {
2205    $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
2206   } else {
2207    $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
2208   }
2209  } // Next Slide
2210
2211
2212  let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);
2213
2214  if (params.loop && nextSlide.length === 0) {
2215   nextSlide = slides.eq(0);
2216   nextSlide.addClass(params.slideNextClass);
2217  } // Prev Slide
2218
2219
2220  let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);
2221
2222  if (params.loop && prevSlide.length === 0) {
2223   prevSlide = slides.eq(-1);
2224   prevSlide.addClass(params.slidePrevClass);
2225  }
2226
2227  if (params.loop) {
2228   // Duplicate to all looped slides
2229   if (nextSlide.hasClass(params.slideDuplicateClass)) {
2230    $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicateNextClass);
2231   } else {
2232    $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicateNextClass);
2233   }
2234
2235   if (prevSlide.hasClass(params.slideDuplicateClass)) {
2236    $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicatePrevClass);
2237   } else {
2238    $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicatePrevClass);
2239   }
2240  }
2241
2242  swiper.emitSlidesClasses();
2243 }
2244
2245 function updateActiveIndex(newActiveIndex) {
2246  const swiper = this;
2247  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2248  const {
2249   slidesGrid,
2250   snapGrid,
2251   params,
2252   activeIndex: previousIndex,
2253   realIndex: previousRealIndex,
2254   snapIndex: previousSnapIndex
2255  } = swiper;
2256  let activeIndex = newActiveIndex;
2257  let snapIndex;
2258
2259  if (typeof activeIndex === 'undefined') {
2260   for (let i = 0; i < slidesGrid.length; i += 1) {
2261    if (typeof slidesGrid[i + 1] !== 'undefined') {
2262     if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
2263      activeIndex = i;
2264     } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
2265      activeIndex = i + 1;
2266     }
2267    } else if (translate >= slidesGrid[i]) {
2268     activeIndex = i;
2269    }
2270   } // Normalize slideIndex
2271
2272
2273   if (params.normalizeSlideIndex) {
2274    if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
2275   }
2276  }
2277
2278  if (snapGrid.indexOf(translate) >= 0) {
2279   snapIndex = snapGrid.indexOf(translate);
2280  } else {
2281   const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
2282   snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
2283  }
2284
2285  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2286
2287  if (activeIndex === previousIndex) {
2288   if (snapIndex !== previousSnapIndex) {
2289    swiper.snapIndex = snapIndex;
2290    swiper.emit('snapIndexChange');
2291   }
2292
2293   return;
2294  } // Get real index
2295
2296
2297  const realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);
2298  Object.assign(swiper, {
2299   snapIndex,
2300   realIndex,
2301   previousIndex,
2302   activeIndex
2303  });
2304  swiper.emit('activeIndexChange');
2305  swiper.emit('snapIndexChange');
2306
2307  if (previousRealIndex !== realIndex) {
2308   swiper.emit('realIndexChange');
2309  }
2310
2311  if (swiper.initialized || swiper.params.runCallbacksOnInit) {
2312   swiper.emit('slideChange');
2313  }
2314 }
2315
2316 function updateClickedSlide(e) {
2317  const swiper = this;
2318  const params = swiper.params;
2319  const slide = $(e).closest(`.${params.slideClass}`)[0];
2320  let slideFound = false;
2321  let slideIndex;
2322
2323  if (slide) {
2324   for (let i = 0; i < swiper.slides.length; i += 1) {
2325    if (swiper.slides[i] === slide) {
2326     slideFound = true;
2327     slideIndex = i;
2328     break;
2329    }
2330   }
2331  }
2332
2333  if (slide && slideFound) {
2334   swiper.clickedSlide = slide;
2335
2336   if (swiper.virtual && swiper.params.virtual.enabled) {
2337    swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);
2338   } else {
2339    swiper.clickedIndex = slideIndex;
2340   }
2341  } else {
2342   swiper.clickedSlide = undefined;
2343   swiper.clickedIndex = undefined;
2344   return;
2345  }
2346
2347  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
2348   swiper.slideToClickedSlide();
2349  }
2350 }
2351
2352 var update = {
2353  updateSize,
2354  updateSlides,
2355  updateAutoHeight,
2356  updateSlidesOffset,
2357  updateSlidesProgress,
2358  updateProgress,
2359  updateSlidesClasses,
2360  updateActiveIndex,
2361  updateClickedSlide
2362 };
2363
2364 function getSwiperTranslate(axis) {
2365  if (axis === void 0) {
2366   axis = this.isHorizontal() ? 'x' : 'y';
2367  }
2368
2369  const swiper = this;
2370  const {
2371   params,
2372   rtlTranslate: rtl,
2373   translate,
2374   $wrapperEl
2375  } = swiper;
2376
2377  if (params.virtualTranslate) {
2378   return rtl ? -translate : translate;
2379  }
2380
2381  if (params.cssMode) {
2382   return translate;
2383  }
2384
2385  let currentTranslate = getTranslate($wrapperEl[0], axis);
2386  if (rtl) currentTranslate = -currentTranslate;
2387  return currentTranslate || 0;
2388 }
2389
2390 function setTranslate(translate, byController) {
2391  const swiper = this;
2392  const {
2393   rtlTranslate: rtl,
2394   params,
2395   $wrapperEl,
2396   wrapperEl,
2397   progress
2398  } = swiper;
2399  let x = 0;
2400  let y = 0;
2401  const z = 0;
2402
2403  if (swiper.isHorizontal()) {
2404   x = rtl ? -translate : translate;
2405  } else {
2406   y = translate;
2407  }
2408
2409  if (params.roundLengths) {
2410   x = Math.floor(x);
2411   y = Math.floor(y);
2412  }
2413
2414  if (params.cssMode) {
2415   wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
2416  } else if (!params.virtualTranslate) {
2417   $wrapperEl.transform(`translate3d(${x}px, ${y}px, ${z}px)`);
2418  }
2419
2420  swiper.previousTranslate = swiper.translate;
2421  swiper.translate = swiper.isHorizontal() ? x : y; // Check if we need to update progress
2422
2423  let newProgress;
2424  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2425
2426  if (translatesDiff === 0) {
2427   newProgress = 0;
2428  } else {
2429   newProgress = (translate - swiper.minTranslate()) / translatesDiff;
2430  }
2431
2432  if (newProgress !== progress) {
2433   swiper.updateProgress(translate);
2434  }
2435
2436  swiper.emit('setTranslate', swiper.translate, byController);
2437 }
2438
2439 function minTranslate() {
2440  return -this.snapGrid[0];
2441 }
2442
2443 function maxTranslate() {
2444  return -this.snapGrid[this.snapGrid.length - 1];
2445 }
2446
2447 function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
2448  if (translate === void 0) {
2449   translate = 0;
2450  }
2451
2452  if (speed === void 0) {
2453   speed = this.params.speed;
2454  }
2455
2456  if (runCallbacks === void 0) {
2457   runCallbacks = true;
2458  }
2459
2460  if (translateBounds === void 0) {
2461   translateBounds = true;
2462  }
2463
2464  const swiper = this;
2465  const {
2466   params,
2467   wrapperEl
2468  } = swiper;
2469
2470  if (swiper.animating && params.preventInteractionOnTransition) {
2471   return false;
2472  }
2473
2474  const minTranslate = swiper.minTranslate();
2475  const maxTranslate = swiper.maxTranslate();
2476  let newTranslate;
2477  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate; // Update progress
2478
2479  swiper.updateProgress(newTranslate);
2480
2481  if (params.cssMode) {
2482   const isH = swiper.isHorizontal();
2483
2484   if (speed === 0) {
2485    wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
2486   } else {
2487    if (!swiper.support.smoothScroll) {
2488     animateCSSModeScroll({
2489      swiper,
2490      targetPosition: -newTranslate,
2491      side: isH ? 'left' : 'top'
2492     });
2493     return true;
2494    }
2495
2496    wrapperEl.scrollTo({
2497     [isH ? 'left' : 'top']: -newTranslate,
2498     behavior: 'smooth'
2499    });
2500   }
2501
2502   return true;
2503  }
2504
2505  if (speed === 0) {
2506   swiper.setTransition(0);
2507   swiper.setTranslate(newTranslate);
2508
2509   if (runCallbacks) {
2510    swiper.emit('beforeTransitionStart', speed, internal);
2511    swiper.emit('transitionEnd');
2512   }
2513  } else {
2514   swiper.setTransition(speed);
2515   swiper.setTranslate(newTranslate);
2516
2517   if (runCallbacks) {
2518    swiper.emit('beforeTransitionStart', speed, internal);
2519    swiper.emit('transitionStart');
2520   }
2521
2522   if (!swiper.animating) {
2523    swiper.animating = true;
2524
2525    if (!swiper.onTranslateToWrapperTransitionEnd) {
2526     swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
2527      if (!swiper || swiper.destroyed) return;
2528      if (e.target !== this) return;
2529      swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2530      swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2531      swiper.onTranslateToWrapperTransitionEnd = null;
2532      delete swiper.onTranslateToWrapperTransitionEnd;
2533
2534      if (runCallbacks) {
2535       swiper.emit('transitionEnd');
2536      }
2537     };
2538    }
2539
2540    swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2541    swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2542   }
2543  }
2544
2545  return true;
2546 }
2547
2548 var translate = {
2549  getTranslate: getSwiperTranslate,
2550  setTranslate,
2551  minTranslate,
2552  maxTranslate,
2553  translateTo
2554 };
2555
2556 function setTransition(duration, byController) {
2557  const swiper = this;
2558
2559  if (!swiper.params.cssMode) {
2560   swiper.$wrapperEl.transition(duration);
2561  }
2562
2563  swiper.emit('setTransition', duration, byController);
2564 }
2565
2566 function transitionEmit(_ref) {
2567  let {
2568   swiper,
2569   runCallbacks,
2570   direction,
2571   step
2572  } = _ref;
2573  const {
2574   activeIndex,
2575   previousIndex
2576  } = swiper;
2577  let dir = direction;
2578
2579  if (!dir) {
2580   if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
2581  }
2582
2583  swiper.emit(`transition${step}`);
2584
2585  if (runCallbacks && activeIndex !== previousIndex) {
2586   if (dir === 'reset') {
2587    swiper.emit(`slideResetTransition${step}`);
2588    return;
2589   }
2590
2591   swiper.emit(`slideChangeTransition${step}`);
2592
2593   if (dir === 'next') {
2594    swiper.emit(`slideNextTransition${step}`);
2595   } else {
2596    swiper.emit(`slidePrevTransition${step}`);
2597   }
2598  }
2599 }
2600
2601 function transitionStart(runCallbacks, direction) {
2602  if (runCallbacks === void 0) {
2603   runCallbacks = true;
2604  }
2605
2606  const swiper = this;
2607  const {
2608   params
2609  } = swiper;
2610  if (params.cssMode) return;
2611
2612  if (params.autoHeight) {
2613   swiper.updateAutoHeight();
2614  }
2615
2616  transitionEmit({
2617   swiper,
2618   runCallbacks,
2619   direction,
2620   step: 'Start'
2621  });
2622 }
2623
2624 function transitionEnd(runCallbacks, direction) {
2625  if (runCallbacks === void 0) {
2626   runCallbacks = true;
2627  }
2628
2629  const swiper = this;
2630  const {
2631   params
2632  } = swiper;
2633  swiper.animating = false;
2634  if (params.cssMode) return;
2635  swiper.setTransition(0);
2636  transitionEmit({
2637   swiper,
2638   runCallbacks,
2639   direction,
2640   step: 'End'
2641  });
2642 }
2643
2644 var transition = {
2645  setTransition,
2646  transitionStart,
2647  transitionEnd
2648 };
2649
2650 function slideTo(index, speed, runCallbacks, internal, initial) {
2651  if (index === void 0) {
2652   index = 0;
2653  }
2654
2655  if (speed === void 0) {
2656   speed = this.params.speed;
2657  }
2658
2659  if (runCallbacks === void 0) {
2660   runCallbacks = true;
2661  }
2662
2663  if (typeof index !== 'number' && typeof index !== 'string') {
2664   throw new Error(`The 'index' argument cannot have type other than 'number' or 'string'. [${typeof index}] given.`);
2665  }
2666
2667  if (typeof index === 'string') {
2668   /**
2669    * The `index` argument converted from `string` to `number`.
2670    * @type {number}
2671    */
2672   const indexAsNumber = parseInt(index, 10);
2673   /**
2674    * Determines whether the `index` argument is a valid `number`
2675    * after being converted from the `string` type.
2676    * @type {boolean}
2677    */
2678
2679   const isValidNumber = isFinite(indexAsNumber);
2680
2681   if (!isValidNumber) {
2682    throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);
2683   } // Knowing that the converted `index` is a valid number,
2684   // we can update the original argument's value.
2685
2686
2687   index = indexAsNumber;
2688  }
2689
2690  const swiper = this;
2691  let slideIndex = index;
2692  if (slideIndex < 0) slideIndex = 0;
2693  const {
2694   params,
2695   snapGrid,
2696   slidesGrid,
2697   previousIndex,
2698   activeIndex,
2699   rtlTranslate: rtl,
2700   wrapperEl,
2701   enabled
2702  } = swiper;
2703
2704  if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
2705   return false;
2706  }
2707
2708  const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
2709  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
2710  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2711  const translate = -snapGrid[snapIndex]; // Normalize slideIndex
2712
2713  if (params.normalizeSlideIndex) {
2714   for (let i = 0; i < slidesGrid.length; i += 1) {
2715    const normalizedTranslate = -Math.floor(translate * 100);
2716    const normalizedGrid = Math.floor(slidesGrid[i] * 100);
2717    const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
2718
2719    if (typeof slidesGrid[i + 1] !== 'undefined') {
2720     if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
2721      slideIndex = i;
2722     } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
2723      slideIndex = i + 1;
2724     }
2725    } else if (normalizedTranslate >= normalizedGrid) {
2726     slideIndex = i;
2727    }
2728   }
2729  } // Directions locks
2730
2731
2732  if (swiper.initialized && slideIndex !== activeIndex) {
2733   if (!swiper.allowSlideNext && translate < swiper.translate && translate < swiper.minTranslate()) {
2734    return false;
2735   }
2736
2737   if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
2738    if ((activeIndex || 0) !== slideIndex) return false;
2739   }
2740  }
2741
2742  if (slideIndex !== (previousIndex || 0) && runCallbacks) {
2743   swiper.emit('beforeSlideChangeStart');
2744  } // Update progress
2745
2746
2747  swiper.updateProgress(translate);
2748  let direction;
2749  if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset'; // Update Index
2750
2751  if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {
2752   swiper.updateActiveIndex(slideIndex); // Update Height
2753
2754   if (params.autoHeight) {
2755    swiper.updateAutoHeight();
2756   }
2757
2758   swiper.updateSlidesClasses();
2759
2760   if (params.effect !== 'slide') {
2761    swiper.setTranslate(translate);
2762   }
2763
2764   if (direction !== 'reset') {
2765    swiper.transitionStart(runCallbacks, direction);
2766    swiper.transitionEnd(runCallbacks, direction);
2767   }
2768
2769   return false;
2770  }
2771
2772  if (params.cssMode) {
2773   const isH = swiper.isHorizontal();
2774   const t = rtl ? translate : -translate;
2775
2776   if (speed === 0) {
2777    const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2778
2779    if (isVirtual) {
2780     swiper.wrapperEl.style.scrollSnapType = 'none';
2781     swiper._immediateVirtual = true;
2782    }
2783
2784    wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
2785
2786    if (isVirtual) {
2787     requestAnimationFrame(() => {
2788      swiper.wrapperEl.style.scrollSnapType = '';
2789      swiper._swiperImmediateVirtual = false;
2790     });
2791    }
2792   } else {
2793    if (!swiper.support.smoothScroll) {
2794     animateCSSModeScroll({
2795      swiper,
2796      targetPosition: t,
2797      side: isH ? 'left' : 'top'
2798     });
2799     return true;
2800    }
2801
2802    wrapperEl.scrollTo({
2803     [isH ? 'left' : 'top']: t,
2804     behavior: 'smooth'
2805    });
2806   }
2807
2808   return true;
2809  }
2810
2811  swiper.setTransition(speed);
2812  swiper.setTranslate(translate);
2813  swiper.updateActiveIndex(slideIndex);
2814  swiper.updateSlidesClasses();
2815  swiper.emit('beforeTransitionStart', speed, internal);
2816  swiper.transitionStart(runCallbacks, direction);
2817
2818  if (speed === 0) {
2819   swiper.transitionEnd(runCallbacks, direction);
2820  } else if (!swiper.animating) {
2821   swiper.animating = true;
2822
2823   if (!swiper.onSlideToWrapperTransitionEnd) {
2824    swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2825     if (!swiper || swiper.destroyed) return;
2826     if (e.target !== this) return;
2827     swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2828     swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2829     swiper.onSlideToWrapperTransitionEnd = null;
2830     delete swiper.onSlideToWrapperTransitionEnd;
2831     swiper.transitionEnd(runCallbacks, direction);
2832    };
2833   }
2834
2835   swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2836   swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2837  }
2838
2839  return true;
2840 }
2841
2842 function slideToLoop(index, speed, runCallbacks, internal) {
2843  if (index === void 0) {
2844   index = 0;
2845  }
2846
2847  if (speed === void 0) {
2848   speed = this.params.speed;
2849  }
2850
2851  if (runCallbacks === void 0) {
2852   runCallbacks = true;
2853  }
2854
2855  if (typeof index === 'string') {
2856   /**
2857    * The `index` argument converted from `string` to `number`.
2858    * @type {number}
2859    */
2860   const indexAsNumber = parseInt(index, 10);
2861   /**
2862    * Determines whether the `index` argument is a valid `number`
2863    * after being converted from the `string` type.
2864    * @type {boolean}
2865    */
2866
2867   const isValidNumber = isFinite(indexAsNumber);
2868
2869   if (!isValidNumber) {
2870    throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);
2871   } // Knowing that the converted `index` is a valid number,
2872   // we can update the original argument's value.
2873
2874
2875   index = indexAsNumber;
2876  }
2877
2878  const swiper = this;
2879  let newIndex = index;
2880
2881  if (swiper.params.loop) {
2882   newIndex += swiper.loopedSlides;
2883  }
2884
2885  return swiper.slideTo(newIndex, speed, runCallbacks, internal);
2886 }
2887
2888 /* eslint no-unused-vars: "off" */
2889 function slideNext(speed, runCallbacks, internal) {
2890  if (speed === void 0) {
2891   speed = this.params.speed;
2892  }
2893
2894  if (runCallbacks === void 0) {
2895   runCallbacks = true;
2896  }
2897
2898  const swiper = this;
2899  const {
2900   animating,
2901   enabled,
2902   params
2903  } = swiper;
2904  if (!enabled) return swiper;
2905  let perGroup = params.slidesPerGroup;
2906
2907  if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2908   perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
2909  }
2910
2911  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2912
2913  if (params.loop) {
2914   if (animating && params.loopPreventsSlide) return false;
2915   swiper.loopFix(); // eslint-disable-next-line
2916
2917   swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2918  }
2919
2920  if (params.rewind && swiper.isEnd) {
2921   return swiper.slideTo(0, speed, runCallbacks, internal);
2922  }
2923
2924  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2925 }
2926
2927 /* eslint no-unused-vars: "off" */
2928 function slidePrev(speed, runCallbacks, internal) {
2929  if (speed === void 0) {
2930   speed = this.params.speed;
2931  }
2932
2933  if (runCallbacks === void 0) {
2934   runCallbacks = true;
2935  }
2936
2937  const swiper = this;
2938  const {
2939   params,
2940   animating,
2941   snapGrid,
2942   slidesGrid,
2943   rtlTranslate,
2944   enabled
2945  } = swiper;
2946  if (!enabled) return swiper;
2947
2948  if (params.loop) {
2949   if (animating && params.loopPreventsSlide) return false;
2950   swiper.loopFix(); // eslint-disable-next-line
2951
2952   swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2953  }
2954
2955  const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2956
2957  function normalize(val) {
2958   if (val < 0) return -Math.floor(Math.abs(val));
2959   return Math.floor(val);
2960  }
2961
2962  const normalizedTranslate = normalize(translate);
2963  const normalizedSnapGrid = snapGrid.map(val => normalize(val));
2964  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2965
2966  if (typeof prevSnap === 'undefined' && params.cssMode) {
2967   let prevSnapIndex;
2968   snapGrid.forEach((snap, snapIndex) => {
2969    if (normalizedTranslate >= snap) {
2970     // prevSnap = snap;
2971     prevSnapIndex = snapIndex;
2972    }
2973   });
2974
2975   if (typeof prevSnapIndex !== 'undefined') {
2976    prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2977   }
2978  }
2979
2980  let prevIndex = 0;
2981
2982  if (typeof prevSnap !== 'undefined') {
2983   prevIndex = slidesGrid.indexOf(prevSnap);
2984   if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2985
2986   if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2987    prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2988    prevIndex = Math.max(prevIndex, 0);
2989   }
2990  }
2991
2992  if (params.rewind && swiper.isBeginning) {
2993   const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2994   return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2995  }
2996
2997  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2998 }
2999
3000 /* eslint no-unused-vars: "off" */
3001 function slideReset(speed, runCallbacks, internal) {
3002  if (speed === void 0) {
3003   speed = this.params.speed;
3004  }
3005
3006  if (runCallbacks === void 0) {
3007   runCallbacks = true;
3008  }
3009
3010  const swiper = this;
3011  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
3012 }
3013
3014 /* eslint no-unused-vars: "off" */
3015 function slideToClosest(speed, runCallbacks, internal, threshold) {
3016  if (speed === void 0) {
3017   speed = this.params.speed;
3018  }
3019
3020  if (runCallbacks === void 0) {
3021   runCallbacks = true;
3022  }
3023
3024  if (threshold === void 0) {
3025   threshold = 0.5;
3026  }
3027
3028  const swiper = this;
3029  let index = swiper.activeIndex;
3030  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
3031  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
3032  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
3033
3034  if (translate >= swiper.snapGrid[snapIndex]) {
3035   // The current translate is on or after the current snap index, so the choice
3036   // is between the current index and the one after it.
3037   const currentSnap = swiper.snapGrid[snapIndex];
3038   const nextSnap = swiper.snapGrid[snapIndex + 1];
3039
3040   if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
3041    index += swiper.params.slidesPerGroup;
3042   }
3043  } else {
3044   // The current translate is before the current snap index, so the choice
3045   // is between the current index and the one before it.
3046   const prevSnap = swiper.snapGrid[snapIndex - 1];
3047   const currentSnap = swiper.snapGrid[snapIndex];
3048
3049   if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
3050    index -= swiper.params.slidesPerGroup;
3051   }
3052  }
3053
3054  index = Math.max(index, 0);
3055  index = Math.min(index, swiper.slidesGrid.length - 1);
3056  return swiper.slideTo(index, speed, runCallbacks, internal);
3057 }
3058
3059 function slideToClickedSlide() {
3060  const swiper = this;
3061  const {
3062   params,
3063   $wrapperEl
3064  } = swiper;
3065  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
3066  let slideToIndex = swiper.clickedIndex;
3067  let realIndex;
3068
3069  if (params.loop) {
3070   if (swiper.animating) return;
3071   realIndex = parseInt($(swiper.clickedSlide).attr('data-swiper-slide-index'), 10);
3072
3073   if (params.centeredSlides) {
3074    if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
3075     swiper.loopFix();
3076     slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
3077     nextTick(() => {
3078      swiper.slideTo(slideToIndex);
3079     });
3080    } else {
3081     swiper.slideTo(slideToIndex);
3082    }
3083   } else if (slideToIndex > swiper.slides.length - slidesPerView) {
3084    swiper.loopFix();
3085    slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
3086    nextTick(() => {
3087     swiper.slideTo(slideToIndex);
3088    });
3089   } else {
3090    swiper.slideTo(slideToIndex);
3091   }
3092  } else {
3093   swiper.slideTo(slideToIndex);
3094  }
3095 }
3096
3097 var slide = {
3098  slideTo,
3099  slideToLoop,
3100  slideNext,
3101  slidePrev,
3102  slideReset,
3103  slideToClosest,
3104  slideToClickedSlide
3105 };
3106
3107 function loopCreate() {
3108  const swiper = this;
3109  const document = getDocument();
3110  const {
3111   params,
3112   $wrapperEl
3113  } = swiper; // Remove duplicated slides
3114
3115  const $selector = $wrapperEl.children().length > 0 ? $($wrapperEl.children()[0].parentNode) : $wrapperEl;
3116  $selector.children(`.${params.slideClass}.${params.slideDuplicateClass}`).remove();
3117  let slides = $selector.children(`.${params.slideClass}`);
3118
3119  if (params.loopFillGroupWithBlank) {
3120   const blankSlidesNum = params.slidesPerGroup - slides.length % params.slidesPerGroup;
3121
3122   if (blankSlidesNum !== params.slidesPerGroup) {
3123    for (let i = 0; i < blankSlidesNum; i += 1) {
3124     const blankNode = $(document.createElement('div')).addClass(`${params.slideClass} ${params.slideBlankClass}`);
3125     $selector.append(blankNode);
3126    }
3127
3128    slides = $selector.children(`.${params.slideClass}`);
3129   }
3130  }
3131
3132  if (params.slidesPerView === 'auto' && !params.loopedSlides) params.loopedSlides = slides.length;
3133  swiper.loopedSlides = Math.ceil(parseFloat(params.loopedSlides || params.slidesPerView, 10));
3134  swiper.loopedSlides += params.loopAdditionalSlides;
3135
3136  if (swiper.loopedSlides > slides.length && swiper.params.loopedSlidesLimit) {
3137   swiper.loopedSlides = slides.length;
3138  }
3139
3140  const prependSlides = [];
3141  const appendSlides = [];
3142  slides.each((el, index) => {
3143   const slide = $(el);
3144   slide.attr('data-swiper-slide-index', index);
3145  });
3146
3147  for (let i = 0; i < swiper.loopedSlides; i += 1) {
3148   const index = i - Math.floor(i / slides.length) * slides.length;
3149   appendSlides.push(slides.eq(index)[0]);
3150   prependSlides.unshift(slides.eq(slides.length - index - 1)[0]);
3151  }
3152
3153  for (let i = 0; i < appendSlides.length; i += 1) {
3154   $selector.append($(appendSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
3155  }
3156
3157  for (let i = prependSlides.length - 1; i >= 0; i -= 1) {
3158   $selector.prepend($(prependSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
3159  }
3160 }
3161
3162 function loopFix() {
3163  const swiper = this;
3164  swiper.emit('beforeLoopFix');
3165  const {
3166   activeIndex,
3167   slides,
3168   loopedSlides,
3169   allowSlidePrev,
3170   allowSlideNext,
3171   snapGrid,
3172   rtlTranslate: rtl
3173  } = swiper;
3174  let newIndex;
3175  swiper.allowSlidePrev = true;
3176  swiper.allowSlideNext = true;
3177  const snapTranslate = -snapGrid[activeIndex];
3178  const diff = snapTranslate - swiper.getTranslate(); // Fix For Negative Oversliding
3179
3180  if (activeIndex < loopedSlides) {
3181   newIndex = slides.length - loopedSlides * 3 + activeIndex;
3182   newIndex += loopedSlides;
3183   const slideChanged = swiper.slideTo(newIndex, 0, false, true);
3184
3185   if (slideChanged && diff !== 0) {
3186    swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
3187   }
3188  } else if (activeIndex >= slides.length - loopedSlides) {
3189   // Fix For Positive Oversliding
3190   newIndex = -slides.length + activeIndex + loopedSlides;
3191   newIndex += loopedSlides;
3192   const slideChanged = swiper.slideTo(newIndex, 0, false, true);
3193
3194   if (slideChanged && diff !== 0) {
3195    swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
3196   }
3197  }
3198
3199  swiper.allowSlidePrev = allowSlidePrev;
3200  swiper.allowSlideNext = allowSlideNext;
3201  swiper.emit('loopFix');
3202 }
3203
3204 function loopDestroy() {
3205  const swiper = this;
3206  const {
3207   $wrapperEl,
3208   params,
3209   slides
3210  } = swiper;
3211  $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass},.${params.slideClass}.${params.slideBlankClass}`).remove();
3212  slides.removeAttr('data-swiper-slide-index');
3213 }
3214
3215 var loop = {
3216  loopCreate,
3217  loopFix,
3218  loopDestroy
3219 };
3220
3221 function setGrabCursor(moving) {
3222  const swiper = this;
3223  if (swiper.support.touch || !swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
3224  const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
3225  el.style.cursor = 'move';
3226  el.style.cursor = moving ? 'grabbing' : 'grab';
3227 }
3228
3229 function unsetGrabCursor() {
3230  const swiper = this;
3231
3232  if (swiper.support.touch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
3233   return;
3234  }
3235
3236  swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
3237 }
3238
3239 var grabCursor = {
3240  setGrabCursor,
3241  unsetGrabCursor
3242 };
3243
3244 function closestElement(selector, base) {
3245  if (base === void 0) {
3246   base = this;
3247  }
3248
3249  function __closestFrom(el) {
3250   if (!el || el === getDocument() || el === getWindow()) return null;
3251   if (el.assignedSlot) el = el.assignedSlot;
3252   const found = el.closest(selector);
3253
3254   if (!found && !el.getRootNode) {
3255    return null;
3256   }
3257
3258   return found || __closestFrom(el.getRootNode().host);
3259  }
3260
3261  return __closestFrom(base);
3262 }
3263
3264 function onTouchStart(event) {
3265  const swiper = this;
3266  const document = getDocument();
3267  const window = getWindow();
3268  const data = swiper.touchEventsData;
3269  const {
3270   params,
3271   touches,
3272   enabled
3273  } = swiper;
3274  if (!enabled) return;
3275
3276  if (swiper.animating && params.preventInteractionOnTransition) {
3277   return;
3278  }
3279
3280  if (!swiper.animating && params.cssMode && params.loop) {
3281   swiper.loopFix();
3282  }
3283
3284  let e = event;
3285  if (e.originalEvent) e = e.originalEvent;
3286  let $targetEl = $(e.target);
3287
3288  if (params.touchEventsTarget === 'wrapper') {
3289   if (!$targetEl.closest(swiper.wrapperEl).length) return;
3290  }
3291
3292  data.isTouchEvent = e.type === 'touchstart';
3293  if (!data.isTouchEvent && 'which' in e && e.which === 3) return;
3294  if (!data.isTouchEvent && 'button' in e && e.button > 0) return;
3295  if (data.isTouched && data.isMoved) return; // change target el for shadow root component
3296
3297  const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== ''; // eslint-disable-next-line
3298
3299  const eventPath = event.composedPath ? event.composedPath() : event.path;
3300
3301  if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
3302   $targetEl = $(eventPath[0]);
3303  }
3304
3305  const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
3306  const isTargetShadow = !!(e.target && e.target.shadowRoot); // use closestElement for shadow root element to get the actual closest for nested shadow root element
3307
3308  if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, $targetEl[0]) : $targetEl.closest(noSwipingSelector)[0])) {
3309   swiper.allowClick = true;
3310   return;
3311  }
3312
3313  if (params.swipeHandler) {
3314   if (!$targetEl.closest(params.swipeHandler)[0]) return;
3315  }
3316
3317  touches.currentX = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
3318  touches.currentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
3319  const startX = touches.currentX;
3320  const startY = touches.currentY; // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
3321
3322  const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
3323  const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
3324
3325  if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
3326   if (edgeSwipeDetection === 'prevent') {
3327    event.preventDefault();
3328   } else {
3329    return;
3330   }
3331  }
3332
3333  Object.assign(data, {
3334   isTouched: true,
3335   isMoved: false,
3336   allowTouchCallbacks: true,
3337   isScrolling: undefined,
3338   startMoving: undefined
3339  });
3340  touches.startX = startX;
3341  touches.startY = startY;
3342  data.touchStartTime = now();
3343  swiper.allowClick = true;
3344  swiper.updateSize();
3345  swiper.swipeDirection = undefined;
3346  if (params.threshold > 0) data.allowThresholdMove = false;
3347
3348  if (e.type !== 'touchstart') {
3349   let preventDefault = true;
3350
3351   if ($targetEl.is(data.focusableElements)) {
3352    preventDefault = false;
3353
3354    if ($targetEl[0].nodeName === 'SELECT') {
3355     data.isTouched = false;
3356    }
3357   }
3358
3359   if (document.activeElement && $(document.activeElement).is(data.focusableElements) && document.activeElement !== $targetEl[0]) {
3360    document.activeElement.blur();
3361   }
3362
3363   const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
3364
3365   if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !$targetEl[0].isContentEditable) {
3366    e.preventDefault();
3367   }
3368  }
3369
3370  if (swiper.params.freeMode && swiper.params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
3371   swiper.freeMode.onTouchStart();
3372  }
3373
3374  swiper.emit('touchStart', e);
3375 }
3376
3377 function onTouchMove(event) {
3378  const document = getDocument();
3379  const swiper = this;
3380  const data = swiper.touchEventsData;
3381  const {
3382   params,
3383   touches,
3384   rtlTranslate: rtl,
3385   enabled
3386  } = swiper;
3387  if (!enabled) return;
3388  let e = event;
3389  if (e.originalEvent) e = e.originalEvent;
3390
3391  if (!data.isTouched) {
3392   if (data.startMoving && data.isScrolling) {
3393    swiper.emit('touchMoveOpposite', e);
3394   }
3395
3396   return;
3397  }
3398
3399  if (data.isTouchEvent && e.type !== 'touchmove') return;
3400  const targetTouch = e.type === 'touchmove' && e.targetTouches && (e.targetTouches[0] || e.changedTouches[0]);
3401  const pageX = e.type === 'touchmove' ? targetTouch.pageX : e.pageX;
3402  const pageY = e.type === 'touchmove' ? targetTouch.pageY : e.pageY;
3403
3404  if (e.preventedByNestedSwiper) {
3405   touches.startX = pageX;
3406   touches.startY = pageY;
3407   return;
3408  }
3409
3410  if (!swiper.allowTouchMove) {
3411   if (!$(e.target).is(data.focusableElements)) {
3412    swiper.allowClick = false;
3413   }
3414
3415   if (data.isTouched) {
3416    Object.assign(touches, {
3417     startX: pageX,
3418     startY: pageY,
3419     currentX: pageX,
3420     currentY: pageY
3421    });
3422    data.touchStartTime = now();
3423   }
3424
3425   return;
3426  }
3427
3428  if (data.isTouchEvent && params.touchReleaseOnEdges && !params.loop) {
3429   if (swiper.isVertical()) {
3430    // Vertical
3431    if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {
3432     data.isTouched = false;
3433     data.isMoved = false;
3434     return;
3435    }
3436   } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) {
3437    return;
3438   }
3439  }
3440
3441  if (data.isTouchEvent && document.activeElement) {
3442   if (e.target === document.activeElement && $(e.target).is(data.focusableElements)) {
3443    data.isMoved = true;
3444    swiper.allowClick = false;
3445    return;
3446   }
3447  }
3448
3449  if (data.allowTouchCallbacks) {
3450   swiper.emit('touchMove', e);
3451  }
3452
3453  if (e.targetTouches && e.targetTouches.length > 1) return;
3454  touches.currentX = pageX;
3455  touches.currentY = pageY;
3456  const diffX = touches.currentX - touches.startX;
3457  const diffY = touches.currentY - touches.startY;
3458  if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;
3459
3460  if (typeof data.isScrolling === 'undefined') {
3461   let touchAngle;
3462
3463   if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {
3464    data.isScrolling = false;
3465   } else {
3466    // eslint-disable-next-line
3467    if (diffX * diffX + diffY * diffY >= 25) {
3468     touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
3469     data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
3470    }
3471   }
3472  }
3473
3474  if (data.isScrolling) {
3475   swiper.emit('touchMoveOpposite', e);
3476  }
3477
3478  if (typeof data.startMoving === 'undefined') {
3479   if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
3480    data.startMoving = true;
3481   }
3482  }
3483
3484  if (data.isScrolling) {
3485   data.isTouched = false;