https://www.accessbankplc.com/scripts/js/swiper.js

1/**
2 * Swiper 6.3.3
3 * Most modern mobile touch slider and framework with hardware accelerated transitions
4 * http://swiperjs.com
5 *
6 * Copyright 2014-2020 Vladimir Kharlampidi
7 *
8 * Released under the MIT License
9 *
10 * Released on: October 9, 2020
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 = global || self, global.Swiper = factory());
17}(this, (function () { 'use strict';
18
19  function _defineProperties(target, props) {
20    for (var i = 0; i < props.length; i++) {
21      var descriptor = props[i];
22      descriptor.enumerable = descriptor.enumerable || false;
23      descriptor.configurable = true;
24      if ("value" in descriptor) descriptor.writable = true;
25      Object.defineProperty(target, descriptor.key, descriptor);
26    }
27  }
28
29  function _createClass(Constructor, protoProps, staticProps) {
30    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
31    if (staticProps) _defineProperties(Constructor, staticProps);
32    return Constructor;
33  }
34
35  function _extends() {
36    _extends = Object.assign || function (target) {
37      for (var i = 1; i < arguments.length; i++) {
38        var source = arguments[i];
39
40        for (var key in source) {
41          if (Object.prototype.hasOwnProperty.call(source, key)) {
42            target[key] = source[key];
43          }
44        }
45      }
46
47      return target;
48    };
49
50    return _extends.apply(this, arguments);
51  }
52
53  /**
54   * SSR Window 3.0.0-alpha.4
55   * Better handling for window object in SSR environment
56   * https://github.com/nolimits4web/ssr-window
57   *
58   * Copyright 2020, Vladimir Kharlampidi
59   *
60   * Licensed under MIT
61   *
62   * Released on: May 20, 2020
63   */
64
65  /* eslint-disable no-param-reassign */
66  function isObject(obj) {
67    return obj !== null && typeof obj === 'object' && 'constructor' in obj && obj.constructor === Object;
68  }
69
70  function extend(target, src) {
71    if (target === void 0) {
72      target = {};
73    }
74
75    if (src === void 0) {
76      src = {};
77    }
78
79    Object.keys(src).forEach(function (key) {
80      if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject(src[key]) && isObject(target[key]) && Object.keys(src[key]).length > 0) {
81        extend(target[key], src[key]);
82      }
83    });
84  }
85
86  var ssrDocument = {
87    body: {},
88    addEventListener: function addEventListener() {},
89    removeEventListener: function removeEventListener() {},
90    activeElement: {
91      blur: function blur() {},
92      nodeName: ''
93    },
94    querySelector: function querySelector() {
95      return null;
96    },
97    querySelectorAll: function querySelectorAll() {
98      return [];
99    },
100    getElementById: function getElementById() {
101      return null;
102    },
103    createEvent: function createEvent() {
104      return {
105        initEvent: function initEvent() {}
106      };
107    },
108    createElement: function createElement() {
109      return {
110        children: [],
111        childNodes: [],
112        style: {},
113        setAttribute: function setAttribute() {},
114        getElementsByTagName: function getElementsByTagName() {
115          return [];
116        }
117      };
118    },
119    createElementNS: function createElementNS() {
120      return {};
121    },
122    importNode: function importNode() {
123      return null;
124    },
125    location: {
126      hash: '',
127      host: '',
128      hostname: '',
129      href: '',
130      origin: '',
131      pathname: '',
132      protocol: '',
133      search: ''
134    }
135  };
136
137  function getDocument() {
138    var doc = typeof document !== 'undefined' ? document : {};
139    extend(doc, ssrDocument);
140    return doc;
141  }
142
143  var ssrWindow = {
144    document: ssrDocument,
145    navigator: {
146      userAgent: ''
147    },
148    location: {
149      hash: '',
150      host: '',
151      hostname: '',
152      href: '',
153      origin: '',
154      pathname: '',
155      protocol: '',
156      search: ''
157    },
158    history: {
159      replaceState: function replaceState() {},
160      pushState: function pushState() {},
161      go: function go() {},
162      back: function back() {}
163    },
164    CustomEvent: function CustomEvent() {
165      return this;
166    },
167    addEventListener: function addEventListener() {},
168    removeEventListener: function removeEventListener() {},
169    getComputedStyle: function getComputedStyle() {
170      return {
171        getPropertyValue: function getPropertyValue() {
172          return '';
173        }
174      };
175    },
176    Image: function Image() {},
177    Date: function Date() {},
178    screen: {},
179    setTimeout: function setTimeout() {},
180    clearTimeout: function clearTimeout() {},
181    matchMedia: function matchMedia() {
182      return {};
183    },
184    requestAnimationFrame: function requestAnimationFrame(callback) {
185      if (typeof setTimeout === 'undefined') {
186        callback();
187        return null;
188      }
189
190      return setTimeout(callback, 0);
191    },
192    cancelAnimationFrame: function cancelAnimationFrame(id) {
193      if (typeof setTimeout === 'undefined') {
194        return;
195      }
196
197      clearTimeout(id);
198    }
199  };
200
201  function getWindow() {
202    var win = typeof window !== 'undefined' ? window : {};
203    extend(win, ssrWindow);
204    return win;
205  }
206
207  /**
208   * Dom7 3.0.0-alpha.7
209   * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API
210   * https://framework7.io/docs/dom7.html
211   *
212   * Copyright 2020, Vladimir Kharlampidi
213   *
214   * Licensed under MIT
215   *
216   * Released on: July 14, 2020
217   */
218
219  function _inheritsLoose(subClass, superClass) {
220    subClass.prototype = Object.create(superClass.prototype);
221    subClass.prototype.constructor = subClass;
222    subClass.__proto__ = superClass;
223  }
224

