https://www.michelbach-bilz.de/fileadmin/templates/js/upgrade/libs/swiper/swiper-bundle.esm.browser.js

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

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

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

967  if (!closest.is(selector)) {
968    closest = closest.parents(selector).eq(0);
969  }
970
971  return closest;
972}
973
974function find(selector) {
975  const foundElements = [];
976
977  for (let i = 0; i < this.length; i += 1) {
978    const found = this[i].querySelectorAll(selector);
979
980    for (let j = 0; j < found.length; j += 1) {
981      foundElements.push(found[j]);
982    }
983  }
984
985  return $(foundElements);
986}
987
988function children(selector) {
989  const children = []; // eslint-disable-line
990
991  for (let i = 0; i < this.length; i += 1) {
992    const childNodes = this[i].children;
993
994    for (let j = 0; j < childNodes.length; j += 1) {
995      if (!selector || $(childNodes[j]).is(selector)) {
996        children.push(childNodes[j]);
997      }
998    }
999  }
1000
1001  return $(children);
1002}
1003
1004function remove() {
1005  for (let i = 0; i < this.length; i += 1) {
1006    if (this[i].parentNode) this[i].parentNode.removeChild(this[i]);
1007  }
1008
1009  return this;
1010}
1011
1012const Methods = {
1013  addClass,
1014  removeClass,
1015  hasClass,
1016  toggleClass,
1017  attr,
1018  removeAttr,
1019  transform,
1020  transition: transition$1,
1021  on,
1022  off,
1023  trigger,
1024  transitionEnd: transitionEnd$1,
1025  outerWidth,
1026  outerHeight,
1027  styles,
1028  offset,
1029  css,
1030  each,
1031  html,
1032  text,
1033  is,
1034  index,
1035  eq,
1036  append,
1037  prepend,
1038  next,
1039  nextAll,
1040  prev,
1041  prevAll,
1042  parent,
1043  parents,
1044  closest,
1045  find,
1046  children,
1047  filter,
1048  remove
1049};
1050Object.keys(Methods).forEach(methodName => {
1051  Object.defineProperty($.fn, methodName, {
1052    value: Methods[methodName],
1053    writable: true
1054  });
1055});
1056
1057function deleteProps(obj) {
1058  const object = obj;
1059  Object.keys(object).forEach(key => {
1060    try {
1061      object[key] = null;
1062    } catch (e) {// no getter for object
1063    }
1064
1065    try {
1066      delete object[key];
1067    } catch (e) {// something got wrong
1068    }
1069  });
1070}
1071
1072function nextTick(callback, delay) {
1073  if (delay === void 0) {

1074    delay = 0;
1075  }
1076
1077  return setTimeout(callback, delay);
1078}
1079
1080function now() {
1081  return Date.now();
1082}
1083
1084function getComputedStyle$1(el) {
1085  const window = getWindow();
1086  let style;
1087
1088  if (window.getComputedStyle) {
1089    style = window.getComputedStyle(el, null);
1090  }
1091
1092  if (!style && el.currentStyle) {
1093    style = el.currentStyle;
1094  }
1095
1096  if (!style) {
1097    style = el.style;
1098  }
1099
1100  return style;
1101}
1102
1103function getTranslate(el, axis) {
1104  if (axis === void 0) {
1105    axis = 'x';
1106  }
1107
1108  const window = getWindow();
1109  let matrix;
1110  let curTransform;
1111  let transformMatrix;
1112  const curStyle = getComputedStyle$1(el);
1113
1114  if (window.WebKitCSSMatrix) {
1115    curTransform = curStyle.transform || curStyle.webkitTransform;
1116
1117    if (curTransform.split(',').length > 6) {
1118      curTransform = curTransform.split(', ').map(a => a.replace(',', '.')).join(', ');
1119    } // Some old versions of Webkit choke when 'none' is passed; pass
1120    // empty string instead in this case
1121
1122
1123    transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
1124  } else {
1125    transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
1126    matrix = transformMatrix.toString().split(',');
1127  }
1128
1129  if (axis === 'x') {
1130    // Latest Chrome and webkits Fix
1131    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41; // Crazy IE10 Matrix
1132    else if (matrix.length === 16) curTransform = parseFloat(matrix[12]); // Normal Browsers
1133    else curTransform = parseFloat(matrix[4]);
1134  }
1135
1136  if (axis === 'y') {
1137    // Latest Chrome and webkits Fix
1138    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42; // Crazy IE10 Matrix
1139    else if (matrix.length === 16) curTransform = parseFloat(matrix[13]); // Normal Browsers
1140    else curTransform = parseFloat(matrix[5]);
1141  }
1142
1143  return curTransform || 0;
1144}
1145
1146function isObject(o) {
1147  return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';
1148}
1149
1150function isNode(node) {
1151  // eslint-disable-next-line
1152  if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
1153    return node instanceof HTMLElement;
1154  }
1155
1156  return node && (node.nodeType === 1 || node.nodeType === 11);
1157}
1158
1159function extend() {
1160  const to = Object(arguments.length <= 0 ? undefined : arguments[0]);
1161  const noExtend = ['__proto__', 'constructor', 'prototype'];
1162
1163  for (let i = 1; i < arguments.length; i += 1) {
1164    const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
1165
1166    if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
1167      const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);
1168
1169      for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
1170        const nextKey = keysArray[nextIndex];
1171        const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
1172
1173        if (desc !== undefined && desc.enumerable) {
1174          if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1175            if (nextSource[nextKey].__swiper__) {
1176              to[nextKey] = nextSource[nextKey];
1177            } else {
1178              extend(to[nextKey], nextSource[nextKey]);
1179            }
1180          } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1181            to[nextKey] = {};
1182
1183            if (nextSource[nextKey].__swiper__) {
1184              to[nextKey] = nextSource[nextKey];
1185            } else {
1186              extend(to[nextKey], nextSource[nextKey]);
1187            }
1188          } else {
1189            to[nextKey] = nextSource[nextKey];
1190          }
1191        }
1192      }
1193    }
1194  }
1195
1196  return to;
1197}
1198
1199function setCSSProperty(el, varName, varValue) {
1200  el.style.setProperty(varName, varValue);
1201}
1202
1203function animateCSSModeScroll(_ref) {
1204  let {
1205    swiper,
1206    targetPosition,
1207    side
1208  } = _ref;
1209  const window = getWindow();
1210  const startPosition = -swiper.translate;
1211  let startTime = null;
1212  let time;
1213  const duration = swiper.params.speed;
1214  swiper.wrapperEl.style.scrollSnapType = 'none';
1215  window.cancelAnimationFrame(swiper.cssModeFrameID);
1216  const dir = targetPosition > startPosition ? 'next' : 'prev';
1217
1218  const isOutOfBound = (current, target) => {
1219    return dir === 'next' && current >= target || dir === 'prev' && current <= target;
1220  };
1221
1222  const animate = () => {
1223    time = new Date().getTime();
1224
1225    if (startTime === null) {
1226      startTime = time;
1227    }
1228
1229    const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
1230    const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;

1231    let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
1232
1233    if (isOutOfBound(currentPosition, targetPosition)) {
1234      currentPosition = targetPosition;
1235    }
1236
1237    swiper.wrapperEl.scrollTo({
1238      [side]: currentPosition
1239    });
1240
1241    if (isOutOfBound(currentPosition, targetPosition)) {
1242      swiper.wrapperEl.style.overflow = 'hidden';
1243      swiper.wrapperEl.style.scrollSnapType = '';
1244      setTimeout(() => {
1245        swiper.wrapperEl.style.overflow = '';
1246        swiper.wrapperEl.scrollTo({
1247          [side]: currentPosition
1248        });
1249      });
1250      window.cancelAnimationFrame(swiper.cssModeFrameID);
1251      return;
1252    }
1253
1254    swiper.cssModeFrameID = window.requestAnimationFrame(animate);
1255  };
1256
1257  animate();
1258}
1259
1260let support;
1261
1262function calcSupport() {
1263  const window = getWindow();
1264  const document = getDocument();
1265  return {
1266    smoothScroll: document.documentElement && 'scrollBehavior' in document.documentElement.style,
1267    touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch),
1268    passiveListener: function checkPassiveListener() {
1269      let supportsPassive = false;
1270
1271      try {
1272        const opts = Object.defineProperty({}, 'passive', {
1273          // eslint-disable-next-line
1274          get() {
1275            supportsPassive = true;
1276          }
1277
1278        });
1279        window.addEventListener('testPassiveListener', null, opts);
1280      } catch (e) {// No support
1281      }
1282
1283      return supportsPassive;
1284    }(),
1285    gestures: function checkGestures() {
1286      return 'ongesturestart' in window;
1287    }()
1288  };
1289}
1290
1291function getSupport() {
1292  if (!support) {
1293    support = calcSupport();
1294  }
1295
1296  return support;
1297}
1298
1299let deviceCached;
1300
1301function calcDevice(_temp) {
1302  let {
1303    userAgent
1304  } = _temp === void 0 ? {} : _temp;

1305  const support = getSupport();
1306  const window = getWindow();
1307  const platform = window.navigator.platform;
1308  const ua = userAgent || window.navigator.userAgent;
1309  const device = {
1310    ios: false,
1311    android: false
1312  };
1313  const screenWidth = window.screen.width;
1314  const screenHeight = window.screen.height;
1315  const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
1316
1317  let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
1318  const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
1319  const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
1320  const windows = platform === 'Win32';
1321  let macos = platform === 'MacIntel'; // iPadOs 13 fix
1322
1323  const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
1324
1325  if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
1326    ipad = ua.match(/(Version)\/([\d.]+)/);
1327    if (!ipad) ipad = [0, 1, '13_0_0'];
1328    macos = false;
1329  } // Android
1330
1331
1332  if (android && !windows) {
1333    device.os = 'android';
1334    device.android = true;
1335  }
1336
1337  if (ipad || iphone || ipod) {
1338    device.os = 'ios';
1339    device.ios = true;
1340  } // Export object
1341
1342
1343  return device;
1344}
1345
1346function getDevice(overrides) {
1347  if (overrides === void 0) {
1348    overrides = {};
1349  }
1350
1351  if (!deviceCached) {
1352    deviceCached = calcDevice(overrides);
1353  }
1354
1355  return deviceCached;
1356}
1357
1358let browser;
1359
1360function calcBrowser() {
1361  const window = getWindow();
1362
1363  function isSafari() {
1364    const ua = window.navigator.userAgent.toLowerCase();
1365    return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
1366  }
1367
1368  return {
1369    isSafari: isSafari(),
1370    isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)
1371  };
1372}
1373
1374function getBrowser() {
1375  if (!browser) {
1376    browser = calcBrowser();
1377  }
1378
1379  return browser;
1380}
1381
1382function Resize(_ref) {
1383  let {
1384    swiper,
1385    on,
1386    emit
1387  } = _ref;
1388  const window = getWindow();
1389  let observer = null;
1390  let animationFrame = null;
1391
1392  const resizeHandler = () => {
1393    if (!swiper || swiper.destroyed || !swiper.initialized) return;
1394    emit('beforeResize');
1395    emit('resize');
1396  };
1397
1398  const createObserver = () => {
1399    if (!swiper || swiper.destroyed || !swiper.initialized) return;
1400    observer = new ResizeObserver(entries => {
1401      animationFrame = window.requestAnimationFrame(() => {
1402        const {
1403          width,
1404          height
1405        } = swiper;
1406        let newWidth = width;
1407        let newHeight = height;
1408        entries.forEach(_ref2 => {
1409          let {
1410            contentBoxSize,
1411            contentRect,
1412            target
1413          } = _ref2;
1414          if (target && target !== swiper.el) return;
1415          newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
1416          newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
1417        });
1418
1419        if (newWidth !== width || newHeight !== height) {
1420          resizeHandler();
1421        }
1422      });
1423    });
1424    observer.observe(swiper.el);
1425  };
1426
1427  const removeObserver = () => {
1428    if (animationFrame) {
1429      window.cancelAnimationFrame(animationFrame);
1430    }
1431
1432    if (observer && observer.unobserve && swiper.el) {
1433      observer.unobserve(swiper.el);
1434      observer = null;
1435    }
1436  };
1437
1438  const orientationChangeHandler = () => {
1439    if (!swiper || swiper.destroyed || !swiper.initialized) return;
1440    emit('orientationchange');
1441  };
1442
1443  on('init', () => {
1444    if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
1445      createObserver();
1446      return;
1447    }
1448
1449    window.addEventListener('resize', resizeHandler);
1450    window.addEventListener('orientationchange', orientationChangeHandler);
1451  });
1452  on('destroy', () => {
1453    removeObserver();
1454    window.removeEventListener('resize', resizeHandler);
1455    window.removeEventListener('orientationchange', orientationChangeHandler);
1456  });
1457}
1458
1459function Observer(_ref) {
1460  let {
1461    swiper,
1462    extendParams,
1463    on,
1464    emit
1465  } = _ref;
1466  const observers = [];
1467  const window = getWindow();
1468
1469  const attach = function (target, options) {
1470    if (options === void 0) {
1471      options = {};
1472    }
1473
1474    const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
1475    const observer = new ObserverFunc(mutations => {
1476      // The observerUpdate event should only be triggered
1477      // once despite the number of mutations.  Additional
1478      // triggers are redundant and are very costly
1479      if (mutations.length === 1) {
1480        emit('observerUpdate', mutations[0]);
1481        return;
1482      }
1483
1484      const observerUpdate = function observerUpdate() {
1485        emit('observerUpdate', mutations[0]);
1486      };
1487
1488      if (window.requestAnimationFrame) {
1489        window.requestAnimationFrame(observerUpdate);
1490      } else {
1491        window.setTimeout(observerUpdate, 0);
1492      }
1493    });
1494    observer.observe(target, {
1495      attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
1496      childList: typeof options.childList === 'undefined' ? true : options.childList,
1497      characterData: typeof options.characterData === 'undefined' ? true : options.characterData
1498    });
1499    observers.push(observer);
1500  };
1501
1502  const init = () => {
1503    if (!swiper.params.observer) return;
1504
1505    if (swiper.params.observeParents) {
1506      const containerParents = swiper.$el.parents();
1507
1508      for (let i = 0; i < containerParents.length; i += 1) {
1509        attach(containerParents[i]);
1510      }
1511    } // Observe container
1512
1513
1514    attach(swiper.$el[0], {
1515      childList: swiper.params.observeSlideChildren
1516    }); // Observe wrapper
1517
1518    attach(swiper.$wrapperEl[0], {
1519      attributes: false
1520    });
1521  };
1522
1523  const destroy = () => {
1524    observers.forEach(observer => {
1525      observer.disconnect();
1526    });
1527    observers.splice(0, observers.length);
1528  };
1529
1530  extendParams({
1531    observer: false,
1532    observeParents: false,
1533    observeSlideChildren: false
1534  });
1535  on('init', init);
1536  on('destroy', destroy);
1537}
1538
1539/* eslint-disable no-underscore-dangle */
1540var eventsEmitter = {
1541  on(events, handler, priority) {
1542    const self = this;
1543    if (!self.eventsListeners || self.destroyed) return self;
1544    if (typeof handler !== 'function') return self;
1545    const method = priority ? 'unshift' : 'push';
1546    events.split(' ').forEach(event => {
1547      if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
1548      self.eventsListeners[event][method](handler);
1549    });
1550    return self;
1551  },
1552
1553  once(events, handler, priority) {
1554    const self = this;
1555    if (!self.eventsListeners || self.destroyed) return self;
1556    if (typeof handler !== 'function') return self;
1557
1558    function onceHandler() {
1559      self.off(events, onceHandler);
1560
1561      if (onceHandler.__emitterProxy) {
1562        delete onceHandler.__emitterProxy;
1563      }
1564
1565      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1566        args[_key] = arguments[_key];
1567      }
1568
1569      handler.apply(self, args);
1570    }
1571
1572    onceHandler.__emitterProxy = handler;
1573    return self.on(events, onceHandler, priority);
1574  },
1575
1576  onAny(handler, priority) {
1577    const self = this;
1578    if (!self.eventsListeners || self.destroyed) return self;
1579    if (typeof handler !== 'function') return self;
1580    const method = priority ? 'unshift' : 'push';
1581
1582    if (self.eventsAnyListeners.indexOf(handler) < 0) {
1583      self.eventsAnyListeners[method](handler);
1584    }
1585
1586    return self;
1587  },
1588
1589  offAny(handler) {
1590    const self = this;
1591    if (!self.eventsListeners || self.destroyed) return self;
1592    if (!self.eventsAnyListeners) return self;
1593    const index = self.eventsAnyListeners.indexOf(handler);
1594
1595    if (index >= 0) {
1596      self.eventsAnyListeners.splice(index, 1);
1597    }
1598
1599    return self;
1600  },
1601
1602  off(events, handler) {
1603    const self = this;
1604    if (!self.eventsListeners || self.destroyed) return self;
1605    if (!self.eventsListeners) return self;
1606    events.split(' ').forEach(event => {
1607      if (typeof handler === 'undefined') {
1608        self.eventsListeners[event] = [];
1609      } else if (self.eventsListeners[event]) {
1610        self.eventsListeners[event].forEach((eventHandler, index) => {
1611          if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
1612            self.eventsListeners[event].splice(index, 1);
1613          }
1614        });
1615      }
1616    });
1617    return self;
1618  },
1619
1620  emit() {
1621    const self = this;
1622    if (!self.eventsListeners || self.destroyed) return self;
1623    if (!self.eventsListeners) return self;
1624    let events;
1625    let data;
1626    let context;
1627
1628    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
1629      args[_key2] = arguments[_key2];
1630    }