225  function _getPrototypeOf(o) {
226    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
227      return o.__proto__ || Object.getPrototypeOf(o);
228    };
229    return _getPrototypeOf(o);
230  }
231
232  function _setPrototypeOf(o, p) {
233    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
234      o.__proto__ = p;
235      return o;
236    };
237
238    return _setPrototypeOf(o, p);
239  }
240
241  function _isNativeReflectConstruct() {
242    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
243    if (Reflect.construct.sham) return false;
244    if (typeof Proxy === "function") return true;
245
246    try {
247      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
248      return true;
249    } catch (e) {
250      return false;
251    }
252  }
253
254  function _construct(Parent, args, Class) {
255    if (_isNativeReflectConstruct()) {
256      _construct = Reflect.construct;
257    } else {
258      _construct = function _construct(Parent, args, Class) {
259        var a = [null];
260        a.push.apply(a, args);
261        var Constructor = Function.bind.apply(Parent, a);
262        var instance = new Constructor();
263        if (Class) _setPrototypeOf(instance, Class.prototype);
264        return instance;
265      };
266    }
267
268    return _construct.apply(null, arguments);
269  }
270
271  function _isNativeFunction(fn) {
272    return Function.toString.call(fn).indexOf("[native code]") !== -1;
273  }
274
275  function _wrapNativeSuper(Class) {
276    var _cache = typeof Map === "function" ? new Map() : undefined;
277
278    _wrapNativeSuper = function _wrapNativeSuper(Class) {
279      if (Class === null || !_isNativeFunction(Class)) return Class;
280
281      if (typeof Class !== "function") {
282        throw new TypeError("Super expression must either be null or a function");
283      }
284
285      if (typeof _cache !== "undefined") {
286        if (_cache.has(Class)) return _cache.get(Class);
287
288        _cache.set(Class, Wrapper);
289      }
290
291      function Wrapper() {
292        return _construct(Class, arguments, _getPrototypeOf(this).constructor);
293      }
294
295      Wrapper.prototype = Object.create(Class.prototype, {
296        constructor: {
297          value: Wrapper,
298          enumerable: false,
299          writable: true,
300          configurable: true
301        }
302      });
303      return _setPrototypeOf(Wrapper, Class);
304    };
305
306    return _wrapNativeSuper(Class);
307  }
308
309  function _assertThisInitialized(self) {
310    if (self === void 0) {
311      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
312    }
313
314    return self;
315  }
316  /* eslint-disable no-proto */
317
318
319  function makeReactive(obj) {
320    var proto = obj.__proto__;
321    Object.defineProperty(obj, '__proto__', {
322      get: function get() {
323        return proto;
324      },
325      set: function set(value) {
326        proto.__proto__ = value;
327      }
328    });
329  }
330
331  var Dom7 = /*#__PURE__*/function (_Array) {
332    _inheritsLoose(Dom7, _Array);
333
334    function Dom7(items) {
335      var _this;
336
337      _this = _Array.call.apply(_Array, [this].concat(items)) || this;
338      makeReactive(_assertThisInitialized(_this));
339      return _this;
340    }
341
342    return Dom7;
343  }( /*#__PURE__*/_wrapNativeSuper(Array));
344
345  function arrayFlat(arr) {
346    if (arr === void 0) {
347      arr = [];
348    }
349
350    var res = [];
351    arr.forEach(function (el) {
352      if (Array.isArray(el)) {
353        res.push.apply(res, arrayFlat(el));
354      } else {
355        res.push(el);
356      }
357    });
358    return res;
359  }
360
361  function arrayFilter(arr, callback) {
362    return Array.prototype.filter.call(arr, callback);
363  }
364
365  function arrayUnique(arr) {
366    var uniqueArray = [];
367
368    for (var i = 0; i < arr.length; i += 1) {
369      if (uniqueArray.indexOf(arr[i]) === -1) uniqueArray.push(arr[i]);
370    }
371
372    return uniqueArray;
373  }
374
375  function qsa(selector, context) {
376    if (typeof selector !== 'string') {
377      return [selector];
378    }
379
380    var a = [];
381    var res = context.querySelectorAll(selector);
382
383    for (var i = 0; i < res.length; i += 1) {
384      a.push(res[i]);
385    }
386
387    return a;
388  }
389
390  function $(selector, context) {
391    var window = getWindow();
392    var document = getDocument();
393    var arr = [];
394
395    if (!context && selector instanceof Dom7) {
396      return selector;
397    }
398
399    if (!selector) {
400      return new Dom7(arr);
401    }
402
403    if (typeof selector === 'string') {
404      var html = selector.trim();
405
406      if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {
407        var toCreate = 'div';
408        if (html.indexOf('<li') === 0) toCreate = 'ul';
409        if (html.indexOf('<tr') === 0) toCreate = 'tbody';
410        if (html.indexOf('<td') === 0 || html.indexOf('<th') === 0) toCreate = 'tr';
411        if (html.indexOf('<tbody') === 0) toCreate = 'table';
412        if (html.indexOf('<option') === 0) toCreate = 'select';
413        var tempParent = document.createElement(toCreate);
414        tempParent.innerHTML = html;
415
416        for (var i = 0; i < tempParent.childNodes.length; i += 1) {
417          arr.push(tempParent.childNodes[i]);
418        }
419      } else {
420        arr = qsa(selector.trim(), context || document);
421      } // arr = qsa(selector, document);
422
423    } else if (selector.nodeType || selector === window || selector === document) {
424      arr.push(selector);
425    } else if (Array.isArray(selector)) {
426      if (selector instanceof Dom7) return selector;
427      arr = selector;
428    }
429
430    return new Dom7(arrayUnique(arr));
431  }
432
433  $.fn = Dom7.prototype;
434
435  function addClass() {
436    for (var _len = arguments.length, classes = new Array(_len), _key = 0; _key < _len; _key++) {
437      classes[_key] = arguments[_key];
438    }
439
440    var classNames = arrayFlat(classes.map(function (c) {
441      return c.split(' ');
442    }));
443    this.forEach(function (el) {
444      var _el$classList;
445
446      (_el$classList = el.classList).add.apply(_el$classList, classNames);
447    });

448    return this;
449  }
450
451  function removeClass() {
452    for (var _len2 = arguments.length, classes = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
453      classes[_key2] = arguments[_key2];
454    }
455
456    var classNames = arrayFlat(classes.map(function (c) {
457      return c.split(' ');
458    }));
459    this.forEach(function (el) {
460      var _el$classList2;
461
462      (_el$classList2 = el.classList).remove.apply(_el$classList2, classNames);
463    });
464    return this;
465  }
466
467  function toggleClass() {
468    for (var _len3 = arguments.length, classes = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
469      classes[_key3] = arguments[_key3];
470    }
471
472    var classNames = arrayFlat(classes.map(function (c) {
473      return c.split(' ');
474    }));
475    this.forEach(function (el) {
476      classNames.forEach(function (className) {
477        el.classList.toggle(className);
478      });
479    });
480  }
481
482  function hasClass() {
483    for (var _len4 = arguments.length, classes = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
484      classes[_key4] = arguments[_key4];
485    }
486
487    var classNames = arrayFlat(classes.map(function (c) {
488      return c.split(' ');
489    }));
490    return arrayFilter(this, function (el) {
491      return classNames.filter(function (className) {
492        return el.classList.contains(className);
493      }).length > 0;
494    }).length > 0;
495  }
496
497  function attr(attrs, value) {
498    if (arguments.length === 1 && typeof attrs === 'string') {
499      // Get attr
500      if (this[0]) return this[0].getAttribute(attrs);
501      return undefined;
502    } // Set attrs
503
504
505    for (var i = 0; i < this.length; i += 1) {
506      if (arguments.length === 2) {
507        // String
508        this[i].setAttribute(attrs, value);
509      } else {
510        // Object
511        for (var attrName in attrs) {
512          this[i][attrName] = attrs[attrName];
513          this[i].setAttribute(attrName, attrs[attrName]);
514        }
515      }
516    }
517
518    return this;
519  }
520
521  function removeAttr(attr) {
522    for (var i = 0; i < this.length; i += 1) {
523      this[i].removeAttribute(attr);
524    }
525
526    return this;
527  }
528
529  function transform(transform) {
530    for (var i = 0; i < this.length; i += 1) {
531      this[i].style.transform = transform;
532    }
533
534    return this;
535  }
536
537  function transition(duration) {
538    for (var i = 0; i < this.length; i += 1) {
539      this[i].style.transition = typeof duration !== 'string' ? duration + "ms" : duration;
540    }
541
542    return this;
543  }
544
545  function on() {
546    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
547      args[_key5] = arguments[_key5];
548    }
549
550    var eventType = args[0],
551        targetSelector = args[1],
552        listener = args[2],
553        capture = args[3];
554
555    if (typeof args[1] === 'function') {
556      eventType = args[0];
557      listener = args[1];
558      capture = args[2];
559      targetSelector = undefined;
560    }
561
562    if (!capture) capture = false;
563
564    function handleLiveEvent(e) {
565      var target = e.target;
566      if (!target) return;
567      var eventData = e.target.dom7EventData || [];
568
569      if (eventData.indexOf(e) < 0) {
570        eventData.unshift(e);
571      }
572
573      if ($(target).is(targetSelector)) listener.apply(target, eventData);else {
574        var _parents = $(target).parents(); // eslint-disable-line
575
576
577        for (var k = 0; k < _parents.length; k += 1) {
578          if ($(_parents[k]).is(targetSelector)) listener.apply(_parents[k], eventData);
579        }
580      }
581    }
582
583    function handleEvent(e) {
584      var eventData = e && e.target ? e.target.dom7EventData || [] : [];
585
586      if (eventData.indexOf(e) < 0) {
587        eventData.unshift(e);
588      }
589
590      listener.apply(this, eventData);
591    }
592
593    var events = eventType.split(' ');
594    var j;
595
596    for (var i = 0; i < this.length; i += 1) {
597      var el = this[i];
598
599      if (!targetSelector) {
600        for (j = 0; j < events.length; j += 1) {
601          var event = events[j];
602          if (!el.dom7Listeners) el.dom7Listeners = {};
603          if (!el.dom7Listeners[event]) el.dom7Listeners[event] = [];
604          el.dom7Listeners[event].push({
605            listener: listener,
606            proxyListener: handleEvent
607          });
608          el.addEventListener(event, handleEvent, capture);
609        }
610      } else {
611        // Live events
612        for (j = 0; j < events.length; j += 1) {
613          var _event = events[j];
614          if (!el.dom7LiveListeners) el.dom7LiveListeners = {};
615          if (!el.dom7LiveListeners[_event]) el.dom7LiveListeners[_event] = [];
616
617          el.dom7LiveListeners[_event].push({
618            listener: listener,
619            proxyListener: handleLiveEvent
620          });
621
622          el.addEventListener(_event, handleLiveEvent, capture);
623        }
624      }
625    }
626
627    return this;
628  }
629
630  function off() {
631    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
632      args[_key6] = arguments[_key6];
633    }
634
635    var eventType = args[0],
636        targetSelector = args[1],
637        listener = args[2],
638        capture = args[3];
639
640    if (typeof args[1] === 'function') {
641      eventType = args[0];
642      listener = args[1];
643      capture = args[2];
644      targetSelector = undefined;
645    }
646
647    if (!capture) capture = false;
648    var events = eventType.split(' ');
649
650    for (var i = 0; i < events.length; i += 1) {
651      var event = events[i];
652
653      for (var j = 0; j < this.length; j += 1) {
654        var el = this[j];
655        var handlers = void 0;
656
657        if (!targetSelector && el.dom7Listeners) {
658          handlers = el.dom7Listeners[event];
659        }

659 else if (targetSelector && el.dom7LiveListeners) {
660          handlers = el.dom7LiveListeners[event];
661        }
662
663        if (handlers && handlers.length) {
664          for (var k = handlers.length - 1; k >= 0; k -= 1) {
665            var handler = handlers[k];
666
667            if (listener && handler.listener === listener) {
668              el.removeEventListener(event, handler.proxyListener, capture);
669              handlers.splice(k, 1);
670            } else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) {
671              el.removeEventListener(event, handler.proxyListener, capture);
672              handlers.splice(k, 1);
673            } else if (!listener) {
674              el.removeEventListener(event, handler.proxyListener, capture);
675              handlers.splice(k, 1);
676            }
677          }
678        }
679      }
680    }
681
682    return this;
683  }
684
685  function trigger() {
686    var window = getWindow();
687
688    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
689      args[_key9] = arguments[_key9];
690    }
691
692    var events = args[0].split(' ');
693    var eventData = args[1];
694
695    for (var i = 0; i < events.length; i += 1) {
696      var event = events[i];
697
698      for (var j = 0; j < this.length; j += 1) {
699        var el = this[j];
700
701        if (window.CustomEvent) {
702          var evt = new window.CustomEvent(event, {
703            detail: eventData,
704            bubbles: true,
705            cancelable: true
706          });
707          el.dom7EventData = args.filter(function (data, dataIndex) {
708            return dataIndex > 0;
709          });
710          el.dispatchEvent(evt);
711          el.dom7EventData = [];
712          delete el.dom7EventData;
713        }
714      }
715    }
716
717    return this;
718  }
719
720  function transitionEnd(callback) {
721    var dom = this;
722
723    function fireCallBack(e) {
724      if (e.target !== this) return;
725      callback.call(this, e);
726      dom.off('transitionend', fireCallBack);
727    }
728
729    if (callback) {
730      dom.on('transitionend', fireCallBack);
731    }
732
733    return this;
734  }
735
736  function outerWidth(includeMargins) {
737    if (this.length > 0) {
738      if (includeMargins) {
739        var _styles = this.styles();
740
741        return this[0].offsetWidth + parseFloat(_styles.getPropertyValue('margin-right')) + parseFloat(_styles.getPropertyValue('margin-left'));
742      }
743
744      return this[0].offsetWidth;
745    }
746
747    return null;
748  }
749
750  function outerHeight(includeMargins) {
751    if (this.length > 0) {
752      if (includeMargins) {
753        var _styles2 = this.styles();
754
755        return this[0].offsetHeight + parseFloat(_styles2.getPropertyValue('margin-top')) + parseFloat(_styles2.getPropertyValue('margin-bottom'));
756      }
757
758      return this[0].offsetHeight;
759    }
760
761    return null;
762  }
763
764  function offset() {
765    if (this.length > 0) {
766      var window = getWindow();
767      var document = getDocument();
768      var el = this[0];
769      var box = el.getBoundingClientRect();
770      var body = document.body;
771      var clientTop = el.clientTop || body.clientTop || 0;
772      var clientLeft = el.clientLeft || body.clientLeft || 0;
773      var scrollTop = el === window ? window.scrollY : el.scrollTop;
774      var scrollLeft = el === window ? window.scrollX : el.scrollLeft;
775      return {
776        top: box.top + scrollTop - clientTop,
777        left: box.left + scrollLeft - clientLeft
778      };
779    }
780
781    return null;
782  }
783
784  function styles() {
785    var window = getWindow();
786    if (this[0]) return window.getComputedStyle(this[0], null);
787    return {};
788  }
789
790  function css(props, value) {
791    var window = getWindow();
792    var i;
793
794    if (arguments.length === 1) {
795      if (typeof props === 'string') {
796        // .css('width')
797        if (this[0]) return window.getComputedStyle(this[0], null).getPropertyValue(props);
798      } else {
799        // .css({ width: '100px' })
800        for (i = 0; i < this.length; i += 1) {
801          for (var _prop in props) {
802            this[i].style[_prop] = props[_prop];
803          }
804        }
805
806        return this;
807      }
808    }
809
810    if (arguments.length === 2 && typeof props === 'string') {
811      // .css('width', '100px')
812      for (i = 0; i < this.length; i += 1) {
813        this[i].style[props] = value;
814      }
815
816      return this;
817    }
818
819    return this;
820  }
821
822  function each(callback) {
823    if (!callback) return this;
824    this.forEach(function (el, index) {
825      callback.apply(el, [el, index]);
826    });

827    return this;
828  }
829
830  function filter(callback) {
831    var result = arrayFilter(this, callback);
832    return $(result);
833  }
834
835  function html(html) {
836    if (typeof html === 'undefined') {
837      return this[0] ? this[0].innerHTML : null;
838    }
839
840    for (var i = 0; i < this.length; i += 1) {
841      this[i].innerHTML = html;
842    }
843
844    return this;
845  }
846
847  function text(text) {
848    if (typeof text === 'undefined') {
849      return this[0] ? this[0].textContent.trim() : null;
850    }
851
852    for (var i = 0; i < this.length; i += 1) {
853      this[i].textContent = text;
854    }
855
856    return this;
857  }
858
859  function is(selector) {
860    var window = getWindow();
861    var document = getDocument();
862    var el = this[0];
863    var compareWith;
864    var i;
865    if (!el || typeof selector === 'undefined') return false;
866
867    if (typeof selector === 'string') {
868      if (el.matches) return el.matches(selector);
869      if (el.webkitMatchesSelector) return el.webkitMatchesSelector(selector);
870      if (el.msMatchesSelector) return el.msMatchesSelector(selector);
871      compareWith = $(selector);
872
873      for (i = 0; i < compareWith.length; i += 1) {
874        if (compareWith[i] === el) return true;
875      }
876
877      return false;
878    }
879
880    if (selector === document) {
881      return el === document;
882    }
883
884    if (selector === window) {
885      return el === window;
886    }
887
888    if (selector.nodeType || selector instanceof Dom7) {
889      compareWith = selector.nodeType ? [selector] : selector;
890
891      for (i = 0; i < compareWith.length; i += 1) {
892        if (compareWith[i] === el) return true;
893      }
894
895      return false;
896    }
897
898    return false;
899  }
900
901  function index() {
902    var child = this[0];
903    var i;
904
905    if (child) {
906      i = 0; // eslint-disable-next-line
907
908      while ((child = child.previousSibling) !== null) {
909        if (child.nodeType === 1) i += 1;
910      }
911
912      return i;
913    }
914
915    return undefined;
916  }
917
918  function eq(index) {
919    if (typeof index === 'undefined') return this;
920    var length = this.length;
921
922    if (index > length - 1) {
923      return $([]);
924    }
925
926    if (index < 0) {
927      var returnIndex = length + index;
928      if (returnIndex < 0) return $([]);
929      return $([this[returnIndex]]);
930    }
931
932    return $([this[index]]);
933  }
934
935  function append() {
936    var newChild;
937    var document = getDocument();
938
939    for (var k = 0; k < arguments.length; k += 1) {
940      newChild = k < 0 || arguments.length <= k ? undefined : arguments[k];
941
942      for (var i = 0; i < this.length; i += 1) {
943        if (typeof newChild === 'string') {
944          var tempDiv = document.createElement('div');
945          tempDiv.innerHTML = newChild;
946
947          while (tempDiv.firstChild) {
948            this[i].appendChild(tempDiv.firstChild);
949          }
950        } else if (newChild instanceof Dom7) {
951          for (var j = 0; j < newChild.length; j += 1) {
952            this[i].appendChild(newChild[j]);
953          }
954        } else {
955          this[i].appendChild(newChild);
956        }
957      }
958    }
959
960    return this;
961  }
962
963  function prepend(newChild) {
964    var document = getDocument();
965    var i;
966    var j;
967
968    for (i = 0; i < this.length; i += 1) {
969      if (typeof newChild === 'string') {
970        var tempDiv = document.createElement('div');
971        tempDiv.innerHTML = newChild;
972
973        for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
974          this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
975        }
976      } else if (newChild instanceof Dom7) {
977        for (j = 0; j < newChild.length; j += 1) {
978          this[i].insertBefore(newChild[j], this[i].childNodes[0]);
979        }
980      } else {
981        this[i].insertBefore(newChild, this[i].childNodes[0]);
982      }
983    }
984
985    return this;
986  }
987
988  function next(selector) {
989    if (this.length > 0) {
990      if (selector) {
991        if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {
992          return $([this[0].nextElementSibling]);
993        }
994
995        return $([]);
996      }
997
998      if (this[0].nextElementSibling) return $([this[0].nextElementSibling]);
999      return $([]);
1000    }
1001
1002    return $([]);
1003  }
1004
1005  function nextAll(selector) {
1006    var nextEls = [];
1007    var el = this[0];
1008    if (!el) return $([]);
1009
1010    while (el.nextElementSibling) {
1011      var _next = el.nextElementSibling; // eslint-disable-line
1012
1013      if (selector) {
1014        if ($(_next).is(selector)) nextEls.push(_next);
1015      } else nextEls.push(_next);
1016
1017      el = _next;
1018    }
1019
1020    return $(nextEls);
1021  }
1022
1023  function prev(selector) {
1024    if (this.length > 0) {
1025      var el = this[0];
1026
1027      if (selector) {
1028        if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {
1029          return $([el.previousElementSibling]);
1030        }
1031
1032        return $([]);
1033      }
1034
1035      if (el.previousElementSibling) return $([el.previousElementSibling]);
1036      return $([]);
1037    }
1038
1039    return $([]);
1040  }
1041
1042  function prevAll(selector) {
1043    var prevEls = [];
1044    var el = this[0];
1045    if (!el) return $([]);
1046
1047    while (el.previousElementSibling) {
1048      var _prev = el.previousElementSibling; // eslint-disable-line
1049
1050      if (selector) {
1051        if ($(_prev).is(selector)) prevEls.push(_prev);
1052      } else prevEls.push(_prev);
1053
1054      el = _prev;
1055    }
1056
1057    return $(prevEls);
1058  }
1059
1060  function parent(selector) {
1061    var parents = []; // eslint-disable-line
1062
1063    for (var i = 0; i < this.length; i += 1) {
1064      if (this[i].parentNode !== null) {
1065        if (selector) {
1066          if ($(this[i].parentNode).is(selector)) parents.push(this[i].parentNode);
1067        } else {
1068          parents.push(this[i].parentNode);
1069        }
1070      }
1071    }
1072
1073    return $(parents);
1074  }
1075
1076  function parents(selector) {
1077    var parents = []; // eslint-disable-line
1078
1079    for (var i = 0; i < this.length; i += 1) {
1080      var _parent = this[i].parentNode; // eslint-disable-line
1081
1082      while (_parent) {
1083        if (selector) {
1084          if ($(_parent).is(selector)) parents.push(_parent);
1085        } else {
1086          parents.push(_parent);
1087        }
1088
1089        _parent = _parent.parentNode;
1090      }
1091    }
1092
1093    return $(parents);
1094  }
1095
1096  function closest(selector) {
1097    var closest = this; // eslint-disable-line
1098
1099    if (typeof selector === 'undefined') {
1100      return $([]);
1101    }
1102

1103    if (!closest.is(selector)) {
1104      closest = closest.parents(selector).eq(0);
1105    }
1106
1107    return closest;
1108  }
1109
1110  function find(selector) {
1111    var foundElements = [];
1112
1113    for (var i = 0; i < this.length; i += 1) {
1114      var found = this[i].querySelectorAll(selector);
1115
1116      for (var j = 0; j < found.length; j += 1) {
1117        foundElements.push(found[j]);
1118      }
1119    }
1120
1121    return $(foundElements);
1122  }
1123
1124  function children(selector) {
1125    var children = []; // eslint-disable-line
1126
1127    for (var i = 0; i < this.length; i += 1) {
1128      var childNodes = this[i].children;
1129
1130      for (var j = 0; j < childNodes.length; j += 1) {
1131        if (!selector || $(childNodes[j]).is(selector)) {
1132          children.push(childNodes[j]);
1133        }
1134      }
1135    }
1136
1137    return $(children);
1138  }
1139
1140  function remove() {
1141    for (var i = 0; i < this.length; i += 1) {
1142      if (this[i].parentNode) this[i].parentNode.removeChild(this[i]);
1143    }
1144
1145    return this;
1146  }
1147
1148  var Methods = {
1149    addClass: addClass,
1150    removeClass: removeClass,
1151    hasClass: hasClass,
1152    toggleClass: toggleClass,
1153    attr: attr,
1154    removeAttr: removeAttr,
1155    transform: transform,
1156    transition: transition,
1157    on: on,
1158    off: off,
1159    trigger: trigger,
1160    transitionEnd: transitionEnd,
1161    outerWidth: outerWidth,
1162    outerHeight: outerHeight,
1163    styles: styles,
1164    offset: offset,
1165    css: css,
1166    each: each,
1167    html: html,
1168    text: text,
1169    is: is,
1170    index: index,
1171    eq: eq,
1172    append: append,
1173    prepend: prepend,
1174    next: next,
1175    nextAll: nextAll,
1176    prev: prev,
1177    prevAll: prevAll,
1178    parent: parent,
1179    parents: parents,
1180    closest: closest,
1181    find: find,
1182    children: children,
1183    filter: filter,
1184    remove: remove
1185  };
1186  Object.keys(Methods).forEach(function (methodName) {
1187    $.fn[methodName] = Methods[methodName];
1188  });
1189
1190  function deleteProps(obj) {
1191    var object = obj;
1192    Object.keys(object).forEach(function (key) {
1193      try {
1194        object[key] = null;
1195      } catch (e) {// no getter for object
1196      }
1197
1198      try {
1199        delete object[key];
1200      } catch (e) {// something got wrong
1201      }
1202    });
1203  }
1204
1205  function nextTick(callback, delay) {
1206    if (delay === void 0) {
1207      delay = 0;
1208    }
1209
1210    return setTimeout(callback, delay);
1211  }
1212
1213  function now() {
1214    return Date.now();
1215  }
1216
1217  function getTranslate(el, axis) {
1218    if (axis === void 0) {
1219      axis = 'x';
1220    }
1221
1222    var window = getWindow();
1223    var matrix;
1224    var curTransform;
1225    var transformMatrix;
1226    var curStyle = window.getComputedStyle(el, null);
1227
1228    if (window.WebKitCSSMatrix) {
1229      curTransform = curStyle.transform || curStyle.webkitTransform;
1230
1231      if (curTransform.split(',').length > 6) {
1232        curTransform = curTransform.split(', ').map(function (a) {
1233          return a.replace(',', '.');
1234        }).join(', ');
1235      } // Some old versions of Webkit choke when 'none' is passed; pass
1236      // empty string instead in this case
1237
1238
1239      transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
1240    } else {
1241      transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
1242      matrix = transformMatrix.toString().split(',');
1243    }
1244
1245    if (axis === 'x') {
1246      // Latest Chrome and webkits Fix
1247      if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41; // Crazy IE10 Matrix
1248      else if (matrix.length === 16) curTransform = parseFloat(matrix[12]); // Normal Browsers
1249        else curTransform = parseFloat(matrix[4]);
1250    }
1251
1252    if (axis === 'y') {
1253      // Latest Chrome and webkits Fix
1254      if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42; // Crazy IE10 Matrix
1255      else if (matrix.length === 16) curTransform = parseFloat(matrix[13]); // Normal Browsers
1256        else curTransform = parseFloat(matrix[5]);
1257    }
1258
1259    return curTransform || 0;
1260  }
1261
1262  function isObject$1(o) {
1263    return typeof o === 'object' && o !== null && o.constructor && o.constructor === Object;
1264  }
1265
1266  function extend$1() {
1267    var to = Object(arguments.length <= 0 ? undefined : arguments[0]);
1268
1269    for (var i = 1; i < arguments.length; i += 1) {
1270      var nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
1271
1272      if (nextSource !== undefined && nextSource !== null) {
1273        var keysArray = Object.keys(Object(nextSource));
1274
1275        for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
1276          var nextKey = keysArray[nextIndex];
1277          var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
1278
1279          if (desc !== undefined && desc.enumerable) {
1280            if (isObject$1(to[nextKey]) && isObject$1(nextSource[nextKey])) {
1281              extend$1(to[nextKey], nextSource[nextKey]);
1282            } else if (!isObject$1(to[nextKey]) && isObject$1(nextSource[nextKey])) {
1283              to[nextKey] = {};
1284              extend$1(to[nextKey], nextSource[nextKey]);
1285            } else {
1286              to[nextKey] = nextSource[nextKey];
1287            }
1288          }
1289        }
1290      }
1291    }
1292
1293    return to;
1294  }
1295
1296  function bindModuleMethods(instance, obj) {

1297    Object.keys(obj).forEach(function (key) {
1298      if (isObject$1(obj[key])) {
1299        Object.keys(obj[key]).forEach(function (subKey) {
1300          if (typeof obj[key][subKey] === 'function') {
1301            obj[key][subKey] = obj[key][subKey].bind(instance);
1302          }
1303        });
1304      }
1305
1306      instance[key] = obj[key];
1307    });
1308  }
1309
1310  var support;
1311
1312  function calcSupport() {
1313    var window = getWindow();
1314    var document = getDocument();
1315    return {
1316      touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch),
1317      pointerEvents: !!window.PointerEvent && 'maxTouchPoints' in window.navigator && window.navigator.maxTouchPoints >= 0,
1318      observer: function checkObserver() {
1319        return 'MutationObserver' in window || 'WebkitMutationObserver' in window;
1320      }(),
1321      passiveListener: function checkPassiveListener() {
1322        var supportsPassive = false;
1323
1324        try {
1325          var opts = Object.defineProperty({}, 'passive', {
1326            // eslint-disable-next-line
1327            get: function get() {
1328              supportsPassive = true;
1329            }
1330          });
1331          window.addEventListener('testPassiveListener', null, opts);
1332        } catch (e) {// No support
1333        }
1334
1335        return supportsPassive;
1336      }(),
1337      gestures: function checkGestures() {
1338        return 'ongesturestart' in window;
1339      }()
1340    };
1341  }
1342
1343  function getSupport() {
1344    if (!support) {
1345      support = calcSupport();
1346    }
1347
1348    return support;
1349  }
1350
1351  var device;
1352
1353  function calcDevice(_temp) {
1354    var _ref = _temp === void 0 ? {} : _temp,
1355        userAgent = _ref.userAgent;
1356

1357    var support = getSupport();
1358    var window = getWindow();
1359    var platform = window.navigator.platform;
1360    var ua = userAgent || window.navigator.userAgent;
1361    var device = {
1362      ios: false,
1363      android: false
1364    };
1365    var screenWidth = window.screen.width;
1366    var screenHeight = window.screen.height;
1367    var android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
1368
1369    var ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
1370    var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
1371    var iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
1372    var windows = platform === 'Win32';
1373    var macos = platform === 'MacIntel'; // iPadOs 13 fix
1374
1375    var iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
1376
1377    if (!ipad && macos && support.touch && iPadScreens.indexOf(screenWidth + "x" + screenHeight) >= 0) {
1378      ipad = ua.match(/(Version)\/([\d.]+)/);
1379      if (!ipad) ipad = [0, 1, '13_0_0'];
1380      macos = false;
1381    } // Android
1382
1383
1384    if (android && !windows) {
1385      device.os = 'android';
1386      device.android = true;
1387    }
1388
1389    if (ipad || iphone || ipod) {
1390      device.os = 'ios';
1391      device.ios = true;
1392    } // Export object
1393
1394
1395    return device;
1396  }
1397
1398  function getDevice(overrides) {
1399    if (overrides === void 0) {
1400      overrides = {};
1401    }
1402
1403    if (!device) {
1404      device = calcDevice(overrides);
1405    }
1406
1407    return device;
1408  }
1409
1410  var browser;
1411
1412  function calcBrowser() {
1413    var window = getWindow();
1414
1415    function isSafari() {
1416      var ua = window.navigator.userAgent.toLowerCase();
1417      return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
1418    }
1419
1420    return {
1421      isEdge: !!window.navigator.userAgent.match(/Edge/g),
1422      isSafari: isSafari(),
1423      isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)
1424    };
1425  }
1426
1427  function getBrowser() {
1428    if (!browser) {
1429      browser = calcBrowser();
1430    }
1431
1432    return browser;
1433  }
1434
1435  var Resize = {
1436    name: 'resize',
1437    create: function create() {
1438      var swiper = this;
1439      extend$1(swiper, {
1440        resize: {
1441          resizeHandler: function resizeHandler() {
1442            if (!swiper || swiper.destroyed || !swiper.initialized) return;
1443            swiper.emit('beforeResize');
1444            swiper.emit('resize');
1445          },
1446          orientationChangeHandler: function orientationChangeHandler() {
1447            if (!swiper || swiper.destroyed || !swiper.initialized) return;
1448            swiper.emit('orientationchange');
1449          }
1450        }
1451      });
1452    },
1453    on: {
1454      init: function init(swiper) {
1455        var window = getWindow(); // Emit resize
1456
1457        window.addEventListener('resize', swiper.resize.resizeHandler); // Emit orientationchange
1458
1459        window.addEventListener('orientationchange', swiper.resize.orientationChangeHandler);
1460      },
1461      destroy: function destroy(swiper) {
1462        var window = getWindow();
1463        window.removeEventListener('resize', swiper.resize.resizeHandler);
1464        window.removeEventListener('orientationchange', swiper.resize.orientationChangeHandler);
1465      }
1466    }
1467  };
1468
1469  var Observer = {
1470    attach: function attach(target, options) {
1471      if (options === void 0) {
1472        options = {};
1473      }
1474
1475      var window = getWindow();
1476      var swiper = this;
1477      var ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
1478      var observer = new ObserverFunc(function (mutations) {
1479        // The observerUpdate event should only be triggered
1480        // once despite the number of mutations.  Additional
1481        // triggers are redundant and are very costly
1482        if (mutations.length === 1) {
1483          swiper.emit('observerUpdate', mutations[0]);
1484          return;
1485        }
1486
1487        var observerUpdate = function observerUpdate() {
1488          swiper.emit('observerUpdate', mutations[0]);
1489        };
1490
1491        if (window.requestAnimationFrame) {
1492          window.requestAnimationFrame(observerUpdate);
1493        } else {
1494          window.setTimeout(observerUpdate, 0);
1495        }
1496      });
1497      observer.observe(target, {
1498        attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
1499        childList: typeof options.childList === 'undefined' ? true : options.childList,
1500        characterData: typeof options.characterData === 'undefined' ? true : options.characterData
1501      });
1502      swiper.observer.observers.push(observer);
1503    },

1504    init: function init() {
1505      var swiper = this;
1506      if (!swiper.support.observer || !swiper.params.observer) return;
1507
1508      if (swiper.params.observeParents) {
1509        var containerParents = swiper.$el.parents();
1510
1511        for (var i = 0; i < containerParents.length; i += 1) {
1512          swiper.observer.attach(containerParents[i]);
1513        }
1514      } // Observe container
1515
1516
1517      swiper.observer.attach(swiper.$el[0], {
1518        childList: swiper.params.observeSlideChildren
1519      }); // Observe wrapper
1520
1521      swiper.observer.attach(swiper.$wrapperEl[0], {
1522        attributes: false
1523      });
1524    },
1525    destroy: function destroy() {
1526      var swiper = this;
1527      swiper.observer.observers.forEach(function (observer) {
1528        observer.disconnect();
1529      });
1530      swiper.observer.observers = [];
1531    }
1532  };
1533  var Observer$1 = {
1534    name: 'observer',
1535    params: {
1536      observer: false,
1537      observeParents: false,
1538      observeSlideChildren: false
1539    },
1540    create: function create() {
1541      var swiper = this;
1542      bindModuleMethods(swiper, {
1543        observer: _extends(_extends({}, Observer), {}, {
1544          observers: []
1545        })
1546      });
1547    },
1548    on: {
1549      init: function init(swiper) {
1550        swiper.observer.init();
1551      },
1552      destroy: function destroy(swiper) {
1553        swiper.observer.destroy();
1554      }
1555    }
1556  };
1557
1558  var modular = {
1559    useParams: function useParams(instanceParams) {
1560      var instance = this;
1561      if (!instance.modules) return;
1562      Object.keys(instance.modules).forEach(function (moduleName) {
1563        var module = instance.modules[moduleName]; // Extend params
1564
1565        if (module.params) {
1566          extend$1(instanceParams, module.params);
1567        }
1568      });
1569    },
1570    useModules: function useModules(modulesParams) {
1571      if (modulesParams === void 0) {
1572        modulesParams = {};
1573      }
1574
1575      var instance = this;
1576      if (!instance.modules) return;
1577      Object.keys(instance.modules).forEach(function (moduleName) {
1578        var module = instance.modules[moduleName];
1579        var moduleParams = modulesParams[moduleName] || {}; // Add event listeners
1580
1581        if (module.on && instance.on) {
1582          Object.keys(module.on).forEach(function (moduleEventName) {
1583            instance.on(moduleEventName, module.on[moduleEventName]);
1584          });
1585        } // Module create callback
1586
1587
1588        if (module.create) {
1589          module.create.bind(instance)(moduleParams);
1590        }
1591      });
1592    }
1593  };
1594
1595  /* eslint-disable no-underscore-dangle */
1596  var eventsEmitter = {
1597    on: function on(events, handler, priority) {
1598      var self = this;
1599      if (typeof handler !== 'function') return self;
1600      var method = priority ? 'unshift' : 'push';
1601      events.split(' ').forEach(function (event) {
1602        if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
1603        self.eventsListeners[event][method](handler);
1604      });
1605      return self;
1606    },
1607    once: function once(events, handler, priority) {
1608      var self = this;
1609      if (typeof handler !== 'function') return self;
1610
1611      function onceHandler() {
1612        self.off(events, onceHandler);
1613
1614        if (onceHandler.__emitterProxy) {
1615          delete onceHandler.__emitterProxy;
1616        }
1617
1618        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1619          args[_key] = arguments[_key];
1620        }
1621
1622        handler.apply(self, args);
1623      }
1624
1625      onceHandler.__emitterProxy = handler;
1626      return self.on(events, onceHandler, priority);
1627    },
1628    onAny: function onAny(handler, priority) {
1629      var self = this;
1630      if (typeof handler !== 'function') return self;
1631      var method = priority ? 'unshift' : 'push';
1632
1633      if (self.eventsAnyListeners.indexOf(handler) < 0) {
1634        self.eventsAnyListeners[method](handler);
1635      }
1636
1637      return self;
1638    },
1639    offAny: function offAny(handler) {
1640      var self = this;
1641      if (!self.eventsAnyListeners) return self;
1642      var index = self.eventsAnyListeners.indexOf(handler);
1643
1644      if (index >= 0) {
1645        self.eventsAnyListeners.splice(index, 1);
1646      }
1647
1648      return self;
1649    },
1650    off: function off(events, handler) {
1651      var self = this;
1652      if (!self.eventsListeners) return self;
1653      events.split(' ').forEach(function (event) {
1654        if (typeof handler === 'undefined') {
1655          self.eventsListeners[event] = [];
1656        } else if (self.eventsListeners[event]) {
1657          self.eventsListeners[event].forEach(function (eventHandler, index) {
1658            if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
1659              self.eventsListeners[event].splice(index, 1);
1660            }
1661          });
1662        }
1663      });
1664      return self;
1665    },
1666    emit: function emit() {
1667      var self = this;
1668      if (!self.eventsListeners) return self;
1669      var events;
1670      var data;
1671      var context;
1672
1673      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
1674        args[_key2] = arguments[_key2];
1675      }
1676
1677      if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1678        events = args[0];
1679        data = args.slice(1, args.length);
1680        context = self;
1681      } else {
1682        events = args[0].events;
1683        data = args[0].data;

1684        context = args[0].context || self;
1685      }
1686
1687      data.unshift(context);
1688      var eventsArray = Array.isArray(events) ? events : events.split(' ');
1689      eventsArray.forEach(function (event) {
1690        if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
1691          self.eventsAnyListeners.forEach(function (eventHandler) {
1692            eventHandler.apply(context, [event].concat(data));
1693          });
1694        }
1695
1696        if (self.eventsListeners && self.eventsListeners[event]) {
1697          var handlers = [];
1698          self.eventsListeners[event].forEach(function (eventHandler) {
1699            handlers.push(eventHandler);
1700          });
1701          handlers.forEach(function (eventHandler) {
1702            eventHandler.apply(context, data);
1703          });
1704        }
1705      });
1706      return self;
1707    }
1708  };
1709
1710  function updateSize() {
1711    var swiper = this;
1712    var width;
1713    var height;
1714    var $el = swiper.$el;
1715
1716    if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
1717      width = swiper.params.width;
1718    } else {
1719      width = $el[0].clientWidth;
1720    }
1721
1722    if (typeof swiper.params.height !== 'undefined' && swiper.params.width !== null) {
1723      height = swiper.params.height;
1724    } else {
1725      height = $el[0].clientHeight;
1726    }
1727
1728    if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
1729      return;
1730    } // Subtract paddings
1731
1732
1733    width = width - parseInt($el.css('padding-left') || 0, 10) - parseInt($el.css('padding-right') || 0, 10);
1734    height = height - parseInt($el.css('padding-top') || 0, 10) - parseInt($el.css('padding-bottom') || 0, 10);
1735    if (Number.isNaN(width)) width = 0;
1736    if (Number.isNaN(height)) height = 0;
1737    extend$1(swiper, {
1738      width: width,
1739      height: height,
1740      size: swiper.isHorizontal() ? width : height
1741    });
1742  }
1743
1744  function updateSlides() {
1745    var swiper = this;
1746    var window = getWindow();
1747    var params = swiper.params;
1748    var $wrapperEl = swiper.$wrapperEl,
1749        swiperSize = swiper.size,
1750        rtl = swiper.rtlTranslate,
1751        wrongRTL = swiper.wrongRTL;
1752    var isVirtual = swiper.virtual && params.virtual.enabled;
1753    var previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1754    var slides = $wrapperEl.children("." + swiper.params.slideClass);
1755    var slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1756    var snapGrid = [];
1757    var slidesGrid = [];
1758    var slidesSizesGrid = [];
1759
1760    function slidesForMargin(slideEl, slideIndex) {
1761      if (!params.cssMode) return true;
1762
1763      if (slideIndex === slides.length - 1) {
1764        return false;
1765      }
1766
1767      return true;
1768    }
1769
1770    var offsetBefore = params.slidesOffsetBefore;
1771
1772    if (typeof offsetBefore === 'function') {
1773      offsetBefore = params.slidesOffsetBefore.call(swiper);
1774    }
1775
1776    var offsetAfter = params.slidesOffsetAfter;
1777
1778    if (typeof offsetAfter === 'function') {
1779      offsetAfter = params.slidesOffsetAfter.call(swiper);
1780    }
1781
1782    var previousSnapGridLength = swiper.snapGrid.length;
1783    var previousSlidesGridLength = swiper.snapGrid.length;
1784    var spaceBetween = params.spaceBetween;
1785    var slidePosition = -offsetBefore;
1786    var prevSlideSize = 0;
1787    var index = 0;
1788
1789    if (typeof swiperSize === 'undefined') {
1790      return;
1791    }
1792
1793    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1794      spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
1795    }
1796
1797    swiper.virtualSize = -spaceBetween; // reset margins
1798
1799    if (rtl) slides.css({
1800      marginLeft: '',
1801      marginTop: ''
1802    });else slides.css({
1803      marginRight: '',
1804      marginBottom: ''
1805    });
1806    var slidesNumberEvenToRows;
1807
1808    if (params.slidesPerColumn > 1) {
1809      if (Math.floor(slidesLength / params.slidesPerColumn) === slidesLength / swiper.params.slidesPerColumn) {
1810        slidesNumberEvenToRows = slidesLength;
1811      } else {
1812        slidesNumberEvenToRows = Math.ceil(slidesLength / params.slidesPerColumn) * params.slidesPerColumn;
1813      }
1814
1815      if (params.slidesPerView !== 'auto' && params.slidesPerColumnFill === 'row') {

1816        slidesNumberEvenToRows = Math.max(slidesNumberEvenToRows, params.slidesPerView * params.slidesPerColumn);
1817      }
1818    } // Calc slides
1819
1820
1821    var slideSize;
1822    var slidesPerColumn = params.slidesPerColumn;
1823    var slidesPerRow = slidesNumberEvenToRows / slidesPerColumn;
1824    var numFullColumns = Math.floor(slidesLength / params.slidesPerColumn);
1825
1826    for (var i = 0; i < slidesLength; i += 1) {
1827      slideSize = 0;
1828      var slide = slides.eq(i);
1829
1830      if (params.slidesPerColumn > 1) {
1831        // Set slides order
1832        var newSlideOrderIndex = void 0;
1833        var column = void 0;
1834        var row = void 0;
1835
1836        if (params.slidesPerColumnFill === 'row' && params.slidesPerGroup > 1) {
1837          var groupIndex = Math.floor(i / (params.slidesPerGroup * params.slidesPerColumn));
1838          var slideIndexInGroup = i - params.slidesPerColumn * params.slidesPerGroup * groupIndex;
1839          var columnsInGroup = groupIndex === 0 ? params.slidesPerGroup : Math.min(Math.ceil((slidesLength - groupIndex * slidesPerColumn * params.slidesPerGroup) / slidesPerColumn), params.slidesPerGroup);
1840          row = Math.floor(slideIndexInGroup / columnsInGroup);
1841          column = slideIndexInGroup - row * columnsInGroup + groupIndex * params.slidesPerGroup;
1842          newSlideOrderIndex = column + row * slidesNumberEvenToRows / slidesPerColumn;
1843          slide.css({
1844            '-webkit-box-ordinal-group': newSlideOrderIndex,
1845            '-moz-box-ordinal-group': newSlideOrderIndex,
1846            '-ms-flex-order': newSlideOrderIndex,
1847            '-webkit-order': newSlideOrderIndex,
1848            order: newSlideOrderIndex
1849          });
1850        } else if (params.slidesPerColumnFill === 'column') {
1851          column = Math.floor(i / slidesPerColumn);
1852          row = i - column * slidesPerColumn;
1853
1854          if (column > numFullColumns || column === numFullColumns && row === slidesPerColumn - 1) {
1855            row += 1;
1856
1857            if (row >= slidesPerColumn) {
1858              row = 0;
1859              column += 1;
1860            }
1861          }
1862        } else {
1863          row = Math.floor(i / slidesPerRow);
1864          column = i - row * slidesPerRow;
1865        }
1866
1867        slide.css("margin-" + (swiper.isHorizontal() ? 'top' : 'left'), row !== 0 && params.spaceBetween && params.spaceBetween + "px");
1868      }
1869
1870      if (slide.css('display') === 'none') continue; // eslint-disable-line
1871
1872      if (params.slidesPerView === 'auto') {
1873        var slideStyles = window.getComputedStyle(slide[0], null);
1874        var currentTransform = slide[0].style.transform;
1875        var currentWebKitTransform = slide[0].style.webkitTransform;
1876
1877        if (currentTransform) {
1878          slide[0].style.transform = 'none';
1879        }
1880
1881        if (currentWebKitTransform) {
1882          slide[0].style.webkitTransform = 'none';
1883        }
1884
1885        if (params.roundLengths) {
1886          slideSize = swiper.isHorizontal() ? slide.outerWidth(true) : slide.outerHeight(true);
1887        } else {
1888          // eslint-disable-next-line
1889          if (swiper.isHorizontal()) {
1890            var width = parseFloat(slideStyles.getPropertyValue('width') || 0);
1891            var paddingLeft = parseFloat(slideStyles.getPropertyValue('padding-left') || 0);
1892            var paddingRight = parseFloat(slideStyles.getPropertyValue('padding-right') || 0);
1893            var marginLeft = parseFloat(slideStyles.getPropertyValue('margin-left') || 0);
1894            var marginRight = parseFloat(slideStyles.getPropertyValue('margin-right') || 0);
1895            var boxSizing = slideStyles.getPropertyValue('box-sizing');
1896
1897            if (boxSizing && boxSizing === 'border-box') {
1898              slideSize = width + marginLeft + marginRight;
1899            } else {
1900              var _slide$ = slide[0],
1901                  clientWidth = _slide$.clientWidth,
1902                  offsetWidth = _slide$.offsetWidth;
1903              slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1904            }
1905          } else {
1906            var height = parseFloat(slideStyles.getPropertyValue('height') || 0);
1907            var paddingTop = parseFloat(slideStyles.getPropertyValue('padding-top') || 0);
1908            var paddingBottom = parseFloat(slideStyles.getPropertyValue('padding-bottom') || 0);
1909            var marginTop = parseFloat(slideStyles.getPropertyValue('margin-top') || 0);
1910            var marginBottom = parseFloat(slideStyles.getPropertyValue('margin-bottom') || 0);
1911
1912            var _boxSizing = slideStyles.getPropertyValue('box-sizing');
1913
1914            if (_boxSizing && _boxSizing === 'border-box') {
1915              slideSize = height + marginTop + marginBottom;
1916            } else {
1917              var _slide$2 = slide[0],
1918                  clientHeight = _slide$2.clientHeight,
1919                  offsetHeight = _slide$2.offsetHeight;
1920              slideSize = height + paddingTop + paddingBottom + marginTop + marginBottom + (offsetHeight - clientHeight);
1921            }
1922          }
1923        }
1924
1925        if (currentTransform) {
1926          slide[0].style.transform = currentTransform;
1927        }
1928
1929        if (currentWebKitTransform) {
1930          slide[0].style.webkitTransform = currentWebKitTransform;
1931        }
1932
1933        if (params.roundLengths) slideSize = Math.floor(slideSize);
1934      } else {
1935        slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
1936        if (params.roundLengths) slideSize = Math.floor(slideSize);
1937
1938        if (slides[i]) {
1939          if (swiper.isHorizontal()) {
1940            slides[i].style.width = slideSize + "px";
1941          } else {
1942            slides[i].style.height = slideSize + "px";
1943          }
1944        }
1945      }
1946
1947      if (slides[i]) {
1948        slides[i].swiperSlideSize = slideSize;
1949      }
1950
1951      slidesSizesGrid.push(slideSize);
1952
1953      if (params.centeredSlides) {
1954        slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1955        if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1956        if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1957        if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
1958        if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1959        if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1960        slidesGrid.push(slidePosition);
1961      } else {
1962        if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1963        if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1964        slidesGrid.push(slidePosition);
1965        slidePosition = slidePosition + slideSize + spaceBetween;
1966      }
1967
1968      swiper.virtualSize += slideSize + spaceBetween;
1969      prevSlideSize = slideSize;
1970      index += 1;

1971    }
1972
1973    swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1974    var newSlidesGrid;
1975
1976    if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1977      $wrapperEl.css({
1978        width: swiper.virtualSize + params.spaceBetween + "px"
1979      });
1980    }
1981
1982    if (params.setWrapperSize) {
1983      if (swiper.isHorizontal()) $wrapperEl.css({
1984        width: swiper.virtualSize + params.spaceBetween + "px"
1985      });else $wrapperEl.css({
1986        height: swiper.virtualSize + params.spaceBetween + "px"
1987      });
1988    }
1989
1990    if (params.slidesPerColumn > 1) {
1991      swiper.virtualSize = (slideSize + params.spaceBetween) * slidesNumberEvenToRows;
1992      swiper.virtualSize = Math.ceil(swiper.virtualSize / params.slidesPerColumn) - params.spaceBetween;
1993      if (swiper.isHorizontal()) $wrapperEl.css({
1994        width: swiper.virtualSize + params.spaceBetween + "px"
1995      });else $wrapperEl.css({
1996        height: swiper.virtualSize + params.spaceBetween + "px"
1997      });
1998
1999      if (params.centeredSlides) {
2000        newSlidesGrid = [];
2001
2002        for (var _i = 0; _i < snapGrid.length; _i += 1) {
2003          var slidesGridItem = snapGrid[_i];
2004          if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
2005          if (snapGrid[_i] < swiper.virtualSize + snapGrid[0]) newSlidesGrid.push(slidesGridItem);
2006        }
2007
2008        snapGrid = newSlidesGrid;
2009      }
2010    } // Remove last grid elements depending on width
2011
2012
2013    if (!params.centeredSlides) {
2014      newSlidesGrid = [];
2015
2016      for (var _i2 = 0; _i2 < snapGrid.length; _i2 += 1) {
2017        var _slidesGridItem = snapGrid[_i2];
2018        if (params.roundLengths) _slidesGridItem = Math.floor(_slidesGridItem);
2019
2020        if (snapGrid[_i2] <= swiper.virtualSize - swiperSize) {
2021          newSlidesGrid.push(_slidesGridItem);
2022        }
2023      }
2024
2025      snapGrid = newSlidesGrid;
2026
2027      if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
2028        snapGrid.push(swiper.virtualSize - swiperSize);
2029      }
2030    }
2031
2032    if (snapGrid.length === 0) snapGrid = [0];
2033
2034    if (params.spaceBetween !== 0) {
2035      if (swiper.isHorizontal()) {
2036        if (rtl) slides.filter(slidesForMargin).css({
2037          marginLeft: spaceBetween + "px"
2038        });else slides.filter(slidesForMargin).css({
2039          marginRight: spaceBetween + "px"
2040        });
2041      } else slides.filter(slidesForMargin).css({
2042        marginBottom: spaceBetween + "px"
2043      });
2044    }
2045
2046    if (params.centeredSlides && params.centeredSlidesBounds) {
2047      var allSlidesSize = 0;
2048      slidesSizesGrid.forEach(function (slideSizeValue) {
2049        allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
2050      });
2051      allSlidesSize -= params.spaceBetween;
2052      var maxSnap = allSlidesSize - swiperSize;
2053      snapGrid = snapGrid.map(function (snap) {
2054        if (snap < 0) return -offsetBefore;
2055        if (snap > maxSnap) return maxSnap + offsetAfter;
2056        return snap;
2057      });
2058    }
2059
2060    if (params.centerInsufficientSlides) {
2061      var _allSlidesSize = 0;
2062      slidesSizesGrid.forEach(function (slideSizeValue) {
2063        _allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
2064      });
2065      _allSlidesSize -= params.spaceBetween;
2066
2067      if (_allSlidesSize < swiperSize) {
2068        var allSlidesOffset = (swiperSize - _allSlidesSize) / 2;
2069        snapGrid.forEach(function (snap, snapIndex) {
2070          snapGrid[snapIndex] = snap - allSlidesOffset;
2071        });
2072        slidesGrid.forEach(function (snap, snapIndex) {
2073          slidesGrid[snapIndex] = snap + allSlidesOffset;
2074        });
2075      }
2076    }
2077
2078    extend$1(swiper, {
2079      slides: slides,
2080      snapGrid: snapGrid,
2081      slidesGrid: slidesGrid,
2082      slidesSizesGrid: slidesSizesGrid
2083    });
2084
2085    if (slidesLength !== previousSlidesLength) {
2086      swiper.emit('slidesLengthChange');
2087    }
2088
2089    if (snapGrid.length !== previousSnapGridLength) {
2090      if (swiper.params.watchOverflow) swiper.checkOverflow();
2091      swiper.emit('snapGridLengthChange');
2092    }
2093
2094    if (slidesGrid.length !== previousSlidesGridLength) {
2095      swiper.emit('slidesGridLengthChange');
2096    }
2097
2098    if (params.watchSlidesProgress || params.watchSlidesVisibility) {
2099      swiper.updateSlidesOffset();
2100    }
2101  }
2102
2103  function updateAutoHeight(speed) {
2104    var swiper = this;
2105    var activeSlides = [];
2106    var newHeight = 0;
2107    var i;
2108
2109    if (typeof speed === 'number') {
2110      swiper.setTransition(speed);
2111    } else if (speed === true) {
2112      swiper.setTransition(swiper.params.speed);
2113    } // Find slides currently in view
2114
2115
2116    if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
2117      if (swiper.params.centeredSlides) {
2118        swiper.visibleSlides.each(function (slide) {
2119          activeSlides.push(slide);
2120        });
2121      } else {
2122        for (i = 0;

2122 i < Math.ceil(swiper.params.slidesPerView); i += 1) {
2123          var index = swiper.activeIndex + i;
2124          if (index > swiper.slides.length) break;
2125          activeSlides.push(swiper.slides.eq(index)[0]);
2126        }
2127      }
2128    } else {
2129      activeSlides.push(swiper.slides.eq(swiper.activeIndex)[0]);
2130    } // Find new height from highest slide in view
2131
2132
2133    for (i = 0; i < activeSlides.length; i += 1) {
2134      if (typeof activeSlides[i] !== 'undefined') {
2135        var height = activeSlides[i].offsetHeight;
2136        newHeight = height > newHeight ? height : newHeight;
2137      }
2138    } // Update Height
2139
2140
2141    if (newHeight) swiper.$wrapperEl.css('height', newHeight + "px");
2142  }
2143
2144  function updateSlidesOffset() {
2145    var swiper = this;
2146    var slides = swiper.slides;
2147
2148    for (var i = 0; i < slides.length; i += 1) {
2149      slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;
2150    }
2151  }
2152
2153  function updateSlidesProgress(translate) {
2154    if (translate === void 0) {
2155      translate = this && this.translate || 0;
2156    }
2157
2158    var swiper = this;
2159    var params = swiper.params;
2160    var slides = swiper.slides,
2161        rtl = swiper.rtlTranslate;
2162    if (slides.length === 0) return;
2163    if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
2164    var offsetCenter = -translate;
2165    if (rtl) offsetCenter = translate; // Visible Slides
2166
2167    slides.removeClass(params.slideVisibleClass);
2168    swiper.visibleSlidesIndexes = [];
2169    swiper.visibleSlides = [];
2170
2171    for (var i = 0; i < slides.length; i += 1) {
2172      var slide = slides[i];
2173      var slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slide.swiperSlideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2174
2175      if (params.watchSlidesVisibility || params.centeredSlides && params.autoHeight) {
2176        var slideBefore = -(offsetCenter - slide.swiperSlideOffset);
2177        var slideAfter = slideBefore + swiper.slidesSizesGrid[i];
2178        var isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
2179
2180        if (isVisible) {
2181          swiper.visibleSlides.push(slide);
2182          swiper.visibleSlidesIndexes.push(i);
2183          slides.eq(i).addClass(params.slideVisibleClass);
2184        }
2185      }
2186
2187      slide.progress = rtl ? -slideProgress : slideProgress;
2188    }
2189
2190    swiper.visibleSlides = $(swiper.visibleSlides);
2191  }
2192
2193  function updateProgress(translate) {
2194    var swiper = this;
2195
2196    if (typeof translate === 'undefined') {
2197      var multiplier = swiper.rtlTranslate ? -1 : 1; // eslint-disable-next-line
2198
2199      translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
2200    }
2201
2202    var params = swiper.params;
2203    var translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2204    var progress = swiper.progress,
2205        isBeginning = swiper.isBeginning,
2206        isEnd = swiper.isEnd;
2207    var wasBeginning = isBeginning;
2208    var wasEnd = isEnd;
2209
2210    if (translatesDiff === 0) {
2211      progress = 0;
2212      isBeginning = true;
2213      isEnd = true;
2214    } else {
2215      progress = (translate - swiper.minTranslate()) / translatesDiff;
2216      isBeginning = progress <= 0;
2217      isEnd = progress >= 1;
2218    }
2219
2220    extend$1(swiper, {
2221      progress: progress,
2222      isBeginning: isBeginning,
2223      isEnd: isEnd
2224    });
2225    if (params.watchSlidesProgress || params.watchSlidesVisibility || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
2226
2227    if (isBeginning && !wasBeginning) {
2228      swiper.emit('reachBeginning toEdge');
2229    }
2230
2231    if (isEnd && !wasEnd) {
2232      swiper.emit('reachEnd toEdge');
2233    }
2234
2235    if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
2236      swiper.emit('fromEdge');
2237    }
2238
2239    swiper.emit('progress', progress);
2240  }
2241
2242  function updateSlidesClasses() {
2243    var swiper = this;
2244    var slides = swiper.slides,
2245        params = swiper.params,
2246        $wrapperEl = swiper.$wrapperEl,

2247        activeIndex = swiper.activeIndex,
2248        realIndex = swiper.realIndex;
2249    var isVirtual = swiper.virtual && params.virtual.enabled;
2250    slides.removeClass(params.slideActiveClass + " " + params.slideNextClass + " " + params.slidePrevClass + " " + params.slideDuplicateActiveClass + " " + params.slideDuplicateNextClass + " " + params.slideDuplicatePrevClass);
2251    var activeSlide;
2252
2253    if (isVirtual) {
2254      activeSlide = swiper.$wrapperEl.find("." + params.slideClass + "[data-swiper-slide-index=\"" + activeIndex + "\"]");
2255    } else {
2256      activeSlide = slides.eq(activeIndex);
2257    } // Active classes
2258
2259
2260    activeSlide.addClass(params.slideActiveClass);
2261
2262    if (params.loop) {
2263      // Duplicate to all looped slides
2264      if (activeSlide.hasClass(params.slideDuplicateClass)) {
2265        $wrapperEl.children("." + params.slideClass + ":not(." + params.slideDuplicateClass + ")[data-swiper-slide-index=\"" + realIndex + "\"]").addClass(params.slideDuplicateActiveClass);
2266      } else {
2267        $wrapperEl.children("." + params.slideClass + "." + params.slideDuplicateClass + "[data-swiper-slide-index=\"" + realIndex + "\"]").addClass(params.slideDuplicateActiveClass);
2268      }
2269    } // Next Slide
2270
2271
2272    var nextSlide = activeSlide.nextAll("." + params.slideClass).eq(0).addClass(params.slideNextClass);
2273
2274    if (params.loop && nextSlide.length === 0) {
2275      nextSlide = slides.eq(0);
2276      nextSlide.addClass(params.slideNextClass);
2277    } // Prev Slide
2278
2279
2280    var prevSlide = activeSlide.prevAll("." + params.slideClass).eq(0).addClass(params.slidePrevClass);
2281
2282    if (params.loop && prevSlide.length === 0) {
2283      prevSlide = slides.eq(-1);
2284      prevSlide.addClass(params.slidePrevClass);
2285    }
2286
2287    if (params.loop) {
2288      // Duplicate to all looped slides
2289      if (nextSlide.hasClass(params.slideDuplicateClass)) {
2290        $wrapperEl.children("." + params.slideClass + ":not(." + params.slideDuplicateClass + ")[data-swiper-slide-index=\"" + nextSlide.attr('data-swiper-slide-index') + "\"]").addClass(params.slideDuplicateNextClass);
2291      } else {
2292        $wrapperEl.children("." + params.slideClass + "." + params.slideDuplicateClass + "[data-swiper-slide-index=\"" + nextSlide.attr('data-swiper-slide-index') + "\"]").addClass(params.slideDuplicateNextClass);
2293      }
2294
2295      if (prevSlide.hasClass(params.slideDuplicateClass)) {
2296        $wrapperEl.children("." + params.slideClass + ":not(." + params.slideDuplicateClass + ")[data-swiper-slide-index=\"" + prevSlide.attr('data-swiper-slide-index') + "\"]").addClass(params.slideDuplicatePrevClass);
2297      } else {
2298        $wrapperEl.children("." + params.slideClass + "." + params.slideDuplicateClass + "[data-swiper-slide-index=\"" + prevSlide.attr('data-swiper-slide-index') + "\"]").addClass(params.slideDuplicatePrevClass);
2299      }
2300    }
2301
2302    swiper.emitSlidesClasses();
2303  }
2304
2305  function updateActiveIndex(newActiveIndex) {
2306    var swiper = this;
2307    var translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2308    var slidesGrid = swiper.slidesGrid,
2309        snapGrid = swiper.snapGrid,
2310        params = swiper.params,
2311        previousIndex = swiper.activeIndex,
2312        previousRealIndex = swiper.realIndex,
2313        previousSnapIndex = swiper.snapIndex;
2314    var activeIndex = newActiveIndex;
2315    var snapIndex;
2316
2317    if (typeof activeIndex === 'undefined') {
2318      for (var i = 0; i < slidesGrid.length; i += 1) {
2319        if (typeof slidesGrid[i + 1] !== 'undefined') {
2320          if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
2321            activeIndex = i;
2322          } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
2323            activeIndex = i + 1;
2324          }
2325        } else if (translate >= slidesGrid[i]) {
2326          activeIndex = i;
2327        }
2328      } // Normalize slideIndex
2329
2330
2331      if (params.normalizeSlideIndex) {
2332        if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
2333      }
2334    }
2335