1630
1631
1632    if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1633      events = args[0];
1634      data = args.slice(1, args.length);
1635      context = self;
1636    } else {
1637      events = args[0].events;
1638      data = args[0].data;
1639      context = args[0].context || self;
1640    }
1641
1642    data.unshift(context);
1643    const eventsArray = Array.isArray(events) ? events : events.split(' ');
1644    eventsArray.forEach(event => {
1645      if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
1646        self.eventsAnyListeners.forEach(eventHandler => {
1647          eventHandler.apply(context, [event, ...data]);
1648        });
1649      }
1650
1651      if (self.eventsListeners && self.eventsListeners[event]) {
1652        self.eventsListeners[event].forEach(eventHandler => {
1653          eventHandler.apply(context, data);
1654        });
1655      }
1656    });
1657    return self;
1658  }
1659
1660};
1661
1662function updateSize() {
1663  const swiper = this;
1664  let width;
1665  let height;
1666  const $el = swiper.$el;
1667
1668  if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
1669    width = swiper.params.width;
1670  } else {
1671    width = $el[0].clientWidth;
1672  }
1673
1674  if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
1675    height = swiper.params.height;
1676  } else {
1677    height = $el[0].clientHeight;
1678  }
1679
1680  if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
1681    return;
1682  } // Subtract paddings
1683
1684
1685  width = width - parseInt($el.css('padding-left') || 0, 10) - parseInt($el.css('padding-right') || 0, 10);
1686  height = height - parseInt($el.css('padding-top') || 0, 10) - parseInt($el.css('padding-bottom') || 0, 10);
1687  if (Number.isNaN(width)) width = 0;
1688  if (Number.isNaN(height)) height = 0;
1689  Object.assign(swiper, {
1690    width,
1691    height,
1692    size: swiper.isHorizontal() ? width : height
1693  });
1694}
1695
1696function updateSlides() {
1697  const swiper = this;
1698
1699  function getDirectionLabel(property) {
1700    if (swiper.isHorizontal()) {
1701      return property;
1702    } // prettier-ignore
1703
1704
1705    return {
1706      'width': 'height',
1707      'margin-top': 'margin-left',
1708      'margin-bottom ': 'margin-right',
1709      'margin-left': 'margin-top',
1710      'margin-right': 'margin-bottom',
1711      'padding-left': 'padding-top',
1712      'padding-right': 'padding-bottom',
1713      'marginRight': 'marginBottom'
1714    }[property];
1715  }
1716
1717  function getDirectionPropertyValue(node, label) {
1718    return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);
1719  }
1720
1721  const params = swiper.params;
1722  const {
1723    $wrapperEl,
1724    size: swiperSize,
1725    rtlTranslate: rtl,
1726    wrongRTL
1727  } = swiper;
1728  const isVirtual = swiper.virtual && params.virtual.enabled;
1729  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1730  const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);
1731  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1732  let snapGrid = [];
1733  const slidesGrid = [];
1734  const slidesSizesGrid = [];
1735  let offsetBefore = params.slidesOffsetBefore;
1736
1737  if (typeof offsetBefore === 'function') {
1738    offsetBefore = params.slidesOffsetBefore.call(swiper);
1739  }
1740
1741  let offsetAfter = params.slidesOffsetAfter;
1742
1743  if (typeof offsetAfter === 'function') {
1744    offsetAfter = params.slidesOffsetAfter.call(swiper);
1745  }
1746
1747  const previousSnapGridLength = swiper.snapGrid.length;
1748  const previousSlidesGridLength = swiper.slidesGrid.length;
1749  let spaceBetween = params.spaceBetween;
1750  let slidePosition = -offsetBefore;
1751  let prevSlideSize = 0;
1752  let index = 0;
1753
1754  if (typeof swiperSize === 'undefined') {
1755    return;
1756  }
1757
1758  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1759    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
1760  }
1761
1762  swiper.virtualSize = -spaceBetween; // reset margins
1763
1764  if (rtl) slides.css({
1765    marginLeft: '',
1766    marginBottom: '',
1767    marginTop: ''
1768  });else slides.css({
1769    marginRight: '',
1770    marginBottom: '',
1771    marginTop: ''
1772  }); // reset cssMode offsets
1773
1774  if (params.centeredSlides && params.cssMode) {
1775    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', '');
1776    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', '');
1777  }
1778
1779  const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
1780
1781  if (gridEnabled) {
1782    swiper.grid.initSlides(slidesLength);
1783  } // Calc slides
1784
1785
1786  let slideSize;
1787  const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
1788    return typeof params.breakpoints[key].slidesPerView !== 'undefined';
1789  }).length > 0;
1790
1791  for (let i = 0; i < slidesLength; i += 1) {
1792    slideSize = 0;
1793    const slide = slides.eq(i);
1794
1795    if (gridEnabled) {
1796      swiper.grid.updateSlide(i, slide, slidesLength, getDirectionLabel);
1797    }
1798
1799    if (slide.css('display') === 'none') continue; // eslint-disable-line
1800
1801    if (params.slidesPerView === 'auto') {
1802      if (shouldResetSlideSize) {
1803        slides[i].style[getDirectionLabel('width')] = ``;
1804      }
1805
1806      const slideStyles = getComputedStyle(slide[0]);
1807      const currentTransform = slide[0].style.transform;
1808      const currentWebKitTransform = slide[0].style.webkitTransform;
1809
1810      if (currentTransform) {
1811        slide[0].style.transform = 'none';
1812      }
1813
1814      if (currentWebKitTransform) {
1815        slide[0].style.webkitTransform = 'none';
1816      }
1817
1818      if (params.roundLengths) {
1819        slideSize = swiper.isHorizontal() ? slide.outerWidth(true) : slide.outerHeight(true);
1820      } else {
1821        // eslint-disable-next-line
1822        const width = getDirectionPropertyValue(slideStyles, 'width');
1823        const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
1824        const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
1825        const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
1826        const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
1827        const boxSizing = slideStyles.getPropertyValue('box-sizing');
1828
1829        if (boxSizing && boxSizing === 'border-box') {
1830          slideSize = width + marginLeft + marginRight;
1831        } else {
1832          const {
1833            clientWidth,
1834            offsetWidth
1835          } = slide[0];
1836          slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1837        }
1838      }
1839
1840      if (currentTransform) {
1841        slide[0].style.transform = currentTransform;
1842      }
1843
1844      if (currentWebKitTransform) {
1845        slide[0].style.webkitTransform = currentWebKitTransform;
1846      }
1847
1848      if (params.roundLengths) slideSize = Math.floor(slideSize);
1849    } else {
1850      slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
1851      if (params.roundLengths) slideSize = Math.floor(slideSize);
1852
1853      if (slides[i]) {
1854        slides[i].style[getDirectionLabel('width')] = `${slideSize}px`;
1855      }
1856    }
1857
1858    if (slides[i]) {
1859      slides[i].swiperSlideSize = slideSize;
1860    }
1861
1862    slidesSizesGrid.push(slideSize);
1863
1864    if (params.centeredSlides) {
1865      slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1866      if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1867      if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1868      if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
1869      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1870      if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1871      slidesGrid.push(slidePosition);
1872    } else {
1873      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1874      if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1875      slidesGrid.push(slidePosition);
1876      slidePosition = slidePosition + slideSize + spaceBetween;
1877    }
1878
1879    swiper.virtualSize += slideSize + spaceBetween;
1880    prevSlideSize = slideSize;
1881    index += 1;
1882  }
1883
1884  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1885
1886  if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1887    $wrapperEl.css({
1888      width: `${swiper.virtualSize + params.spaceBetween}px`
1889    });
1890  }
1891
1892  if (params.setWrapperSize) {
1893    $wrapperEl.css({
1894      [getDirectionLabel('width')]: `${swiper.virtualSize + params.spaceBetween}px`
1895    });
1896  }
1897
1898  if (gridEnabled) {
1899    swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);
1900  } // Remove last grid elements depending on width
1901
1902
1903  if (!params.centeredSlides) {
1904    const newSlidesGrid = [];
1905
1906    for (let i = 0; i < snapGrid.length; i += 1) {
1907      let slidesGridItem = snapGrid[i];
1908      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1909
1910      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1911        newSlidesGrid.push(slidesGridItem);
1912      }
1913    }
1914
1915    snapGrid = newSlidesGrid;
1916
1917    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1918      snapGrid.push(swiper.virtualSize - swiperSize);
1919    }
1920  }
1921
1922  if (snapGrid.length === 0) snapGrid = [0];
1923
1924  if (params.spaceBetween !== 0) {
1925    const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');
1926    slides.filter((_, slideIndex) => {
1927      if (!params.cssMode) return true;
1928
1929      if (slideIndex === slides.length - 1) {
1930        return false;
1931      }
1932
1933      return true;
1934    }).css({
1935      [key]: `${spaceBetween}px`
1936    });
1937  }
1938
1939  if (params.centeredSlides && params.centeredSlidesBounds) {
1940    let allSlidesSize = 0;
1941    slidesSizesGrid.forEach(slideSizeValue => {
1942      allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1943    });
1944    allSlidesSize -= params.spaceBetween;
1945    const maxSnap = allSlidesSize - swiperSize;
1946    snapGrid = snapGrid.map(snap => {
1947      if (snap < 0) return -offsetBefore;
1948      if (snap > maxSnap) return maxSnap + offsetAfter;
1949      return snap;
1950    });
1951  }
1952
1953  if (params.centerInsufficientSlides) {
1954    let allSlidesSize = 0;
1955    slidesSizesGrid.forEach(slideSizeValue => {
1956      allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1957    });
1958    allSlidesSize -= params.spaceBetween;
1959
1960    if (allSlidesSize < swiperSize) {
1961      const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1962      snapGrid.forEach((snap, snapIndex) => {
1963        snapGrid[snapIndex] = snap - allSlidesOffset;
1964      });
1965      slidesGrid.forEach((snap, snapIndex) => {
1966        slidesGrid[snapIndex] = snap + allSlidesOffset;
1967      });
1968    }
1969  }
1970
1971  Object.assign(swiper, {
1972    slides,
1973    snapGrid,
1974    slidesGrid,
1975    slidesSizesGrid
1976  });
1977
1978  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1979    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
1980    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1981    const addToSnapGrid = -swiper.snapGrid[0];
1982    const addToSlidesGrid = -swiper.slidesGrid[0];
1983    swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1984    swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1985  }
1986
1987  if (slidesLength !== previousSlidesLength) {
1988    swiper.emit('slidesLengthChange');
1989  }
1990
1991  if (snapGrid.length !== previousSnapGridLength) {
1992    if (swiper.params.watchOverflow) swiper.checkOverflow();
1993    swiper.emit('snapGridLengthChange');
1994  }
1995
1996  if (slidesGrid.length !== previousSlidesGridLength) {
1997    swiper.emit('slidesGridLengthChange');
1998  }
1999
2000  if (params.watchSlidesProgress) {
2001    swiper.updateSlidesOffset();
2002  }

2003
2004  if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
2005    const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
2006    const hasClassBackfaceClassAdded = swiper.$el.hasClass(backFaceHiddenClass);
2007
2008    if (slidesLength <= params.maxBackfaceHiddenSlides) {
2009      if (!hasClassBackfaceClassAdded) swiper.$el.addClass(backFaceHiddenClass);
2010    } else if (hasClassBackfaceClassAdded) {
2011      swiper.$el.removeClass(backFaceHiddenClass);
2012    }
2013  }
2014}
2015
2016function updateAutoHeight(speed) {
2017  const swiper = this;
2018  const activeSlides = [];
2019  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2020  let newHeight = 0;
2021  let i;
2022
2023  if (typeof speed === 'number') {
2024    swiper.setTransition(speed);
2025  } else if (speed === true) {
2026    swiper.setTransition(swiper.params.speed);
2027  }
2028
2029  const getSlideByIndex = index => {
2030    if (isVirtual) {
2031      return swiper.slides.filter(el => parseInt(el.getAttribute('data-swiper-slide-index'), 10) === index)[0];
2032    }
2033
2034    return swiper.slides.eq(index)[0];
2035  }; // Find slides currently in view
2036
2037
2038  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
2039    if (swiper.params.centeredSlides) {
2040      (swiper.visibleSlides || $([])).each(slide => {
2041        activeSlides.push(slide);
2042      });
2043    } else {
2044      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
2045        const index = swiper.activeIndex + i;
2046        if (index > swiper.slides.length && !isVirtual) break;
2047        activeSlides.push(getSlideByIndex(index));
2048      }
2049    }
2050  } else {
2051    activeSlides.push(getSlideByIndex(swiper.activeIndex));
2052  } // Find new height from highest slide in view
2053
2054
2055  for (i = 0; i < activeSlides.length; i += 1) {
2056    if (typeof activeSlides[i] !== 'undefined') {
2057      const height = activeSlides[i].offsetHeight;
2058      newHeight = height > newHeight ? height : newHeight;
2059    }
2060  } // Update Height
2061
2062
2063  if (newHeight || newHeight === 0) swiper.$wrapperEl.css('height', `${newHeight}px`);
2064}
2065
2066function updateSlidesOffset() {
2067  const swiper = this;
2068  const slides = swiper.slides;
2069
2070  for (let i = 0; i < slides.length; i += 1) {
2071    slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;
2072  }
2073}
2074
2075function updateSlidesProgress(translate) {
2076  if (translate === void 0) {
2077    translate = this && this.translate || 0;
2078  }
2079
2080  const swiper = this;
2081  const params = swiper.params;
2082  const {
2083    slides,
2084    rtlTranslate: rtl,
2085    snapGrid
2086  } = swiper;
2087  if (slides.length === 0) return;
2088  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
2089  let offsetCenter = -translate;
2090  if (rtl) offsetCenter = translate; // Visible Slides
2091
2092  slides.removeClass(params.slideVisibleClass);
2093  swiper.visibleSlidesIndexes = [];
2094  swiper.visibleSlides = [];
2095
2096  for (let i = 0; i < slides.length; i += 1) {
2097    const slide = slides[i];
2098    let slideOffset = slide.swiperSlideOffset;
2099
2100    if (params.cssMode && params.centeredSlides) {
2101      slideOffset -= slides[0].swiperSlideOffset;
2102    }
2103
2104    const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2105    const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2106    const slideBefore = -(offsetCenter - slideOffset);
2107    const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
2108    const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
2109
2110    if (isVisible) {
2111      swiper.visibleSlides.push(slide);
2112      swiper.visibleSlidesIndexes.push(i);
2113      slides.eq(i).addClass(params.slideVisibleClass);
2114    }
2115
2116    slide.progress = rtl ? -slideProgress : slideProgress;
2117    slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
2118  }
2119
2120  swiper.visibleSlides = $(swiper.visibleSlides);
2121}
2122
2123function updateProgress(translate) {
2124  const swiper = this;
2125
2126  if (typeof translate === 'undefined') {
2127    const multiplier = swiper.rtlTranslate ? -1 : 1; // eslint-disable-next-line
2128
2129    translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
2130  }
2131
2132  const params = swiper.params;
2133  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2134  let {
2135    progress,
2136    isBeginning,
2137    isEnd
2138  } = swiper;
2139  const wasBeginning = isBeginning;
2140  const wasEnd = isEnd;
2141
2142  if (translatesDiff === 0) {
2143    progress = 0;
2144    isBeginning = true;
2145    isEnd = true;
2146  } else {
2147    progress = (translate - swiper.minTranslate()) / translatesDiff;
2148    isBeginning = progress <= 0;
2149    isEnd = progress >= 1;
2150  }
2151
2152  Object.assign(swiper, {
2153    progress,
2154    isBeginning,
2155    isEnd
2156  });
2157  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
2158
2159  if (isBeginning && !wasBeginning) {
2160    swiper.emit('reachBeginning toEdge');
2161  }
2162
2163  if (isEnd && !wasEnd) {
2164    swiper.emit('reachEnd toEdge');
2165  }
2166
2167  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
2168    swiper.emit('fromEdge');
2169  }
2170
2171  swiper.emit('progress', progress);
2172}
2173
2174function updateSlidesClasses() {
2175  const swiper = this;
2176  const {
2177    slides,
2178    params,
2179    $wrapperEl,
2180    activeIndex,
2181    realIndex
2182  } = swiper;
2183  const isVirtual = swiper.virtual && params.virtual.enabled;
2184  slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);
2185  let activeSlide;
2186
2187  if (isVirtual) {
2188    activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index="${activeIndex}"]`);
2189  } else {
2190    activeSlide = slides.eq(activeIndex);
2191  } // Active classes
2192
2193
2194  activeSlide.addClass(params.slideActiveClass);
2195
2196  if (params.loop) {
2197    // Duplicate to all looped slides
2198    if (activeSlide.hasClass(params.slideDuplicateClass)) {
2199      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
2200    } else {
2201      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
2202    }
2203  } // Next Slide
2204
2205
2206  let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);
2207
2208  if (params.loop && nextSlide.length === 0) {
2209    nextSlide = slides.eq(0);
2210    nextSlide.addClass(params.slideNextClass);
2211  } // Prev Slide
2212
2213
2214  let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);
2215
2216  if (params.loop && prevSlide.length === 0) {
2217    prevSlide = slides.eq(-1);
2218    prevSlide.addClass(params.slidePrevClass);
2219  }
2220
2221  if (params.loop) {
2222    // Duplicate to all looped slides
2223    if (nextSlide.hasClass(params.slideDuplicateClass)) {
2224      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicateNextClass);
2225    } else {
2226      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicateNextClass);
2227    }
2228
2229    if (prevSlide.hasClass(params.slideDuplicateClass)) {
2230      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicatePrevClass);
2231    } else {
2232      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicatePrevClass);
2233    }
2234  }
2235
2236  swiper.emitSlidesClasses();
2237}
2238
2239function updateActiveIndex(newActiveIndex) {
2240  const swiper = this;
2241  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2242  const {
2243    slidesGrid,
2244    snapGrid,
2245    params,
2246    activeIndex: previousIndex,
2247    realIndex: previousRealIndex,
2248    snapIndex: previousSnapIndex
2249  } = swiper;
2250  let activeIndex = newActiveIndex;
2251  let snapIndex;
2252
2253  if (typeof activeIndex === 'undefined') {
2254    for (let i = 0; i < slidesGrid.length; i += 1) {
2255      if (typeof slidesGrid[i + 1] !== 'undefined') {
2256        if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
2257          activeIndex = i;
2258        } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
2259          activeIndex = i + 1;
2260        }
2261      } else if (translate >= slidesGrid[i]) {
2262        activeIndex = i;
2263      }
2264    } // Normalize slideIndex
2265
2266
2267    if (params.normalizeSlideIndex) {
2268      if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
2269    }
2270  }
2271
2272  if (snapGrid.indexOf(translate) >= 0) {
2273    snapIndex = snapGrid.indexOf(translate);
2274  } else {
2275    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
2276    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
2277  }
2278
2279  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2280
2281  if (activeIndex === previousIndex) {
2282    if (snapIndex !== previousSnapIndex) {
2283      swiper.snapIndex = snapIndex;
2284      swiper.emit('snapIndexChange');
2285    }
2286
2287    return;
2288  } // Get real index
2289
2290
2291  const realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);
2292  Object.assign(swiper, {
2293    snapIndex,
2294    realIndex,
2295    previousIndex,
2296    activeIndex
2297  });
2298  swiper.emit('activeIndexChange');
2299  swiper.emit('snapIndexChange');
2300
2301  if (previousRealIndex !== realIndex) {
2302    swiper.emit('realIndexChange');
2303  }
2304
2305  if (swiper.initialized || swiper.params.runCallbacksOnInit) {
2306    swiper.emit('slideChange');
2307  }
2308}
2309
2310function updateClickedSlide(e) {
2311  const swiper = this;
2312  const params = swiper.params;
2313  const slide = $(e).closest(`.${params.slideClass}`)[0];
2314  let slideFound = false;
2315  let slideIndex;
2316
2317  if (slide) {
2318    for (let i = 0; i < swiper.slides.length; i += 1) {
2319      if (swiper.slides[i] === slide) {
2320        slideFound = true;
2321        slideIndex = i;
2322        break;
2323      }
2324    }
2325  }
2326
2327  if (slide && slideFound) {
2328    swiper.clickedSlide = slide;
2329
2330    if (swiper.virtual && swiper.params.virtual.enabled) {
2331      swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);
2332    } else {
2333      swiper.clickedIndex = slideIndex;
2334    }
2335  } else {
2336    swiper.clickedSlide = undefined;
2337    swiper.clickedIndex = undefined;
2338    return;
2339  }
2340
2341  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
2342    swiper.slideToClickedSlide();
2343  }
2344}
2345
2346var update = {
2347  updateSize,
2348  updateSlides,
2349  updateAutoHeight,
2350  updateSlidesOffset,
2351  updateSlidesProgress,
2352  updateProgress,
2353  updateSlidesClasses,
2354  updateActiveIndex,
2355  updateClickedSlide
2356};
2357
2358function getSwiperTranslate(axis) {
2359  if (axis === void 0) {
2360    axis = this.isHorizontal() ? 'x' : 'y';
2361  }
2362
2363  const swiper = this;
2364  const {
2365    params,
2366    rtlTranslate: rtl,
2367    translate,
2368    $wrapperEl
2369  } = swiper;
2370
2371  if (params.virtualTranslate) {
2372    return rtl ? -translate : translate;
2373  }
2374
2375  if (params.cssMode) {
2376    return translate;
2377  }
2378
2379  let currentTranslate = getTranslate($wrapperEl[0], axis);
2380  if (rtl) currentTranslate = -currentTranslate;
2381  return currentTranslate || 0;
2382}
2383
2384function setTranslate(translate, byController) {
2385  const swiper = this;
2386  const {
2387    rtlTranslate: rtl,
2388    params,
2389    $wrapperEl,
2390    wrapperEl,
2391    progress
2392  } = swiper;
2393  let x = 0;
2394  let y = 0;
2395  const z = 0;
2396
2397  if (swiper.isHorizontal()) {
2398    x = rtl ? -translate : translate;
2399  } else {
2400    y = translate;
2401  }
2402
2403  if (params.roundLengths) {
2404    x = Math.floor(x);
2405    y = Math.floor(y);
2406  }
2407
2408  if (params.cssMode) {
2409    wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
2410  } else if (!params.virtualTranslate) {
2411    $wrapperEl.transform(`translate3d(${x}px, ${y}px, ${z}px)`);
2412  }
2413
2414  swiper.previousTranslate = swiper.translate;
2415  swiper.translate = swiper.isHorizontal() ? x : y; // Check if we need to update progress
2416
2417  let newProgress;
2418  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2419
2420  if (translatesDiff === 0) {
2421    newProgress = 0;
2422  } else {
2423    newProgress = (translate - swiper.minTranslate()) / translatesDiff;
2424  }
2425
2426  if (newProgress !== progress) {
2427    swiper.updateProgress(translate);
2428  }
2429
2430  swiper.emit('setTranslate', swiper.translate, byController);
2431}
2432
2433function minTranslate() {
2434  return -this.snapGrid[0];
2435}
2436
2437function maxTranslate() {
2438  return -this.snapGrid[this.snapGrid.length - 1];
2439}
2440
2441function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
2442  if (translate === void 0) {
2443    translate = 0;
2444  }
2445
2446  if (speed === void 0) {
2447    speed = this.params.speed;
2448  }
2449
2450  if (runCallbacks === void 0) {
2451    runCallbacks = true;
2452  }
2453
2454  if (translateBounds === void 0) {
2455    translateBounds = true;
2456  }
2457
2458  const swiper = this;
2459  const {
2460    params,
2461    wrapperEl
2462  } = swiper;
2463
2464  if (swiper.animating && params.preventInteractionOnTransition) {
2465    return false;
2466  }
2467
2468  const minTranslate = swiper.minTranslate();
2469  const maxTranslate = swiper.maxTranslate();
2470  let newTranslate;
2471  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate; // Update progress
2472
2473  swiper.updateProgress(newTranslate);
2474
2475  if (params.cssMode) {
2476    const isH = swiper.isHorizontal();
2477
2478    if (speed === 0) {
2479      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
2480    } else {
2481      if (!swiper.support.smoothScroll) {
2482        animateCSSModeScroll({
2483          swiper,
2484          targetPosition: -newTranslate,
2485          side: isH ? 'left' : 'top'
2486        });
2487        return true;
2488      }
2489
2490      wrapperEl.scrollTo({
2491        [isH ? 'left' : 'top']: -newTranslate,
2492        behavior: 'smooth'
2493      });
2494    }
2495
2496    return true;
2497  }
2498
2499  if (speed === 0) {
2500    swiper.setTransition(0);
2501    swiper.setTranslate(newTranslate);
2502
2503    if (runCallbacks) {
2504      swiper.emit('beforeTransitionStart', speed, internal);
2505      swiper.emit('transitionEnd');
2506    }
2507  } else {
2508    swiper.setTransition(speed);
2509    swiper.setTranslate(newTranslate);
2510
2511    if (runCallbacks) {
2512      swiper.emit('beforeTransitionStart', speed, internal);
2513      swiper.emit('transitionStart');
2514    }
2515
2516    if (!swiper.animating) {
2517      swiper.animating = true;
2518
2519      if (!swiper.onTranslateToWrapperTransitionEnd) {
2520        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
2521          if (!swiper || swiper.destroyed) return;
2522          if (e.target !== this) return;
2523          swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2524          swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2525          swiper.onTranslateToWrapperTransitionEnd = null;
2526          delete swiper.onTranslateToWrapperTransitionEnd;
2527
2528          if (runCallbacks) {
2529            swiper.emit('transitionEnd');
2530          }
2531        };
2532      }
2533
2534      swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2535      swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2536    }
2537  }
2538
2539  return true;
2540}
2541
2542var translate = {
2543  getTranslate: getSwiperTranslate,
2544  setTranslate,
2545  minTranslate,
2546  maxTranslate,
2547  translateTo
2548};
2549
2550function setTransition(duration, byController) {
2551  const swiper = this;
2552
2553  if (!swiper.params.cssMode) {
2554    swiper.$wrapperEl.transition(duration);
2555  }
2556
2557  swiper.emit('setTransition', duration, byController);
2558}
2559
2560function transitionEmit(_ref) {
2561  let {
2562    swiper,
2563    runCallbacks,
2564    direction,
2565    step
2566  } = _ref;
2567  const {
2568    activeIndex,
2569    previousIndex
2570  } = swiper;
2571  let dir = direction;
2572
2573  if (!dir) {
2574    if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
2575  }
2576
2577  swiper.emit(`transition${step}`);
2578
2579  if (runCallbacks && activeIndex !== previousIndex) {
2580    if (dir === 'reset') {
2581      swiper.emit(`slideResetTransition${step}`);
2582      return;
2583    }
2584
2585    swiper.emit(`slideChangeTransition${step}`);
2586
2587    if (dir === 'next') {
2588      swiper.emit(`slideNextTransition${step}`);
2589    } else {
2590      swiper.emit(`slidePrevTransition${step}`);
2591    }
2592  }
2593}
2594
2595function transitionStart(runCallbacks, direction) {
2596  if (runCallbacks === void 0) {
2597    runCallbacks = true;
2598  }
2599
2600  const swiper = this;
2601  const {
2602    params
2603  } = swiper;
2604  if (params.cssMode) return;
2605
2606  if (params.autoHeight) {
2607    swiper.updateAutoHeight();
2608  }
2609
2610  transitionEmit({
2611    swiper,
2612    runCallbacks,
2613    direction,
2614    step: 'Start'
2615  });
2616}
2617
2618function transitionEnd(runCallbacks, direction) {
2619  if (runCallbacks === void 0) {
2620    runCallbacks = true;
2621  }
2622
2623  const swiper = this;
2624  const {
2625    params
2626  } = swiper;
2627  swiper.animating = false;
2628  if (params.cssMode) return;
2629  swiper.setTransition(0);
2630  transitionEmit({
2631    swiper,
2632    runCallbacks,
2633    direction,
2634    step: 'End'
2635  });
2636}
2637
2638var transition = {
2639  setTransition,
2640  transitionStart,
2641  transitionEnd
2642};
2643
2644function slideTo(index, speed, runCallbacks, internal, initial) {
2645  if (index === void 0) {
2646    index = 0;
2647  }
2648
2649  if (speed === void 0) {
2650    speed = this.params.speed;
2651  }
2652
2653  if (runCallbacks === void 0) {
2654    runCallbacks = true;
2655  }
2656
2657  if (typeof index !== 'number' && typeof index !== 'string') {
2658    throw new Error(`The 'index' argument cannot have type other than 'number' or 'string'. [${typeof index}] given.`);
2659  }
2660
2661  if (typeof index === 'string') {
2662    /**
2663     * The `index` argument converted from `string` to `number`.
2664     * @type {number}
2665     */
2666    const indexAsNumber = parseInt(index, 10);
2667    /**
2668     * Determines whether the `index` argument is a valid `number`
2669     * after being converted from the `string` type.
2670     * @type {boolean}
2671     */
2672
2673    const isValidNumber = isFinite(indexAsNumber);
2674
2675    if (!isValidNumber) {
2676      throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);
2677    } // Knowing that the converted `index` is a valid number,
2678    // we can update the original argument's value.
2679
2680
2681    index = indexAsNumber;
2682  }
2683
2684  const swiper = this;
2685  let slideIndex = index;
2686  if (slideIndex < 0) slideIndex = 0;
2687  const {
2688    params,
2689    snapGrid,
2690    slidesGrid,
2691    previousIndex,
2692    activeIndex,
2693    rtlTranslate: rtl,
2694    wrapperEl,
2695    enabled
2696  } = swiper;
2697
2698  if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
2699    return false;