2336    if (snapGrid.indexOf(translate) >= 0) {
2337      snapIndex = snapGrid.indexOf(translate);
2338    } else {
2339      var skip = Math.min(params.slidesPerGroupSkip, activeIndex);
2340      snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
2341    }
2342
2343    if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2344
2345    if (activeIndex === previousIndex) {
2346      if (snapIndex !== previousSnapIndex) {
2347        swiper.snapIndex = snapIndex;
2348        swiper.emit('snapIndexChange');
2349      }
2350
2351      return;
2352    } // Get real index
2353
2354
2355    var realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);
2356    extend$1(swiper, {
2357      snapIndex: snapIndex,
2358      realIndex: realIndex,
2359      previousIndex: previousIndex,
2360      activeIndex: activeIndex
2361    });
2362    swiper.emit('activeIndexChange');
2363    swiper.emit('snapIndexChange');
2364
2365    if (previousRealIndex !== realIndex) {
2366      swiper.emit('realIndexChange');
2367    }
2368
2369    if (swiper.initialized || swiper.params.runCallbacksOnInit) {
2370      swiper.emit('slideChange');
2371    }
2372  }
2373
2374  function updateClickedSlide(e) {
2375    var swiper = this;
2376    var params = swiper.params;
2377    var slide = $(e.target).closest("." + params.slideClass)[0];
2378    var slideFound = false;
2379
2380    if (slide) {
2381      for (var i = 0; i < swiper.slides.length; i += 1) {
2382        if (swiper.slides[i] === slide) slideFound = true;
2383      }
2384    }
2385
2386    if (slide && slideFound) {
2387      swiper.clickedSlide = slide;
2388
2389      if (swiper.virtual && swiper.params.virtual.enabled) {
2390        swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);
2391      } else {
2392        swiper.clickedIndex = $(slide).index();
2393      }
2394    } else {
2395      swiper.clickedSlide = undefined;
2396      swiper.clickedIndex = undefined;
2397      return;
2398    }
2399
2400    if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
2401      swiper.slideToClickedSlide();
2402    }
2403  }
2404
2405  var update = {
2406    updateSize: updateSize,
2407    updateSlides: updateSlides,
2408    updateAutoHeight: updateAutoHeight,
2409    updateSlidesOffset: updateSlidesOffset,
2410    updateSlidesProgress: updateSlidesProgress,
2411    updateProgress: updateProgress,
2412    updateSlidesClasses: updateSlidesClasses,
2413    updateActiveIndex: updateActiveIndex,
2414    updateClickedSlide: updateClickedSlide
2415  };
2416
2417  function getSwiperTranslate(axis) {
2418    if (axis === void 0) {
2419      axis = this.isHorizontal() ? 'x' : 'y';
2420    }
2421
2422    var swiper = this;
2423    var params = swiper.params,
2424        rtl = swiper.rtlTranslate,
2425        translate = swiper.translate,
2426        $wrapperEl = swiper.$wrapperEl;
2427
2428    if (params.virtualTranslate) {
2429      return rtl ? -translate : translate;
2430    }
2431
2432    if (params.cssMode) {
2433      return translate;
2434    }
2435
2436    var currentTranslate = getTranslate($wrapperEl[0], axis);
2437    if (rtl) currentTranslate = -currentTranslate;
2438    return currentTranslate || 0;
2439  }
2440
2441  function setTranslate(translate, byController) {
2442    var swiper = this;
2443    var rtl = swiper.rtlTranslate,
2444        params = swiper.params,
2445        $wrapperEl = swiper.$wrapperEl,
2446        wrapperEl = swiper.wrapperEl,
2447        progress = swiper.progress;
2448    var x = 0;
2449    var y = 0;
2450    var z = 0;
2451
2452    if (swiper.isHorizontal()) {
2453      x = rtl ? -translate : translate;
2454    } else {
2455      y = translate;
2456    }
2457
2458    if (params.roundLengths) {
2459      x = Math.floor(x);
2460      y = Math.floor(y);
2461    }
2462
2463    if (params.cssMode) {
2464      wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
2465    } else if (!params.virtualTranslate) {
2466      $wrapperEl.transform("translate3d(" + x + "px, " + y + "px, " + z + "px)");
2467    }
2468
2469    swiper.previousTranslate = swiper.translate;
2470    swiper.translate = swiper.isHorizontal() ? x : y; // Check if we need to update progress
2471
2472    var newProgress;
2473    var translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2474
2475    if (translatesDiff === 0) {
2476      newProgress = 0;
2477    } else {
2478      newProgress = (translate - swiper.minTranslate()) / translatesDiff;
2479    }
2480
2481    if (newProgress !== progress) {
2482      swiper.updateProgress(translate);
2483    }
2484
2485    swiper.emit('setTranslate', swiper.translate, byController);
2486  }
2487
2488  function minTranslate() {
2489    return -this.snapGrid[0];
2490  }
2491
2492  function maxTranslate() {
2493    return -this.snapGrid[this.snapGrid.length - 1];
2494  }
2495
2496  function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
2497    if (translate === void 0) {
2498      translate = 0;
2499    }
2500
2501    if (speed === void 0) {
2502      speed = this.params.speed;
2503    }
2504
2505    if (runCallbacks === void 0) {
2506      runCallbacks = true;
2507    }
2508
2509    if (translateBounds === void 0) {
2510      translateBounds = true;
2511    }
2512
2513    var swiper = this;
2514    var params = swiper.params,
2515        wrapperEl = swiper.wrapperEl;
2516
2517    if (swiper.animating && params.preventInteractionOnTransition) {
2518      return false;
2519    }
2520
2521    var minTranslate = swiper.minTranslate();
2522    var maxTranslate = swiper.maxTranslate();
2523    var newTranslate;
2524    if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate; // Update progress
2525
2526    swiper.updateProgress(newTranslate);
2527
2528    if (params.cssMode) {
2529      var isH = swiper.isHorizontal();
2530
2531      if (speed === 0) {
2532        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
2533      } else {
2534        // eslint-disable-next-line
2535        if (wrapperEl.scrollTo) {
2536          var _wrapperEl$scrollTo;
2537
2538          wrapperEl.scrollTo((_wrapperEl$scrollTo = {}, _wrapperEl$scrollTo[isH ? 'left' : 'top'] = -newTranslate, _wrapperEl$scrollTo.behavior = 'smooth', _wrapperEl$scrollTo));
2539        } else {
2540          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
2541        }
2542      }
2543
2544      return true;
2545    }
2546
2547    if (speed === 0) {
2548      swiper.setTransition(0);
2549      swiper.setTranslate(newTranslate);
2550
2551      if (runCallbacks) {
2552        swiper.emit('beforeTransitionStart', speed, internal);
2553        swiper.emit('transitionEnd');
2554      }
2555    } else {
2556      swiper.setTransition(speed);
2557      swiper.setTranslate(newTranslate);
2558
2559      if (runCallbacks) {
2560        swiper.emit('beforeTransitionStart', speed, internal);
2561        swiper.emit('transitionStart');
2562      }
2563
2564      if (!swiper.animating) {
2565        swiper.animating = true;
2566
2567        if (!swiper.onTranslateToWrapperTransitionEnd) {
2568          swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
2569            if (!swiper || swiper.destroyed) return;
2570            if (e.target !== this) return;
2571            swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2572            swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2573            swiper.onTranslateToWrapperTransitionEnd = null;
2574            delete swiper.onTranslateToWrapperTransitionEnd;
2575
2576            if (runCallbacks) {
2577              swiper.emit('transitionEnd');
2578            }
2579          };
2580        }
2581
2582        swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2583        swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2584      }
2585    }
2586
2587    return true;
2588  }
2589
2590  var translate = {
2591    getTranslate: getSwiperTranslate,
2592    setTranslate: setTranslate,
2593    minTranslate: minTranslate,
2594    maxTranslate: maxTranslate,
2595    translateTo: translateTo
2596  };
2597
2598  function setTransition(duration, byController) {
2599    var swiper = this;
2600
2601    if (!swiper.params.cssMode) {
2602      swiper.$wrapperEl.transition(duration);
2603    }
2604
2605    swiper.emit('setTransition', duration, byController);
2606  }
2607
2608  function transitionStart(runCallbacks, direction) {
2609    if (runCallbacks === void 0) {
2610      runCallbacks = true;
2611    }
2612
2613    var swiper = this;
2614    var activeIndex = swiper.activeIndex,
2615        params = swiper.params,
2616        previousIndex = swiper.previousIndex;
2617    if (params.cssMode) return;
2618
2619    if (params.autoHeight) {
2620      swiper.updateAutoHeight();
2621    }
2622
2623    var dir = direction;
2624
2625    if (!dir) {
2626      if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
2627    }
2628
2629    swiper.emit('transitionStart');
2630
2631    if (runCallbacks && activeIndex !== previousIndex) {
2632      if (dir === 'reset') {
2633        swiper.emit('slideResetTransitionStart');
2634        return;
2635      }
2636
2637      swiper.emit('slideChangeTransitionStart');
2638
2639      if (dir === 'next') {
2640        swiper.emit('slideNextTransitionStart');
2641      } else {
2642        swiper.emit('slidePrevTransitionStart');
2643      }
2644    }
2645  }
2646
2647  function transitionEnd$1(runCallbacks, direction) {
2648    if (runCallbacks === void 0) {
2649      runCallbacks = true;
2650    }
2651
2652    var swiper = this;
2653    var activeIndex = swiper.activeIndex,
2654        previousIndex = swiper.previousIndex,
2655        params = swiper.params;
2656    swiper.animating = false;
2657    if (params.cssMode) return;
2658    swiper.setTransition(0);
2659    var dir = direction;
2660
2661    if (!dir) {
2662      if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
2663    }
2664
2665    swiper.emit('transitionEnd');
2666
2667    if (runCallbacks && activeIndex !== previousIndex) {
2668      if (dir === 'reset') {
2669        swiper.emit('slideResetTransitionEnd');
2670        return;
2671      }
2672
2673      swiper.emit('slideChangeTransitionEnd');
2674
2675      if (dir === 'next') {
2676        swiper.emit('slideNextTransitionEnd');
2677      } else {
2678        swiper.emit('slidePrevTransitionEnd');
2679      }
2680    }
2681  }
2682
2683  var transition$1 = {
2684    setTransition: setTransition,
2685    transitionStart: transitionStart,
2686    transitionEnd: transitionEnd$1
2687  };
2688
2689  function slideTo(index, speed, runCallbacks, internal) {
2690    if (index === void 0) {
2691      index = 0;
2692    }
2693
2694    if (speed === void 0) {
2695      speed = this.params.speed;
2696    }
2697
2698    if (runCallbacks === void 0) {
2699      runCallbacks = true;
2700    }
2701
2702    var swiper = this;
2703    var slideIndex = index;
2704    if (slideIndex < 0) slideIndex = 0;
2705    var params = swiper.params,
2706        snapGrid = swiper.snapGrid,
2707        slidesGrid = swiper.slidesGrid,
2708        previousIndex = swiper.previousIndex,
2709        activeIndex = swiper.activeIndex,
2710        rtl = swiper.rtlTranslate,
2711        wrapperEl = swiper.wrapperEl;
2712
2713    if (swiper.animating && params.preventInteractionOnTransition) {
2714      return false;
2715    }
2716
2717    var skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
2718    var snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
2719    if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2720
2721    if ((activeIndex || params.initialSlide || 0) === (previousIndex || 0) && runCallbacks) {
2722      swiper.emit('beforeSlideChangeStart');
2723    }
2724