https://montessori-boventij.nl/wp-content/themes/montessoriboventijnl/js/vendor/swiper.js?ver=4.4.2

1/**
2 * Swiper 4.4.2
3 * Most modern mobile touch slider and framework with hardware accelerated transitions
4 * http://www.idangero.us/swiper/
5 *
6 * Copyright 2014-2018 Vladimir Kharlampidi
7 *
8 * Released under the MIT License
9 *
10 * Released on: November 1, 2018
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.Swiper = factory());
17}(this, (function () { 'use strict';
18
19  /**
20   * SSR Window 1.0.1
21   * Better handling for window object in SSR environment
22   * https://github.com/nolimits4web/ssr-window
23   *
24   * Copyright 2018, Vladimir Kharlampidi
25   *
26   * Licensed under MIT
27   *
28   * Released on: July 18, 2018
29   */
30  var doc = (typeof document === 'undefined') ? {
31    body: {},
32    addEventListener: function addEventListener() {},
33    removeEventListener: function removeEventListener() {},
34    activeElement: {
35      blur: function blur() {},
36      nodeName: '',
37    },
38    querySelector: function querySelector() {
39      return null;
40    },
41    querySelectorAll: function querySelectorAll() {
42      return [];
43    },
44    getElementById: function getElementById() {
45      return null;
46    },
47    createEvent: function createEvent() {
48      return {
49        initEvent: function initEvent() {},
50      };
51    },
52    createElement: function createElement() {
53      return {
54        children: [],
55        childNodes: [],
56        style: {},
57        setAttribute: function setAttribute() {},
58        getElementsByTagName: function getElementsByTagName() {
59          return [];
60        },
61      };
62    },
63    location: { hash: '' },
64  } : document; // eslint-disable-line
65
66  var win = (typeof window === 'undefined') ? {
67    document: doc,
68    navigator: {
69      userAgent: '',
70    },
71    location: {},
72    history: {},
73    CustomEvent: function CustomEvent() {
74      return this;
75    },
76    addEventListener: function addEventListener() {},
77    removeEventListener: function removeEventListener() {},
78    getComputedStyle: function getComputedStyle() {
79      return {
80        getPropertyValue: function getPropertyValue() {
81          return '';
82        },
83      };
84    },
85    Image: function Image() {},
86    Date: function Date() {},
87    screen: {},
88    setTimeout: function setTimeout() {},
89    clearTimeout: function clearTimeout() {},
90  } : window; // eslint-disable-line
91
92  /**
93   * Dom7 2.1.2
94   * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API
95   * http://framework7.io/docs/dom.html
96   *
97   * Copyright 2018, Vladimir Kharlampidi
98   * The iDangero.us
99   * http://www.idangero.us/
100   *
101   * Licensed under MIT
102   *
103   * Released on: September 13, 2018

103
104   */
105
106  var Dom7 = function Dom7(arr) {
107    var self = this;
108    // Create array-like object
109    for (var i = 0; i < arr.length; i += 1) {
110      self[i] = arr[i];
111    }
112    self.length = arr.length;
113    // Return collection with methods
114    return this;
115  };
116
117  function $(selector, context) {
118    var arr = [];
119    var i = 0;
120    if (selector && !context) {
121      if (selector instanceof Dom7) {
122        return selector;
123      }
124    }
125    if (selector) {
126        // String
127      if (typeof selector === 'string') {
128        var els;
129        var tempParent;
130        var html = selector.trim();
131        if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {
132          var toCreate = 'div';
133          if (html.indexOf('<li') === 0) { toCreate = 'ul'; }
134          if (html.indexOf('<tr') === 0) { toCreate = 'tbody'; }
135          if (html.indexOf('<td') === 0 || html.indexOf('<th') === 0) { toCreate = 'tr'; }
136          if (html.indexOf('<tbody') === 0) { toCreate = 'table'; }
137          if (html.indexOf('<option') === 0) { toCreate = 'select'; }
138          tempParent = doc.createElement(toCreate);
139          tempParent.innerHTML = html;
140          for (i = 0; i < tempParent.childNodes.length; i += 1) {
141            arr.push(tempParent.childNodes[i]);
142          }
143        } else {
144          if (!context && selector[0] === '#' && !selector.match(/[ .<>:~]/)) {
145            // Pure ID selector
146            els = [doc.getElementById(selector.trim().split('#')[1])];
147          } else {
148            // Other selectors
149            els = (context || doc).querySelectorAll(selector.trim());
150          }
151          for (i = 0; i < els.length; i += 1) {
152            if (els[i]) { arr.push(els[i]); }
153          }
154        }
155      } else if (selector.nodeType || selector === win || selector === doc) {
156        // Node/element
157        arr.push(selector);
158      } else if (selector.length > 0 && selector[0].nodeType) {
159        // Array of elements or instance of Dom
160        for (i = 0; i < selector.length; i += 1) {
161          arr.push(selector[i]);
162        }
163      }
164    }
165    return new Dom7(arr);
166  }
167
168  $.fn = Dom7.prototype;
169  $.Class = Dom7;
170  $.Dom7 = Dom7;
171
172  function unique(arr) {
173    var uniqueArray = [];
174    for (var i = 0; i < arr.length; i += 1) {
175      if (uniqueArray.indexOf(arr[i]) === -1) { uniqueArray.push(arr[i]); }
176    }
177    return uniqueArray;
178  }
179
180  // Classes and attributes
181  function addClass(className) {
182    if (typeof className === 'undefined') {
183      return this;
184    }
185    var classes = className.split(' ');
186    for (var i = 0; i < classes.length; i += 1) {
187      for (var j = 0; j < this.length; j += 1) {
188        if (typeof this[j] !== 'undefined' && typeof this[j].classList !== 'undefined') { this[j].classList.add(classes[i]); }
189      }
190    }
191    return this;
192  }
193  function removeClass(className) {
194    var classes = className.split(' ');
195    for (var i = 0; i < classes.length; i += 1) {
196      for (var j = 0; j < this.length; j += 1) {
197        if (typeof this[j] !== 'undefined' && typeof this[j].classList !== 'undefined') { this[j].classList.remove(classes[i]); }
198      }
199    }
200    return this;
201  }
202  function hasClass(className) {
203    if (!this[0]) { return false; }
204    return this[0].classList.contains(className);
205  }
206  function toggleClass(className) {
207    var classes = className.split(' ');
208    for (var i = 0; i < classes.length; i += 1) {
209      for (var j = 0; j < this.length; j += 1) {
210        if (typeof this[j] !== 'undefined' && typeof this[j].classList !== 'undefined') { this[j].classList.toggle(classes[i]); }
211      }
212    }
213    return this;
214  }
215  function attr(attrs, value) {
216    var arguments$1 = arguments;
217
218    if (arguments.length === 1 && typeof attrs === 'string') {
219      // Get attr
220      if (this[0]) { return this[0].getAttribute(attrs); }
221      return undefined;
222    }
223
224    // Set attrs
225    for (var i = 0; i < this.length; i += 1) {
226      if (arguments$1.length === 2) {
227        // String
228        this[i].setAttribute(attrs, value);
229      } else {
230        // Object
231        // eslint-disable-next-line
232        for (var attrName in attrs) {
233          this[i][attrName] = attrs[attrName];
234          this[i].setAttribute(attrName, attrs[attrName]);
235        }
236      }
237    }
238    return this;
239  }
240  // eslint-disable-next-line
241  function removeAttr(attr) {
242    for (var i = 0; i < this.length; i += 1) {
243      this[i].removeAttribute(attr);
244    }
245    return this;
246  }
247  function data(key, value) {
248    var el;
249    if (typeof value === 'undefined') {
250      el = this[0];
251      // Get value
252      if (el) {
253        if (el.dom7ElementDataStorage && (key in el.dom7ElementDataStorage)) {
254          return el.dom7ElementDataStorage[key];
255        }
256
257        var dataKey = el.getAttribute(("data-" + key));
258        if (dataKey) {
259          return dataKey;
260        }
261        return undefined;
262      }
263      return undefined;
264    }
265
266    // Set value
267    for (var i = 0; i < this.length; i += 1) {
268      el = this[i];
269      if (!el.dom7ElementDataStorage) { el.dom7ElementDataStorage = {}; }
270      el.dom7ElementDataStorage[key] = value;
271    }
272    return this;
273  }
274  // Transforms
275  // eslint-disable-next-line
276  function transform(transform) {
277    for (var i = 0; i < this.length; i += 1) {
278      var elStyle = this[i].style;
279      elStyle.webkitTransform = transform;
280      elStyle.transform = transform;
281    }
282    return this;
283  }
284  function transition(duration) {
285    if (typeof duration !== 'string') {
286      duration = duration + "ms"; // eslint-disable-line
287    }
288    for (var i = 0; i < this.length; i += 1) {
289      var elStyle = this[i].style;
290      elStyle.webkitTransitionDuration = duration;
291      elStyle.transitionDuration = duration;
292    }
293    return this;
294  }
295  // Events
296  function on() {
297    var assign;
298
299    var args = [], len = arguments.length;
300    while ( len-- ) args[ len ] = arguments[ len ];
301    var eventType = args[0];
302    var targetSelector = args[1];
303    var listener = args[2];
304    var capture = args[3];
305    if (typeof args[1] === 'function') {
306      (assign = args, eventType = assign[0], listener = assign[1], capture = assign[2]);
307      targetSelector = undefined;
308    }
309    if (!capture) { capture = false; }
310
311    function handleLiveEvent(e) {
312      var target = e.target;
313      if (!target) { return; }
314      var eventData = e.target.dom7EventData || [];
315      if (eventData.indexOf(e) < 0) {
316        eventData.unshift(e);
317      }
318      if ($(target).is(targetSelector)) { listener.apply(target, eventData); }
319      else {
320        var parents = $(target).parents(); // eslint-disable-line
321        for (var k = 0; k < parents.length; k += 1) {
322          if ($(parents[k]).is(targetSelector)) { listener.apply(parents[k], eventData); }
323        }
324      }
325    }
326    function handleEvent(e) {
327      var eventData = e && e.target ? e.target.dom7EventData || [] : [];
328      if (eventData.indexOf(e) < 0) {
329        eventData.unshift(e);
330      }
331      listener.apply(this, eventData);
332    }
333    var events = eventType.split(' ');
334    var j;
335    for (var i = 0; i < this.length; i += 1) {
336      var el = this[i];
337      if (!targetSelector) {
338        for (j = 0; j < events.length; j += 1) {
339          var event = events[j];
340          if (!el.dom7Listeners) { el.dom7Listeners = {}; }
341          if (!el.dom7Listeners[event]) { el.dom7Listeners[event] = []; }
342          el.dom7Listeners[event].push({
343            listener: listener,
344            proxyListener: handleEvent,
345          });
346          el.addEventListener(event, handleEvent, capture);
347        }
348      } else {
349        // Live events
350        for (j = 0; j < events.length; j += 1) {
351          var event$1 = events[j];
352          if (!el.dom7LiveListeners) { el.dom7LiveListeners = {}; }
353          if (!el.dom7LiveListeners[event$1]) { el.dom7LiveListeners[event$1] = []; }
354          el.dom7LiveListeners[event$1].push({
355            listener: listener,
356            proxyListener: handleLiveEvent,
357          });
358          el.addEventListener(event$1, handleLiveEvent, capture);
359        }
360      }
361    }
362    return this;
363  }
364  function off() {
365    var assign;
366
367    var args = [], len = arguments.length;
368    while ( len-- ) args[ len ] = arguments[ len ];
369    var eventType = args[0];
370    var targetSelector = args[1];
371    var listener = args[2];
372    var capture = args[3];
373    if (typeof args[1] === 'function') {
374      (assign = args, eventType = assign[0], listener = assign[1], capture = assign[2]);
375      targetSelector = undefined;
376    }
377    if (!capture) { capture = false; }
378
379    var events = eventType.split(' ');
380    for (var i = 0; i < events.length; i += 1) {
381      var event = events[i];
382      for (var j = 0; j < this.length; j += 1) {
383        var el = this[j];
384        var handlers = (void 0);
385        if (!targetSelector && el.dom7Listeners) {
386          handlers = el.dom7Listeners[event];
387        } else if (targetSelector && el.dom7LiveListeners) {
388          handlers = el.dom7LiveListeners[event];
389        }
390        if (handlers && handlers.length) {
391          for (var k = handlers.length - 1; k >= 0; k -= 1) {
392            var handler = handlers[k];
393            if (listener && handler.listener === listener) {
394              el.removeEventListener(event, handler.proxyListener, capture);
395              handlers.splice(k, 1);
396            } else if (!listener) {
397              el.removeEventListener(event, handler.proxyListener, capture);
398              handlers.splice(k, 1);
399            }
400          }
401        }
402      }
403    }
404    return this;
405  }
406  function trigger() {
407    var args = [], len = arguments.length;
408    while ( len-- ) args[ len ] = arguments[ len ];
409
410    var events = args[0].split(' ');
411    var eventData = args[1];
412    for (var i = 0; i < events.length; i += 1) {
413      var event = events[i];
414      for (var j = 0; j < this.length; j += 1) {
415        var el = this[j];
416        var evt = (void 0);
417        try {
418          evt = new win.CustomEvent(event, {
419            detail: eventData,
420            bubbles: true,
421            cancelable: true,
422          });
423        } catch (e) {
424          evt = doc.createEvent('Event');
425          evt.initEvent(event, true, true);
426          evt.detail = eventData;
427        }
428        // eslint-disable-next-line
429        el.dom7EventData = args.filter(function (data, dataIndex) { return dataIndex > 0; });
430        el.dispatchEvent(evt);
431        el.dom7EventData = [];
432        delete el.dom7EventData;
433      }
434    }
435    return this;
436  }
437  function transitionEnd(callback) {
438    var events = ['webkitTransitionEnd', 'transitionend'];
439    var dom = this;
440    var i;
441    function fireCallBack(e) {
442      /* jshint validthis:true */
443      if (e.target !== this) { return; }
444      callback.call(this, e);
445      for (i = 0; i < events.length; i += 1) {
446        dom.off(events[i], fireCallBack);
447      }
448    }
449    if (callback) {
450      for (i = 0; i < events.length; i += 1) {
451        dom.on(events[i], fireCallBack);
452      }
453    }
454    return this;
455  }
456  function outerWidth(includeMargins) {
457    if (this.length > 0) {
458      if (includeMargins) {
459        // eslint-disable-next-line
460        var styles = this.styles();
461        return this[0].offsetWidth + parseFloat(styles.getPropertyValue('margin-right')) + parseFloat(styles.getPropertyValue('margin-left'));
462      }
463      return this[0].offsetWidth;
464    }
465    return null;
466  }
467  function outerHeight(includeMargins) {
468    if (this.length > 0) {
469      if (includeMargins) {
470        // eslint-disable-next-line
471        var styles = this.styles();
472        return this[0].offsetHeight + parseFloat(styles.getPropertyValue('margin-top')) + parseFloat(styles.getPropertyValue('margin-bottom'));
473      }
474      return this[0].offsetHeight;
475    }
476    return null;
477  }
478  function offset() {
479    if (this.length > 0) {
480      var el = this[0];
481      var box = el.getBoundingClientRect();
482      var body = doc.body;
483      var clientTop = el.clientTop || body.clientTop || 0;
484      var clientLeft = el.clientLeft || body.clientLeft || 0;
485      var scrollTop = el === win ? win.scrollY : el.scrollTop;
486      var scrollLeft = el === win ? win.scrollX : el.scrollLeft;
487      return {
488        top: (box.top + scrollTop) - clientTop,
489        left: (box.left + scrollLeft) - clientLeft,
490      };
491    }
492
493    return null;
494  }
495  function styles() {
496    if (this[0]) { return win.getComputedStyle(this[0], null); }
497    return {};
498  }
499  function css(props, value) {
500    var i;
501    if (arguments.length === 1) {
502      if (typeof props === 'string') {
503        if (this[0]) { return win.getComputedStyle(this[0], null).getPropertyValue(props); }
504      } else {
505        for (i = 0; i < this.length; i += 1) {
506          // eslint-disable-next-line
507          for (var prop in props) {
508            this[i].style[prop] = props[prop];
509          }
510        }
511        return this;
512      }
513    }
514    if (arguments.length === 2 && typeof props === 'string') {
515      for (i = 0; i < this.length; i += 1) {
516        this[i].style[props] = value;
517      }
518      return this;
519    }
520    return this;
521  }
522  // Iterate over the collection passing elements to `callback`
523  function each(callback) {
524    // Don't bother continuing without a callback
525    if (!callback) { return this; }
526    // Iterate over the current collection
527    for (var i = 0; i < this.length; i += 1) {
528      // If the callback returns false
529      if (callback.call(this[i], i, this[i]) === false) {
530        // End the loop early
531        return this;
532      }
533    }
534    // Return `this` to allow chained DOM operations
535    return this;
536  }
537  // eslint-disable-next-line
538  function html(html) {
539    if (typeof html === 'undefined') {
540      return this[0] ? this[0].innerHTML : undefined;
541    }
542
543    for (var i = 0; i < this.length; i += 1) {
544      this[i].innerHTML = html;
545    }
546    return this;
547  }
548  // eslint-disable-next-line
549  function text(text) {
550    if (typeof text === 'undefined') {
551      if (this[0]) {
552        return this[0].textContent.trim();
553      }
554      return null;
555    }
556
557    for (var i = 0; i < this.length; i += 1) {
558      this[i].textContent = text;
559    }
560    return this;
561  }
562  function is(selector) {
563    var el = this[0];
564    var compareWith;
565    var i;
566    if (!el || typeof selector === 'undefined') { return false; }
567    if (typeof selector === 'string') {
568      if (el.matches) { return el.matches(selector); }
569      else if (el.webkitMatchesSelector) { return el.webkitMatchesSelector(selector); }
570      else if (el.msMatchesSelector) { return el.msMatchesSelector(selector); }
571
572      compareWith = $(selector);
573      for (i = 0; i < compareWith.length; i += 1) {
574        if (compareWith[i] === el) { return true; }
575      }
576      return false;
577    } else if (selector === doc) { return el === doc; }
578    else if (selector === win) { return el === win; }
579
580    if (selector.nodeType || selector instanceof Dom7) {
581      compareWith = selector.nodeType ? [selector] : selector;
582      for (i = 0; i < compareWith.length; i += 1) {
583        if (compareWith[i] === el) { return true; }
584      }
585      return false;
586    }
587    return false;
588  }
589  function index() {
590    var child = this[0];
591    var i;
592    if (child) {
593      i = 0;
594      // eslint-disable-next-line
595      while ((child = child.previousSibling) !== null) {
596        if (child.nodeType === 1) { i += 1; }
597      }
598      return i;
599    }
600    return undefined;
601  }
602  // eslint-disable-next-line
603  function eq(index) {
604    if (typeof index === 'undefined') { return this; }
605    var length = this.length;
606    var returnIndex;
607    if (index > length - 1) {
608      return new Dom7([]);
609    }
610    if (index < 0) {
611      returnIndex = length + index;
612      if (returnIndex < 0) { return new Dom7([]); }
613      return new Dom7([this[returnIndex]]);
614    }
615    return new Dom7([this[index]]);
616  }
617  function append() {
618    var args = [], len = arguments.length;
619    while ( len-- ) args[ len ] = arguments[ len ];
620
621    var newChild;
622
623    for (var k = 0; k < args.length; k += 1) {
624      newChild = args[k];
625      for (var i = 0; i < this.length; i += 1) {
626        if (typeof newChild === 'string') {
627          var tempDiv = doc.createElement('div');
628          tempDiv.innerHTML = newChild;
629          while (tempDiv.firstChild) {
630            this[i].appendChild(tempDiv.firstChild);
631          }
632        } else if (newChild instanceof Dom7) {
633          for (var j = 0; j < newChild.length; j += 1) {
634            this[i].appendChild(newChild[j]);
635          }
636        } else {
637          this[i].appendChild(newChild);
638        }
639      }
640    }
641
642    return this;
643  }
644  function prepend(newChild) {
645    var i;
646    var j;
647    for (i = 0; i < this.length; i += 1) {
648      if (typeof newChild === 'string') {
649        var tempDiv = doc.createElement('div');
650        tempDiv.innerHTML = newChild;
651        for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
652          this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
653        }
654      } else if (newChild instanceof Dom7) {
655        for (j = 0; j < newChild.length; j += 1) {
656          this[i].insertBefore(newChild[j], this[i].childNodes[0]);
657        }
658      } else {
659        this[i].insertBefore(newChild, this[i].childNodes[0]);
660      }
661    }
662    return this;
663  }
664  function next(selector) {
665    if (this.length > 0) {
666      if (selector) {
667        if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {
668          return new Dom7([this[0].nextElementSibling]);
669        }
670        return new Dom7([]);
671      }
672
673      if (this[0].nextElementSibling) { return new Dom7([this[0].nextElementSibling]); }
674      return new Dom7([]);
675    }
676    return new Dom7([]);
677  }
678  function nextAll(selector) {
679    var nextEls = [];
680    var el = this[0];
681    if (!el) { return new Dom7([]); }
682    while (el.nextElementSibling) {
683      var next = el.nextElementSibling; // eslint-disable-line
684      if (selector) {
685        if ($(next).is(selector)) { nextEls.push(next); }
686      } else { nextEls.push(next); }
687      el = next;
688    }
689    return new Dom7(nextEls);
690  }
691  function prev(selector) {
692    if (this.length > 0) {
693      var el = this[0];
694      if (selector) {
695        if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {
696          return new Dom7([el.previousElementSibling]);
697        }
698        return new Dom7([]);
699      }
700
701      if (el.previousElementSibling) { return new Dom7([el.previousElementSibling]); }
702      return new Dom7([]);
703    }
704    return new Dom7([]);
705  }
706  function prevAll(selector) {
707    var prevEls = [];
708    var el = this[0];
709    if (!el) { return new Dom7([]); }
710    while (el.previousElementSibling) {
711      var prev = el.previousElementSibling; // eslint-disable-line
712      if (selector) {
713        if ($(prev).is(selector)) { prevEls.push(prev); }
714      } else { prevEls.push(prev); }
715      el = prev;
716    }
717    return new Dom7(prevEls);
718  }
719  function parent(selector) {
720    var parents = []; // eslint-disable-line
721    for (var i = 0; i < this.length; i += 1) {
722      if (this[i].parentNode !== null) {
723        if (selector) {
724          if ($(this[i].parentNode).is(selector)) { parents.push(this[i].parentNode); }
725        } else {
726          parents.push(this[i].parentNode);
727        }
728      }
729    }
730    return $(unique(parents));
731  }
732  function parents(selector) {
733    var parents = []; // eslint-disable-line
734    for (var i = 0; i < this.length; i += 1) {
735      var parent = this[i].parentNode; // eslint-disable-line
736      while (parent) {
737        if (selector) {
738          if ($(parent).is(selector)) { parents.push(parent); }
739        } else {
740          parents.push(parent);
741        }
742        parent = parent.parentNode;
743      }
744    }
745    return $(unique(parents));
746  }
747  function closest(selector) {
748    var closest = this; // eslint-disable-line
749    if (typeof selector === 'undefined') {
750      return new Dom7([]);
751    }
752    if (!closest.is(selector)) {
753      closest = closest.parents(selector).eq(0);
754    }
755    return closest;
756  }
757  function find(selector) {
758    var foundElements = [];
759    for (var i = 0; i < this.length; i += 1) {
760      var found = this[i].querySelectorAll(selector);
761      for (var j = 0; j < found.length; j += 1) {
762        foundElements.push(found[j]);
763      }
764    }
765    return new Dom7(foundElements);
766  }
767  function children(selector) {
768    var children = []; // eslint-disable-line
769    for (var i = 0; i < this.length; i += 1) {
770      var childNodes = this[i].childNodes;
771
772      for (var j = 0; j < childNodes.length; j += 1) {
773        if (!selector) {
774          if (childNodes[j].nodeType === 1) { children.push(childNodes[j]); }
775        } else if (childNodes[j].nodeType === 1 && $(childNodes[j]).is(selector)) {
776          children.push(childNodes[j]);
777        }
778      }
779    }
780    return new Dom7(unique(children));
781  }
782  function remove() {
783    for (var i = 0; i < this.length; i += 1) {
784      if (this[i].parentNode) { this[i].parentNode.removeChild(this[i]); }
785    }
786    return this;
787  }
788  function add() {
789    var args = [], len = arguments.length;
790    while ( len-- ) args[ len ] = arguments[ len ];
791
792    var dom = this;
793    var i;
794    var j;
795    for (i = 0; i < args.length; i += 1) {
796      var toAdd = $(args[i]);
797      for (j = 0; j < toAdd.length; j += 1) {
798        dom[dom.length] = toAdd[j];
799        dom.length += 1;
800      }
801    }
802    return dom;
803  }
804
805  var Methods = {
806    addClass: addClass,
807    removeClass: removeClass,
808    hasClass: hasClass,
809    toggleClass: toggleClass,
810    attr: attr,
811    removeAttr: removeAttr,
812    data: data,
813    transform: transform,
814    transition: transition,
815    on: on,
816    off: off,
817    trigger: trigger,
818    transitionEnd: transitionEnd,
819    outerWidth: outerWidth,
820    outerHeight: outerHeight,
821    offset: offset,
822    css: css,
823    each: each,
824    html: html,
825    text: text,
826    is: is,
827    index: index,
828    eq: eq,
829    append: append,
830    prepend: prepend,
831    next: next,
832    nextAll: nextAll,
833    prev: prev,
834    prevAll: prevAll,
835    parent: parent,
836    parents: parents,
837    closest: closest,
838    find: find,
839    children: children,
840    remove: remove,
841    add: add,
842    styles: styles,
843  };
844
845  Object.keys(Methods).forEach(function (methodName) {
846    $.fn[methodName] = 

846Methods[methodName];
847  });
848
849  var Utils = {
850    deleteProps: function deleteProps(obj) {
851      var object = obj;
852      Object.keys(object).forEach(function (key) {
853        try {
854          object[key] = null;
855        } catch (e) {
856          // no getter for object
857        }
858        try {
859          delete object[key];
860        } catch (e) {
861          // something got wrong
862        }
863      });
864    },
865    nextTick: function nextTick(callback, delay) {
866      if ( delay === void 0 ) delay = 0;
867
868      return setTimeout(callback, delay);
869    },
870    now: function now() {
871      return Date.now();
872    },
873    getTranslate: function getTranslate(el, axis) {
874      if ( axis === void 0 ) axis = 'x';
875
876      var matrix;
877      var curTransform;
878      var transformMatrix;
879
880      var curStyle = win.getComputedStyle(el, null);
881
882      if (win.WebKitCSSMatrix) {
883        curTransform = curStyle.transform || curStyle.webkitTransform;
884        if (curTransform.split(',').length > 6) {
885          curTransform = curTransform.split(', ').map(function (a) { return a.replace(',', '.'); }).join(', ');
886        }
887        // Some old versions of Webkit choke when 'none' is passed; pass
888        // empty string instead in this case
889        transformMatrix = new win.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
890      } else {
891        transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
892        matrix = transformMatrix.toString().split(',');
893      }
894
895      if (axis === 'x') {
896        // Latest Chrome and webkits Fix
897        if (win.WebKitCSSMatrix) { curTransform = transformMatrix.m41; }
898        // Crazy IE10 Matrix
899        else if (matrix.length === 16) { curTransform = parseFloat(matrix[12]); }
900        // Normal Browsers
901        else { curTransform = parseFloat(matrix[4]); }
902      }
903      if (axis === 'y') {
904        // Latest Chrome and webkits Fix
905        if (win.WebKitCSSMatrix) { curTransform = transformMatrix.m42; }
906        // Crazy IE10 Matrix
907        else if (matrix.length === 16) { curTransform = parseFloat(matrix[13]); }
908        // Normal Browsers
909        else { curTransform = parseFloat(matrix[5]); }
910      }
911      return curTransform || 0;
912    },
913    parseUrlQuery: function parseUrlQuery(url) {
914      var query = {};
915      var urlToParse = url || win.location.href;
916      var i;
917      var params;
918      var param;
919      var length;
920      if (typeof urlToParse === 'string' && urlToParse.length) {
921        urlToParse = urlToParse.indexOf('?') > -1 ? urlToParse.replace(/\S*\?/, '') : '';
922        params = urlToParse.split('&').filter(function (paramsPart) { return paramsPart !== ''; });
923        length = params.length;
924
925        for (i = 0; i < length; i += 1) {
926          param = params[i].replace(/#\S+/g, '').split('=');
927          query[decodeURIComponent(param[0])] = typeof param[1] === 'undefined' ? undefined : decodeURIComponent(param[1]) || '';
928        }
929      }
930      return query;
931    },
932    isObject: function isObject(o) {
933      return typeof o === 'object' && o !== null && o.constructor && o.constructor === Object;
934    },
935    extend: function extend() {
936      var args = [], len$1 = arguments.length;
937      while ( len$1-- ) args[ len$1 ] = arguments[ len$1 ];
938
939      var to = Object(args[0]);
940      for (var i = 1; i < args.length; i += 1) {
941        var nextSource = args[i];
942        if (nextSource !== undefined && nextSource !== null) {
943          var keysArray = Object.keys(Object(nextSource));
944          for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
945            var nextKey = keysArray[nextIndex];
946            var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
947            if (desc !== undefined && desc.enumerable) {
948              if (Utils.isObject(to[nextKey]) && Utils.isObject(nextSource[nextKey])) {
949                Utils.extend(to[nextKey], nextSource[nextKey]);
950              } else if (!Utils.isObject(to[nextKey]) && Utils.isObject(nextSource[nextKey])) {
951                to[nextKey] = {};
952                Utils.extend(to[nextKey], nextSource[nextKey]);
953              } else {
954                to[nextKey] = nextSource[nextKey];
955              }
956            }
957          }
958        }
959      }
960      return to;
961    },
962  };
963
964  var Support = (function Support() {
965    var testDiv = doc.createElement('div');
966    return {
967      touch: (win.Modernizr && win.Modernizr.touch === true) || (function checkTouch() {
968        return !!(('ontouchstart' in win) || (win.DocumentTouch && doc instanceof win.DocumentTouch));
969      }()),
970
971      pointerEvents: !!(win.navigator.pointerEnabled || win.PointerEvent || ('maxTouchPoints' in win.navigator)),
972      prefixedPointerEvents: !!win.navigator.msPointerEnabled,
973
974      transition: (function checkTransition() {
975        var style = testDiv.style;
976        return ('transition' in style || 'webkitTransition' in style || 'MozTransition' in style);
977      }()),
978      transforms3d: (win.Modernizr && win.Modernizr.csstransforms3d === true) || (function checkTransforms3d() {
979        var style = testDiv.style;
980        return ('webkitPerspective' in style || 'MozPerspective' in style || 'OPerspective' in style || 'MsPerspective' in style || 'perspective' in style);
981      }()),
982
983      flexbox: (function checkFlexbox() {
984        var style = testDiv.style;
985        var styles = ('alignItems webkitAlignItems webkitBoxAlign msFlexAlign mozBoxAlign webkitFlexDirection msFlexDirection mozBoxDirection mozBoxOrient webkitBoxDirection webkitBoxOrient').split(' ');
986        for (var i = 0; i < styles.length; i += 1) {
987          if (styles[i] in style) { return true; }
988        }
989        return false;
990      }()),
991
992      observer: (function checkObserver() {
993        return ('MutationObserver' in win || 'WebkitMutationObserver' in win);
994      }()),
995
996      passiveListener: (function checkPassiveListener() {
997        var supportsPassive = false;
998        try {
999          var opts = Object.defineProperty({}, 'passive', {
1000            // eslint-disable-next-line
1001            get: function get() {
1002              supportsPassive = true;
1003            },
1004          });
1005          win.addEventListener('testPassiveListener', null, opts);
1006        } catch (e) {
1007          // No support
1008        }
1009        return supportsPassive;
1010      }()),
1011
1012      gestures: (function checkGestures() {
1013        return 'ongesturestart' in win;
1014      }()),
1015    };
1016  }());
1017
1018  var SwiperClass = function SwiperClass(params) {
1019    if ( params === void 0 ) params = {};
1020
1021    var self = this;
1022    self.params = params;
1023
1024    // Events
1025    self.eventsListeners = {};
1026
1027    if (self.params && self.params.on) {
1028      Object.keys(self.params.on).forEach(function (eventName) {
1029        self.on(eventName, self.params.on[eventName]);
1030      });
1031    }
1032  };
1033
1034  var staticAccessors = { components: { configurable: true } };
1035
1036  SwiperClass.prototype.on = function on (events, handler, priority) {
1037    var self = this;
1038    if (typeof handler !== 'function') { return self; }
1039    var method = priority ? 'unshift' : 'push';
1040    events.split(' ').forEach(function (event) {
1041      if (!self.eventsListeners[event]) { self.eventsListeners[event] = []; }
1042      self.eventsListeners[event][method](handler);
1043    });
1044    return self;
1045  };
1046
1047  SwiperClass.prototype.once = function once (events, handler, priority) {
1048    var self = this;
1049    if (typeof handler !== 'function') { return self; }
1050    function onceHandler() {
1051        var args = [], len = arguments.length;
1052        while ( len-- ) args[ len ] = arguments[ len ];
1053
1054      handler.apply(self, args);
1055      self.off(events, onceHandler);
1056    }
1057    return self.on(events, onceHandler, priority);
1058  };
1059
1060  SwiperClass.prototype.off = function off (events, handler) {
1061    var self = this;
1062    if (!self.eventsListeners) { return self; }
1063    events.split(' ').forEach(function (event) {
1064      if (typeof handler === 'undefined') {
1065        self.eventsListeners[event] = [];
1066      } else if (self.eventsListeners[event] && self.eventsListeners[event].length) {
1067        self.eventsListeners[event].forEach(function (eventHandler, index) {
1068          if (eventHandler === handler) {
1069            self.eventsListeners[event].splice(index, 1);
1070          }
1071        });
1072      }
1073    });
1074    return self;
1075  };
1076
1077  SwiperClass.prototype.emit = function emit () {
1078      var args = [], len = arguments.length;
1079      while ( len-- ) args[ len ] = arguments[ len ];
1080
1081    var self = this;
1082    if (!self.eventsListeners) { return self; }
1083    var events;
1084    var data;
1085    var context;
1086    if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1087      events = args[0];
1088      data = args.slice(1, args.length);
1089      context = self;
1090    } else {
1091      events = args[0].events;
1092      data = args[0].data;
1093      context = args[0].context || self;
1094    }
1095    var eventsArray = Array.isArray(events) ? events : events.split(' ');
1096    eventsArray.forEach(function (event) {
1097      if (self.eventsListeners && self.eventsListeners[event]) {
1098        var handlers = [];
1099        self.eventsListeners[event].forEach(function (eventHandler) {
1100          handlers.push(eventHandler);
1101        });
1102        handlers.forEach(function (eventHandler) {
1103          eventHandler.apply(context, data);
1104        });
1105      }
1106    });
1107    return self;
1108  };
1109
1110  SwiperClass.prototype.useModulesParams = function useModulesParams (instanceParams) {
1111    var instance = this;
1112    if (!instance.modules) { return; }
1113    Object.keys(instance.modules).forEach(function (moduleName) {
1114      var module = instance.modules[moduleName];
1115      // Extend params
1116      if (module.params) {
1117        Utils.extend(instanceParams, module.params);
1118      }
1119    });
1120  };
1121
1122  SwiperClass.prototype.useModules = function useModules (modulesParams) {
1123      if ( modulesParams === void 0 ) modulesParams = {};
1124
1125    var instance = this;
1126    if (!instance.modules) { return; }
1127    Object.keys(instance.modules).forEach(function (moduleName) {
1128      var module = instance.modules[moduleName];
1129      var moduleParams = modulesParams[moduleName] || {};
1130      // Extend instance methods and props
1131      if (module.instance) {
1132        Object.keys(module.instance).forEach(function (modulePropName) {
1133          var moduleProp = module.instance[modulePropName];
1134          if (typeof moduleProp === 'function') {
1135            instance[modulePropName] = moduleProp.bind(instance);
1136          } else {
1137            instance[modulePropName] = moduleProp;
1138          }
1139        });
1140      }
1141      // Add event listeners
1142      if (module.on && instance.on) {
1143        Object.keys(module.on).forEach(function (moduleEventName) {
1144          instance.on(moduleEventName, module.on[moduleEventName]);
1145        });
1146      }
1147
1148      // Module create callback
1149      if (module.create) {
1150        module.create.bind(instance)(moduleParams);
1151      }
1152    });
1153  };
1154
1155  staticAccessors.components.set = function (components) {
1156    var Class = this;
1157    if (!Class.use) { return; }
1158    Class.use(components);
1159  };
1160
1161  SwiperClass.installModule = function installModule (module) {
1162      var params = [], len = arguments.length - 1;
1163      while ( len-- > 0 ) params[ len ] = arguments[ len + 1 ];
1164
1165    var Class = this;
1166    if (!Class.prototype.modules) { Class.prototype.modules = {}; }
1167    var name = module.name || (((Object.keys(Class.prototype.modules).length) + "_" + (Utils.now())));
1168    Class.prototype.modules[name] = module;
1169    // Prototype
1170    if (module.proto) {
1171      Object.keys(module.proto).forEach(function (key) {
1172        Class.prototype[key] = module.proto[key];
1173      });
1174    }
1175    // Class
1176    if (module.static) {
1177      Object.keys(module.static).forEach(function (key) {
1178        Class[key] = module.static[key];
1179      });
1180    }
1181    // Callback
1182    if (module.install) {
1183      module.install.apply(Class, params);
1184    }
1185    return Class;
1186  };
1187
1188  SwiperClass.use = function use (module) {
1189      var params = [], len = arguments.length - 1;
1190      while ( len-- > 0 ) params[ len ] = arguments[ len + 1 ];
1191
1192    var Class = this;
1193    if (Array.isArray(module)) {
1194      module.forEach(function (m) { return Class.installModule(m); });
1195      return Class;
1196    }
1197    return Class.installModule.apply(Class, [ module ].concat( params ));
1198  };
1199
1200  Object.defineProperties( SwiperClass, staticAccessors );
1201
1202  function updateSize () {
1203    var swiper = this;
1204    var width;
1205    var height;
1206    var $el = swiper.$el;
1207    if (typeof swiper.params.width !== 'undefined') {
1208      width = swiper.params.width;
1209    } else {
1210      width = $el[0].clientWidth;
1211    }
1212    if (typeof swiper.params.height !== 'undefined') {
1213      height = swiper.params.height;
1214    } else {
1215      height = $el[0].clientHeight;
1216    }
1217    if ((width === 0 && swiper.isHorizontal()) || (height === 0 && swiper.isVertical())) {
1218      return;
1219    }
1220
1221    // Subtract paddings
1222    width = width - parseInt($el.css('padding-left'), 10) - parseInt($el.css('padding-right'), 10);
1223    height = height - parseInt($el.css('padding-top'), 10) - parseInt($el.css('padding-bottom'), 10);
1224
1225    Utils.extend(swiper, {
1226      width: width,
1227      height: height,
1228      size: swiper.isHorizontal() ? width : height,
1229    });
1230  }
1231
1232  function updateSlides () {
1233    var swiper = this;
1234    var params = swiper.params;
1235
1236    var $wrapperEl = swiper.$wrapperEl;
1237    var swiperSize = swiper.size;
1238    var rtl = swiper.rtlTranslate;
1239    var wrongRTL = swiper.wrongRTL;
1240    var isVirtual = swiper.virtual && params.virtual.enabled;
1241    var previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1242    var slides = $wrapperEl.children(("." + (swiper.params.slideClass)));
1243    var slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1244    var snapGrid = [];
1245    var slidesGrid = [];
1246    var slidesSizesGrid = [];
1247
1248    var offsetBefore = params.slidesOffsetBefore;
1249    if (typeof offsetBefore === 'function') {
1250      offsetBefore = params.slidesOffsetBefore.call(swiper);
1251    }
1252
1253    var offsetAfter = params.slidesOffsetAfter;
1254    if (typeof offsetAfter === 'function') {
1255      offsetAfter = params.slidesOffsetAfter.call(swiper);
1256    }
1257
1258    var previousSnapGridLength = swiper.snapGrid.length;
1259    var previousSlidesGridLength = swiper.snapGrid.length;
1260
1261    var spaceBetween = params.spaceBetween;
1262    var slidePosition = -offsetBefore;
1263    var prevSlideSize = 0;
1264    var index = 0;
1265    if (typeof swiperSize === 'undefined') {
1266      return;
1267    }
1268    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1269      spaceBetween = (parseFloat(spaceBetween.replace('%', '')) / 100) * swiperSize;
1270    }
1271
1272    swiper.virtualSize = -spaceBetween;
1273
1274    // reset margins
1275    if (rtl) { slides.css({ marginLeft: '', marginTop: '' }); }
1276    else { slides.css({ marginRight: '', marginBottom: '' }); }
1277
1278    var slidesNumberEvenToRows;
1279    if (params.slidesPerColumn > 1) {
1280      if (Math.floor(slidesLength / params.slidesPerColumn) === slidesLength / swiper.params.slidesPerColumn) {
1281        slidesNumberEvenToRows = slidesLength;
1282      } else {
1283        slidesNumberEvenToRows = Math.ceil(slidesLength / params.slidesPerColumn) * params.slidesPerColumn;
1284      }
1285      if (params.slidesPerView !== 'auto' && params.slidesPerColumnFill === 'row') {
1286        slidesNumberEvenToRows = Math.max(slidesNumberEvenToRows, params.slidesPerView * params.slidesPerColumn);
1287      }
1288    }
1289
1290    // Calc slides
1291    var slideSize;
1292    var slidesPerColumn = params.slidesPerColumn;
1293    var slidesPerRow = slidesNumberEvenToRows / slidesPerColumn;
1294    var numFullColumns = slidesPerRow - ((params.slidesPerColumn * slidesPerRow) - slidesLength);
1295    for (var i = 0; i < slidesLength; i += 1) {
1296      slideSize = 0;
1297      var slide = slides.eq(i);
1298      if (params.slidesPerColumn > 1) {
1299        // Set slides order
1300        var newSlideOrderIndex = (void 0);
1301        var column = (void 0);
1302        var row = (void 0);
1303        if (params.slidesPerColumnFill === 'column') {
1304          column = Math.floor(i / slidesPerColumn);
1305          row = i - (column * slidesPerColumn);
1306          if (column > numFullColumns || (column === numFullColumns && row === slidesPerColumn - 1)) {
1307            row += 1;
1308            if (row >= slidesPerColumn) {
1309              row = 0;
1310              column += 1;
1311            }
1312          }
1313          newSlideOrderIndex = column + ((row * slidesNumberEvenToRows) / slidesPerColumn);
1314          slide
1315            .css({
1316              '-webkit-box-ordinal-group': newSlideOrderIndex,
1317              '-moz-box-ordinal-group': newSlideOrderIndex,
1318              '-ms-flex-order': newSlideOrderIndex,
1319              '-webkit-order': newSlideOrderIndex,
1320              order: newSlideOrderIndex,
1321            });
1322        } else {
1323          row = Math.floor(i / slidesPerRow);
1324          column = i - (row * slidesPerRow);
1325        }
1326        slide
1327          .css(
1328            ("margin-" + (swiper.isHorizontal() ? 'top' : 'left')),
1329            (row !== 0 && params.spaceBetween) && (((params.spaceBetween) + "px"))
1330          )
1331          .attr('data-swiper-column', column)
1332          .attr('data-swiper-row', row);
1333      }
1334      if (slide.css('display') === 'none') { continue; } // eslint-disable-line
1335
1336      if (params.slidesPerView === 'auto') {
1337        var slideStyles = win.getComputedStyle(slide[0], null);
1338        var currentTransform = slide[0].style.transform;
1339        var currentWebKitTransform = slide[0].style.webkitTransform;
1340        if (currentTransform) {
1341          slide[0].style.transform = 'none';
1342        }
1343        if (currentWebKitTransform) {
1344          slide[0].style.webkitTransform = 'none';
1345        }
1346        if (params.roundLengths) {
1347          slideSize = swiper.isHorizontal()
1348            ? slide.outerWidth(true)
1349            : slide.outerHeight(true);
1350        } else {
1351          // eslint-disable-next-line
1352          if (swiper.isHorizontal()) {
1353            slideSize = parseFloat(slideStyles.getPropertyValue('width'))
1354              + parseFloat(slideStyles.getPropertyValue('margin-left'))
1355              + parseFloat(slideStyles.getPropertyValue('margin-right'));
1356          } else {
1357            slideSize = parseFloat(slideStyles.getPropertyValue('height'))
1358              + parseFloat(slideStyles.getPropertyValue('margin-top'))
1359              + parseFloat(slideStyles.getPropertyValue('margin-bottom'));
1360          }
1361        }
1362        if (currentTransform) {
1363          slide[0].style.transform = currentTransform;
1364        }
1365        if (currentWebKitTransform) {
1366          slide[0].style.webkitTransform = currentWebKitTransform;
1367        }
1368        if (params.roundLengths) { slideSize = Math.floor(slideSize); }
1369      } else {
1370        slideSize = (swiperSize - ((params.slidesPerView - 1) * spaceBetween)) / params.slidesPerView;
1371        if (params.roundLengths) { slideSize = Math.floor(slideSize); }
1372
1373        if (slides[i]) {
1374          if (swiper.isHorizontal()) {
1375            slides[i].style.width = slideSize + "px";
1376          } else {
1377            slides[i].style.height = slideSize + "px";
1378          }
1379        }
1380      }
1381      if (slides[i]) {
1382        slides[i].swiperSlideSize = slideSize;
1383      }
1384      slidesSizesGrid.push(slideSize);
1385
1386
1387      if (params.centeredSlides) {
1388        slidePosition = slidePosition + (slideSize / 2) + (prevSlideSize / 2) + spaceBetween;
1389        if (prevSlideSize === 0 && i !== 0) { slidePosition = slidePosition - (swiperSize / 2) - spaceBetween; }
1390        if (i === 0) { slidePosition = slidePosition - (swiperSize / 2) - spaceBetween; }
1391        if (Math.abs(slidePosition) < 1 / 1000) { slidePosition = 0; }
1392        if (params.roundLengths) { slidePosition = Math.floor(slidePosition); }
1393        if ((index) % params.slidesPerGroup === 0) { snapGrid.push(slidePosition); }
1394        slidesGrid.push(slidePosition);
1395      } else {
1396        if (params.roundLengths) { slidePosition = Math.floor(slidePosition); }
1397        if ((index) % params.slidesPerGroup === 0) { snapGrid.push(slidePosition); }
1398        slidesGrid.push(slidePosition);
1399        slidePosition = slidePosition + slideSize + spaceBetween;
1400      }
1401
1402      swiper.virtualSize += slideSize + spaceBetween;
1403
1404      prevSlideSize = slideSize;
1405
1406      index += 1;
1407    }
1408    swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1409    var newSlidesGrid;
1410
1411    if (
1412      rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1413      $wrapperEl.css({ width: ((swiper.virtualSize + params.spaceBetween) + "px") });
1414    }
1415    if (!Support.flexbox || params.setWrapperSize) {
1416      if (swiper.isHorizontal()) { $wrapperEl.css({ width: ((swiper.virtualSize + params.spaceBetween) + "px") }); }
1417      else { $wrapperEl.css({ height: ((swiper.virtualSize + params.spaceBetween) + "px") }); }
1418    }
1419
1420    if (params.slidesPerColumn > 1) {
1421      swiper.virtualSize = (slideSize + params.spaceBetween) * slidesNumberEvenToRows;
1422      swiper.virtualSize = Math.ceil(swiper.virtualSize / params.slidesPerColumn) - params.spaceBetween;
1423      if (swiper.isHorizontal()) { $wrapperEl.css({ width: ((swiper.virtualSize + params.spaceBetween) + "px") }); }
1424      else { $wrapperEl.css({ height: ((swiper.virtualSize + params.spaceBetween) + "px") }); }
1425      if (params.centeredSlides) {
1426        newSlidesGrid = [];
1427        for (var i$1 = 0; i$1 < snapGrid.length; i$1 += 1) {
1428          var slidesGridItem = snapGrid[i$1];
1429          if (params.roundLengths) { slidesGridItem = Math.floor(slidesGridItem); }
1430          if (snapGrid[i$1] < swiper.virtualSize + snapGrid[0]) { newSlidesGrid.push(slidesGridItem); }
1431        }
1432        snapGrid = newSlidesGrid;
1433      }
1434    }
1435
1436    // Remove last grid elements depending on width
1437    if (!params.centeredSlides) {
1438      newSlidesGrid = [];
1439      for (var i$2 = 0; i$2 < snapGrid.length; i$2 += 1) {
1440        var slidesGridItem$1 = snapGrid[i$2];
1441        if (params.roundLengths) { slidesGridItem$1 = Math.floor(slidesGridItem$1); }
1442        if (snapGrid[i$2] <= swiper.virtualSize - swiperSize) {
1443          newSlidesGrid.push(slidesGridItem$1);
1444        }
1445      }
1446      snapGrid = newSlidesGrid;
1447      if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1448        snapGrid.push(swiper.virtualSize - swiperSize);
1449      }
1450    }
1451    if (snapGrid.length === 0) { snapGrid = [0]; }
1452
1453    if (params.spaceBetween !== 0) {
1454      if (swiper.isHorizontal()) {
1455        if (rtl) { slides.css({ marginLeft: (spaceBetween + "px") }); }
1456        else { slides.css({ marginRight: (spaceBetween + "px") }); }
1457      } else { slides.css({ marginBottom: (spaceBetween + "px") }); }
1458    }
1459
1460    if (params.centerInsufficientSlides) {
1461      var allSlidesSize = 0;
1462      slidesSizesGrid.forEach(function (slideSizeValue) {
1463        allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1464      });
1465      allSlidesSize -= params.spaceBetween;
1466      if (allSlidesSize < swiperSize) {
1467        var allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1468        snapGrid.forEach(function (snap, snapIndex) {
1469          snapGrid[snapIndex] = snap - allSlidesOffset;
1470        });
1471        slidesGrid.forEach(function (snap, snapIndex) {
1472          slidesGrid[snapIndex] = snap + allSlidesOffset;
1473        });
1474      }
1475    }
1476
1477    Utils.extend(swiper, {
1478      slides: slides,
1479      snapGrid: snapGrid,
1480      slidesGrid: slidesGrid,
1481      slidesSizesGrid: slidesSizesGrid,
1482    });
1483
1484    if (slidesLength !== previousSlidesLength) {
1485      swiper.emit('slidesLengthChange');
1486    }
1487    if (snapGrid.length !== previousSnapGridLength) {
1488      if (swiper.params.watchOverflow) { swiper.checkOverflow(); }
1489      swiper.emit('snapGridLengthChange');
1490    }
1491    if (slidesGrid.length !== previousSlidesGridLength) {
1492      swiper.emit('slidesGridLengthChange');
1493    }
1494
1495    if (params.watchSlidesProgress || params.watchSlidesVisibility) {
1496      swiper.updateSlidesOffset();
1497    }
1498  }
1499
1500  function updateAutoHeight (speed) {
1501    var swiper = this;
1502    var activeSlides = [];
1503    var newHeight = 0;
1504    var i;
1505    if (typeof speed === 'number') {
1506      swiper.setTransition(speed);
1507    } else if (speed === true) {
1508      swiper.setTransition(swiper.params.speed);
1509    }
1510    // Find slides currently in view
1511    if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1512      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1513        var index = swiper.activeIndex + i;
1514        if (index > swiper.slides.length) { break; }
1515        activeSlides.push(swiper.slides.eq(index)[0]);
1516      }
1517    } else {
1518      activeSlides.push(swiper.slides.eq(swiper.activeIndex)[0]);
1519    }
1520
1521    // Find new height from highest slide in view
1522    for (i = 0; i < activeSlides.length; i += 1) {
1523      if (typeof activeSlides[i] !== 'undefined') {
1524        var height = activeSlides[i].offsetHeight;
1525        newHeight = height > newHeight ? height : newHeight;
1526      }
1527    }
1528
1529    // Update Height
1530    if (newHeight) { swiper.$wrapperEl.css('height', (newHeight + "px")); }
1531  }
1532
1533  function updateSlidesOffset () {
1534    var swiper = this;
1535    var slides = swiper.slides;
1536    for (var i = 0; i < slides.length; i += 1) {
1537      slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;
1538    }
1539  }
1540
1541  function updateSlidesProgress (translate) {
1542    if ( translate === void 0 ) translate = (this && this.translate) || 0;
1543
1544    var swiper = this;
1545    var params = swiper.params;
1546
1547    var slides = swiper.slides;
1548    var rtl = swiper.rtlTranslate;
1549
1550    if (slides.length === 0) { return; }
1551    if (typeof slides[0].swiperSlideOffset === 'undefined') { swiper.updateSlidesOffset(); }
1552
1553    var offsetCenter = -translate;
1554    if (rtl) { offsetCenter = translate; }
1555
1556    // Visible Slides
1557    slides.removeClass(params.slideVisibleClass);
1558
1559    swiper.visibleSlidesIndexes = [];
1560    swiper.visibleSlides = [];
1561
1562    for (var i = 0; i < slides.length; i += 1) {
1563      var slide = slides[i];
1564      var slideProgress = (
1565        (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0)) - slide.swiperSlideOffset
1566      ) / (slide.swiperSlideSize + params.spaceBetween);
1567      if (params.watchSlidesVisibility) {
1568        var slideBefore = -(offsetCenter - slide.swiperSlideOffset);
1569        var slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1570        var isVisible = (slideBefore >= 0 && slideBefore < swiper.size)
1571                  || (slideAfter > 0 && slideAfter <= swiper.size)
1572                  || (slideBefore <= 0 && slideAfter >= swiper.size);
1573        if (isVisible) {
1574          swiper.visibleSlides.push(slide);
1575          swiper.visibleSlidesIndexes.push(i);
1576          slides.eq(i).addClass(params.slideVisibleClass);
1577        }
1578      }
1579      slide.progress = rtl ? -slideProgress : slideProgress;
1580    }
1581    swiper.visibleSlides = $(swiper.visibleSlides);
1582  }
1583
1584  function updateProgress (translate) {
1585    if ( translate === void 0 ) translate = (this && this.translate) || 0;
1586
1587    var swiper = this;
1588    var params = swiper.params;

1588
1589
1590    var translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1591    var progress = swiper.progress;
1592    var isBeginning = swiper.isBeginning;
1593    var isEnd = swiper.isEnd;
1594    var wasBeginning = isBeginning;
1595    var wasEnd = isEnd;
1596    if (translatesDiff === 0) {
1597      progress = 0;
1598      isBeginning = true;
1599      isEnd = true;
1600    } else {
1601      progress = (translate - swiper.minTranslate()) / (translatesDiff);
1602      isBeginning = progress <= 0;
1603      isEnd = progress >= 1;
1604    }
1605    Utils.extend(swiper, {
1606      progress: progress,
1607      isBeginning: isBeginning,
1608      isEnd: isEnd,
1609    });
1610
1611    if (params.watchSlidesProgress || params.watchSlidesVisibility) { swiper.updateSlidesProgress(translate); }
1612
1613    if (isBeginning && !wasBeginning) {
1614      swiper.emit('reachBeginning toEdge');
1615    }
1616    if (isEnd && !wasEnd) {
1617      swiper.emit('reachEnd toEdge');
1618    }
1619    if ((wasBeginning && !isBeginning) || (wasEnd && !isEnd)) {
1620      swiper.emit('fromEdge');
1621    }
1622
1623    swiper.emit('progress', progress);
1624  }
1625
1626  function updateSlidesClasses () {
1627    var swiper = this;
1628
1629    var slides = swiper.slides;
1630    var params = swiper.params;
1631    var $wrapperEl = swiper.$wrapperEl;
1632    var activeIndex = swiper.activeIndex;
1633    var realIndex = swiper.realIndex;
1634    var isVirtual = swiper.virtual && params.virtual.enabled;
1635
1636    slides.removeClass(((params.slideActiveClass) + " " + (params.slideNextClass) + " " + (params.slidePrevClass) + " " + (params.slideDuplicateActiveClass) + " " + (params.slideDuplicateNextClass) + " " + (params.slideDuplicatePrevClass)));
1637
1638    var activeSlide;
1639    if (isVirtual) {
1640      activeSlide = swiper.$wrapperEl.find(("." + (params.slideClass) + "[data-swiper-slide-index=\"" + activeIndex + "\"]"));
1641    } else {
1642      activeSlide = slides.eq(activeIndex);
1643    }
1644
1645    // Active classes
1646    activeSlide.addClass(params.slideActiveClass);
1647
1648    if (params.loop) {
1649      // Duplicate to all looped slides
1650      if (activeSlide.hasClass(params.slideDuplicateClass)) {
1651        $wrapperEl
1652          .children(("." + (params.slideClass) + ":not(." + (params.slideDuplicateClass) + ")[data-swiper-slide-index=\"" + realIndex + "\"]"))
1653          .addClass(params.slideDuplicateActiveClass);
1654      } else {
1655        $wrapperEl
1656          .children(("." + (params.slideClass) + "." + (params.slideDuplicateClass) + "[data-swiper-slide-index=\"" + realIndex + "\"]"))
1657          .addClass(params.slideDuplicateActiveClass);
1658      }
1659    }
1660    // Next Slide
1661    var nextSlide = activeSlide.nextAll(("." + (params.slideClass))).eq(0).addClass(params.slideNextClass);
1662    if (params.loop && nextSlide.length === 0) {
1663      nextSlide = slides.eq(0);
1664      nextSlide.addClass(params.slideNextClass);
1665    }
1666    // Prev Slide
1667    var prevSlide = activeSlide.prevAll(("." + (params.slideClass))).eq(0).addClass(params.slidePrevClass);
1668    if (params.loop && prevSlide.length === 0) {
1669      prevSlide = slides.eq(-1);
1670      prevSlide.addClass(params.slidePrevClass);
1671    }
1672    if (params.loop) {
1673      // Duplicate to all looped slides
1674      if (nextSlide.hasClass(params.slideDuplicateClass)) {
1675        $wrapperEl
1676          .children(("." + (params.slideClass) + ":not(." + (params.slideDuplicateClass) + ")[data-swiper-slide-index=\"" + (nextSlide.attr('data-swiper-slide-index')) + "\"]"))
1677          .addClass(params.slideDuplicateNextClass);
1678      } else {
1679        $wrapperEl
1680          .children(("." + (params.slideClass) + "." + (params.slideDuplicateClass) + "[data-swiper-slide-index=\"" + (nextSlide.attr('data-swiper-slide-index')) + "\"]"))
1681          .addClass(params.slideDuplicateNextClass);
1682      }
1683      if (prevSlide.hasClass(params.slideDuplicateClass)) {
1684        $wrapperEl
1685          .children(("." + (params.slideClass) + ":not(." + (params.slideDuplicateClass) + ")[data-swiper-slide-index=\"" + (prevSlide.attr('data-swiper-slide-index')) + "\"]"))
1686          .addClass(params.slideDuplicatePrevClass);
1687      } else {
1688        $wrapperEl
1689          .children(("." + (params.slideClass) + "." + (params.slideDuplicateClass) + "[data-swiper-slide-index=\"" + (prevSlide.attr('data-swiper-slide-index')) + "\"]"))
1690          .addClass(params.slideDuplicatePrevClass);
1691      }
1692    }
1693  }
1694
1695  function updateActiveIndex (newActiveIndex) {
1696    var swiper = this;
1697    var translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1698    var slidesGrid = swiper.slidesGrid;
1699    var snapGrid = swiper.snapGrid;
1700    var params = swiper.params;
1701    var previousIndex = swiper.activeIndex;
1702    var previousRealIndex = swiper.realIndex;
1703    var previousSnapIndex = swiper.snapIndex;
1704    var activeIndex = newActiveIndex;
1705    var snapIndex;
1706    if (typeof activeIndex === 'undefined') {
1707      for (var i = 0; i < slidesGrid.length; i += 1) {
1708        if (typeof slidesGrid[i + 1] !== 'undefined') {
1709          if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - ((slidesGrid[i + 1] - slidesGrid[i]) / 2)) {
1710            activeIndex = i;
1711          } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1712            activeIndex = i + 1;
1713          }
1714        } else if (translate >= slidesGrid[i]) {
1715          activeIndex = i;
1716        }
1717      }
1718      // Normalize slideIndex
1719      if (params.normalizeSlideIndex) {
1720        if (activeIndex < 0 || typeof activeIndex === 'undefined') { activeIndex = 0; }
1721      }
1722    }
1723    if (snapGrid.indexOf(translate) >= 0) {
1724      snapIndex = snapGrid.indexOf(translate);
1725    } else {
1726      snapIndex = Math.floor(activeIndex / params.slidesPerGroup);
1727    }
1728    if (snapIndex >= snapGrid.length) { snapIndex = snapGrid.length - 1; }
1729    if (activeIndex === previousIndex) {
1730      if (snapIndex !== previousSnapIndex) {
1731        swiper.snapIndex = snapIndex;
1732        swiper.emit('snapIndexChange');
1733      }
1734      return;
1735    }
1736
1737    // Get real index
1738    var realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);
1739
1740    Utils.extend(swiper, {
1741      snapIndex: snapIndex,
1742      realIndex: realIndex,
1743      previousIndex: previousIndex,
1744      activeIndex: activeIndex,
1745    });
1746    swiper.emit('activeIndexChange');
1747    swiper.emit('snapIndexChange');
1748    if (previousRealIndex !== realIndex) {
1749      swiper.emit('realIndexChange');
1750    }
1751    

1751
1752  }
1753
1754  function updateClickedSlide (e) {
1755    var swiper = this;
1756    var params = swiper.params;
1757    var slide = $(e.target).closest(("." + (params.slideClass)))[0];
1758    var slideFound = false;
1759    if (slide) {
1760      for (var i = 0; i < swiper.slides.length; i += 1) {
1761        if (swiper.slides[i] === slide) { slideFound = true; }
1762      }
1763    }
1764
1765    if (slide && slideFound) {
1766      swiper.clickedSlide = slide;
1767      if (swiper.virtual && swiper.params.virtual.enabled) {
1768        swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);
1769      } else {
1770        swiper.clickedIndex = $(slide).index();
1771      }
1772    } else {
1773      swiper.clickedSlide = undefined;
1774      swiper.clickedIndex = undefined;
1775      return;
1776    }
1777    if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1778      swiper.slideToClickedSlide();
1779    }
1780  }
1781
1782  var update = {
1783    updateSize: updateSize,
1784    updateSlides: updateSlides,
1785    updateAutoHeight: updateAutoHeight,
1786    updateSlidesOffset: updateSlidesOffset,
1787    updateSlidesProgress: updateSlidesProgress,
1788    updateProgress: updateProgress,
1789    updateSlidesClasses: updateSlidesClasses,
1790    updateActiveIndex: updateActiveIndex,
1791    updateClickedSlide: updateClickedSlide,
1792  };
1793
1794  function getTranslate (axis) {
1795    if ( axis === void 0 ) axis = this.isHorizontal() ? 'x' : 'y';
1796
1797    var swiper = this;
1798
1799    var params = swiper.params;
1800    var rtl = swiper.rtlTranslate;
1801    var translate = swiper.translate;
1802    var $wrapperEl = swiper.$wrapperEl;
1803
1804    if (params.virtualTranslate) {
1805      return rtl ? -translate : translate;
1806    }
1807
1808    var currentTranslate = Utils.getTranslate($wrapperEl[0], axis);
1809    if (rtl) { currentTranslate = -currentTranslate; }
1810
1811    return currentTranslate || 0;
1812  }
1813
1814  function setTranslate (translate, byController) {
1815    var swiper = this;
1816    var rtl = swiper.rtlTranslate;
1817    var params = swiper.params;
1818    var $wrapperEl = swiper.$wrapperEl;
1819    var progress = swiper.progress;
1820    var x = 0;
1821    var y = 0;
1822    var z = 0;
1823
1824    if (swiper.isHorizontal()) {
1825      x = rtl ? -translate : translate;
1826    } else {
1827      y = translate;
1828    }
1829
1830    if (params.roundLengths) {
1831      x = Math.floor(x);
1832      y = Math.floor(y);
1833    }
1834
1835    if (!params.virtualTranslate) {
1836      if (Support.transforms3d) { $wrapperEl.transform(("translate3d(" + x + "px, " + y + "px, " + z + "px)")); }
1837      else { $wrapperEl.transform(("translate(" + x + "px, " + y + "px)")); }
1838    }
1839    swiper.previousTranslate = swiper.translate;
1840    swiper.translate = swiper.isHorizontal() ? x : y;
1841
1842    // Check if we need to update progress
1843    var newProgress;
1844    var translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1845    if (translatesDiff === 0) {
1846      newProgress = 0;
1847    } else {
1848      newProgress = (translate - swiper.minTranslate()) / (translatesDiff);
1849    }
1850    if (newProgress !== progress) {
1851      swiper.updateProgress(translate);
1852    }
1853
1854    swiper.emit('setTranslate', swiper.translate, byController);
1855  }
1856
1857  function minTranslate () {
1858    return (-this.snapGrid[0]);
1859  }
1860
1861  function maxTranslate () {
1862    return (-this.snapGrid[this.snapGrid.length - 1]);
1863  }
1864
1865  var translate = {
1866    getTranslate: getTranslate,
1867    setTranslate: setTranslate,
1868    minTranslate: minTranslate,
1869    maxTranslate: maxTranslate,
1870  };
1871
1872  function setTransition (duration, byController) {
1873    var swiper = this;
1874
1875    swiper.$wrapperEl.transition(duration);
1876
1877    swiper.emit('setTransition', duration, byController);
1878  }
1879
1880  function transitionStart (runCallbacks, direction) {
1881    if ( runCallbacks === void 0 ) runCallbacks = true;
1882
1883    var swiper = this;
1884    var activeIndex = swiper.activeIndex;
1885    var params = swiper.params;
1886    var previousIndex = swiper.previousIndex;
1887    if (params.autoHeight) {
1888      swiper.updateAutoHeight();
1889    }
1890
1891    var dir = direction;
1892    if (!dir) {
1893      if (activeIndex > previousIndex) { dir = 'next'; }
1894      else if (activeIndex < previousIndex) { dir = 'prev'; }
1895      else { dir = 'reset'; }
1896    }
1897
1898    swiper.emit('transitionStart');
1899
1900    if (runCallbacks && activeIndex !== previousIndex) {
1901      if (dir === 'reset') {
1902        swiper.emit('slideResetTransitionStart');
1903        return;
1904      }
1905      swiper.emit('slideChangeTransitionStart');
1906      if (dir === 'next') {
1907        swiper.emit('slideNextTransitionStart');
1908      } else {
1909        swiper.emit('slidePrevTransitionStart');
1910      }
1911    }
1912  }
1913
1914  function transitionEnd$1 (runCallbacks, direction) {
1915    if ( runCallbacks === void 0 ) runCallbacks = true;
1916
1917    var swiper = this;
1918    var activeIndex = swiper.activeIndex;
1919    var previousIndex = swiper.previousIndex;
1920    swiper.animating = false;
1921    swiper.setTransition(0);
1922
1923    var dir = direction;
1924    if (!dir) {
1925      if (activeIndex > previousIndex) { dir = 'next'; }
1926      else if (activeIndex < previousIndex) { dir = 'prev'; }
1927      else { dir = 'reset'; }
1928    }
1929
1930    swiper.emit('transitionEnd');
1931
1932    if (runCallbacks && activeIndex !== previousIndex) {
1933      if (dir === 'reset') {
1934        swiper.emit('slideResetTransitionEnd');
1935        return;
1936      }
1937      swiper.emit('slideChangeTransitionEnd');
1938      if (dir === 'next') {
1939        swiper.emit('slideNextTransitionEnd');
1940      } else {
1941        swiper.emit('slidePrevTransitionEnd');
1942      }
1943    }
1944  }
1945
1946  var transition$1 = {
1947    setTransition: setTransition,
1948    transitionStart: transitionStart,
1949    transitionEnd: transitionEnd$1,
1950  };
1951
1952  function slideTo (index, speed, runCallbacks, internal) {
1953    if ( index === void 0 ) index = 0;
1954    if ( speed === void 0 ) speed = this.params.speed;
1955    if ( runCallbacks === void 0 ) runCallbacks = true;
1956
1957    var swiper = this;
1958    var slideIndex = index;
1959    if (slideIndex < 0) { slideIndex = 0; }
1960
1961    var params = swiper.params;
1962    var snapGrid = swiper.snapGrid;
1963    var slidesGrid = swiper.slidesGrid;
1964    var previousIndex = swiper.previousIndex;
1965    var activeIndex = swiper.activeIndex;
1966    var rtl = swiper.rtlTranslate;
1967    if (swiper.animating && params.preventInteractionOnTransition) {
1968      return false;
1969    }
1970
1971    var snapIndex = Math.floor(slideIndex / params.slidesPerGroup);
1972    if (snapIndex >= snapGrid.length) { snapIndex = snapGrid.length - 1; }
1973
1974    if ((activeIndex || params.initialSlide || 0) === (previousIndex || 0) && runCallbacks) {
1975      swiper.emit('beforeSlideChangeStart');
1976    }
1977
1978    var translate = -snapGrid[snapIndex];
1979
1980    // Update progress
1981    swiper.updateProgress(translate);
1982
1983    // Normalize slideIndex
1984    if (params.normalizeSlideIndex) {
1985      for (var i = 0; i < slidesGrid.length; i += 1) {
1986        if (-Math.floor(translate * 100) >= Math.floor(slidesGrid[i] * 100)) {
1987          slideIndex = i;
1988        }
1989      }
1990    }
1991    // Directions locks
1992    if (swiper.initialized && slideIndex !== activeIndex) {
1993      if (!swiper.allowSlideNext && translate < swiper.translate && translate < swiper.minTranslate()) {
1994        return false;
1995      }
1996      if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
1997        if ((activeIndex || 0) !== slideIndex) { return false; }
1998      }
1999    }
2000
2001    var direction;
2002    if (slideIndex > activeIndex) { direction = 'next'; }
2003    else if (slideIndex < activeIndex) { direction = 'prev'; }
2004    else { direction = 'reset'; }
2005
2006
2007    // Update Index
2008    if ((rtl && -translate === swiper.translate) || (!rtl && translate === swiper.translate)) {
2009      swiper.updateActiveIndex(slideIndex);
2010      // Update Height
2011      if (params.autoHeight) {
2012        swiper.updateAutoHeight();
2013      }
2014      swiper.updateSlidesClasses();
2015      if (params.effect !== 'slide') {
2016        swiper.setTranslate(translate);
2017      }
2018      if (direction !== 'reset') {
2019        swiper.transitionStart(runCallbacks, direction);
2020        swiper.transitionEnd(runCallbacks, direction);
2021      }
2022      return false;
2023    }
2024
2025    if (speed === 0 || !Support.transition) {
2026      swiper.setTransition(0);
2027      swiper.setTranslate(translate);
2028      swiper.updateActiveIndex(slideIndex);
2029      swiper.updateSlidesClasses();
2030      swiper.emit('beforeTransitionStart', speed, internal);
2031      swiper.transitionStart(runCallbacks, direction);
2032      swiper.transitionEnd(runCallbacks, direction);
2033    } else {
2034      swiper.setTransition(speed);
2035      swiper.setTranslate(translate);
2036      swiper.updateActiveIndex(slideIndex);
2037      swiper.updateSlidesClasses();
2038      swiper.emit('beforeTransitionStart', speed, internal);
2039      swiper.transitionStart(runCallbacks, direction);
2040      if (!swiper.animating) {
2041        swiper.animating = true;
2042        if (!swiper.onSlideToWrapperTransitionEnd) {
2043          swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2044            if (!swiper || swiper.destroyed) { return; }
2045            if (e.target !== this) { return; }
2046            swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2047            swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2048            swiper.onSlideToWrapperTransitionEnd = null;
2049            delete swiper.onSlideToWrapperTransitionEnd;
2050            swiper.transitionEnd(runCallbacks, direction);
2051          };
2052        }
2053        swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2054        swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2055      }
2056    }
2057
2058    return true;
2059  }
2060
2061  function slideToLoop (index, speed, runCallbacks, internal) {
2062    if ( index === void 0 ) index = 0;
2063    if ( speed === void 0 ) speed = this.params.speed;
2064    if ( runCallbacks === void 0 ) runCallbacks = true;
2065
2066    var swiper = this;
2067    var newIndex = index;
2068    if (swiper.params.loop) {
2069      newIndex += swiper.loopedSlides;
2070    }
2071
2072    return swiper.slideTo(newIndex, speed, runCallbacks, internal);
2073  }
2074
2075  /* eslint no-unused-vars: "off" */
2076  function slideNext (speed, runCallbacks, internal) {
2077    if ( speed === void 0 ) speed = this.params.speed;
2078    if ( runCallbacks === void 0 ) runCallbacks = true;
2079
2080    var swiper = this;
2081    var params = swiper.params;
2082    var animating = swiper.animating;
2083    if (params.loop) {
2084      if (animating) { return false; }
2085      swiper.loopFix();
2086      // eslint-disable-next-line
2087      swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2088      return swiper.slideTo(swiper.activeIndex + params.slidesPerGroup, speed, runCallbacks, internal);
2089    }
2090    return swiper.slideTo(swiper.activeIndex + params.slidesPerGroup, speed, runCallbacks, internal);
2091  }
2092
2093  /* eslint no-unused-vars: "off" */
2094  function slidePrev (speed, runCallbacks, internal) {
2095    if ( speed === void 0 ) speed = this.params.speed;
2096    if ( runCallbacks === void 0 ) runCallbacks = true;
2097
2098    var swiper = this;
2099    var params = swiper.params;
2100    var animating = swiper.animating;
2101    var snapGrid = swiper.snapGrid;
2102    var slidesGrid = swiper.slidesGrid;
2103    var rtlTranslate = swiper.rtlTranslate;
2104
2105    if (params.loop) {
2106      if (animating) { return false; }
2107      swiper.loopFix();
2108      // eslint-disable-next-line
2109      swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2110    }
2111    var translate = rtlTranslate ? swiper.translate : -swiper.translate;
2112    function normalize(val) {
2113      if (val < 0) { return -Math.floor(Math.abs(val)); }
2114      return Math.floor(val);
2115    }
2116    var normalizedTranslate = normalize(translate);
2117    var normalizedSnapGrid = snapGrid.map(function (val) { return normalize(val); });
2118    var normalizedSlidesGrid = slidesGrid.map(function (val) { return normalize(val); });
2119
2120    var currentSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate)];
2121    var prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2122    var prevIndex;
2123    if (typeof prevSnap !== 'undefined') {
2124      prevIndex = slidesGrid.indexOf(prevSnap);
2125      if (prevIndex < 0) { prevIndex = swiper.activeIndex - 1; }
2126    }
2127    return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2128  }
2129
2130  /* eslint no-unused-vars: "off" */
2131  function slideReset (speed, runCallbacks, internal) {
2132    if ( speed === void 0 ) speed = this.params.speed;
2133    if ( runCallbacks === void 0 ) runCallbacks = true;
2134
2135    var swiper = this;
2136    return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2137  }
2138
2139  /* eslint no-unused-vars: "off" */
2140  function slideToClosest (speed, runCallbacks, internal) {
2141    if ( speed === void 0 ) speed = this.params.speed;
2142    if ( runCallbacks === void 0 ) runCallbacks = true;
2143
2144    var swiper = this;
2145    var index = swiper.activeIndex;
2146    var snapIndex = Math.floor(index / swiper.params.slidesPerGroup);
2147
2148    if (snapIndex < swiper.snapGrid.length - 1) {
2149      var translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2150
2151      var currentSnap = swiper.snapGrid[snapIndex];
2152      var nextSnap = swiper.snapGrid[snapIndex + 1];
2153
2154      if ((translate - currentSnap) > (nextSnap - currentSnap) / 2) {
2155        index = swiper.params.slidesPerGroup;
2156      }
2157    }
2158
2159    return swiper.slideTo(index, speed, runCallbacks, internal);
2160  }
2161
2162  function slideToClickedSlide () {
2163    var swiper = this;
2164    var params = swiper.params;
2165    var $wrapperEl = swiper.$wrapperEl;
2166
2167    var slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2168    var slideToIndex = swiper.clickedIndex;
2169    var realIndex;
2170    if (params.loop) {
2171      if (swiper.animating) { return; }
2172      realIndex = parseInt($(swiper.clickedSlide).attr('data-swiper-slide-index'), 10);
2173      if (params.centeredSlides) {
2174        if (
2175          (slideToIndex < swiper.loopedSlides - (slidesPerView / 2))
2176          || (slideToIndex > (swiper.slides.length - swiper.loopedSlides) + (slidesPerView / 2))
2177        ) {
2178          swiper.loopFix();
2179          slideToIndex = $wrapperEl
2180            .children(("." + (params.slideClass) + "[data-swiper-slide-index=\"" + realIndex + "\"]:not(." + (params.slideDuplicateClass) + ")"))
2181            .eq(0)
2182            .index();
2183
2184          Utils.nextTick(function () {
2185            swiper.slideTo(slideToIndex);
2186          });
2187        } else {
2188          swiper.slideTo(slideToIndex);
2189        }
2190      } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2191        swiper.loopFix();
2192        slideToIndex = $wrapperEl
2193          .children(("." + (params.slideClass) + "[data-swiper-slide-index=\"" + realIndex + "\"]:not(." + (params.slideDuplicateClass) + ")"))
2194          .eq(0)
2195          .index();
2196
2197        Utils.nextTick(function () {
2198          swiper.slideTo(slideToIndex);
2199        });
2200      } else {
2201        swiper.slideTo(slideToIndex);
2202      }
2203    } else {
2204      swiper.slideTo(slideToIndex);
2205    }
2206  }
2207
2208  var slide = {
2209    slideTo: slideTo,
2210    slideToLoop: slideToLoop,
2211    slideNext: slideNext,
2212    slidePrev: slidePrev,
2213    slideReset: slideReset,
2214    slideToClosest: slideToClosest,
2215    slideToClickedSlide: slideToClickedSlide,
2216  };
2217
2218  function loopCreate () {
2219    var swiper = this;
2220    var params = swiper.params;
2221    var $wrapperEl = swiper.$wrapperEl;
2222    // Remove duplicated slides
2223    $wrapperEl.children(("." + (params.slideClass) + "." + (params.slideDuplicateClass))).remove();
2224
2225    var slides = $wrapperEl.children(("." + (params.slideClass)));
2226
2227    if (params.loopFillGroupWithBlank) {
2228      var blankSlidesNum = params.slidesPerGroup - (slides.length % params.slidesPerGroup);
2229      if (blankSlidesNum !== params.slidesPerGroup) {
2230        for (var i = 0; i < blankSlidesNum; i += 1) {
2231          var blankNode = $(doc.createElement('div')).addClass(((params.slideClass) + " " + (params.slideBlankClass)));
2232          $wrapperEl.append(blankNode);
2233        }
2234        slides = $wrapperEl.children(("." + (params.slideClass)));
2235      }
2236    }
2237
2238    if (params.slidesPerView === 'auto' && !params.loopedSlides) { params.loopedSlides = slides.length; }
2239
2240    swiper.loopedSlides = parseInt(params.loopedSlides || params.slidesPerView, 10);
2241    swiper.loopedSlides += params.loopAdditionalSlides;
2242    if (swiper.loopedSlides > slides.length) {
2243      swiper.loopedSlides = slides.length;
2244    }
2245
2246    var prependSlides = [];
2247    var appendSlides = [];
2248    slides.each(function (index, el) {
2249      var slide = $(el);
2250      if (index < swiper.loopedSlides) { appendSlides.push(el); }
2251      if (index < slides.length && index >= slides.length - swiper.loopedSlides) { prependSlides.push(el); }
2252      slide.attr('data-swiper-slide-index', index);
2253    });
2254    for (var i$1 = 0; i$1 < appendSlides.length; i$1 += 1) {
2255      $wrapperEl.append($(appendSlides[i$1].cloneNode(true)).addClass(params.slideDuplicateClass));
2256    }
2257    for (var i$2 = prependSlides.length - 1; i$2 >= 0; i$2 -= 1) {
2258      $wrapperEl.prepend($(prependSlides[i$2].cloneNode(true)).addClass(params.slideDuplicateClass));
2259    }
2260  }
2261
2262  function loopFix () {
2263    var swiper = this;
2264    var params = swiper.params;
2265    var activeIndex = swiper.activeIndex;
2266    var slides = swiper.slides;
2267    var loopedSlides = swiper.loopedSlides;
2268    var allowSlidePrev = swiper.allowSlidePrev;
2269    var allowSlideNext = swiper.allowSlideNext;
2270    var snapGrid = swiper.snapGrid;
2271    var rtl = swiper.rtlTranslate;
2272    var newIndex;
2273    swiper.allowSlidePrev = true;
2274    swiper.allowSlideNext = true;
2275
2276    var snapTranslate = -snapGrid[activeIndex];
2277    var diff = snapTranslate - swiper.getTranslate();
2278
2279
2280    // Fix For Negative Oversliding
2281    if (activeIndex < loopedSlides) {
2282      newIndex = (slides.length - (loopedSlides * 3)) + activeIndex;
2283      newIndex += loopedSlides;
2284      var slideChanged = swiper.slideTo(newIndex, 0, false, true);
2285      if (slideChanged && diff !== 0) {
2286        swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
2287      }
2288    } else if ((params.slidesPerView === 'auto' && activeIndex >= loopedSlides * 2) || (activeIndex >= slides.length - loopedSlides)) {
2289      // Fix For Positive Oversliding
2290      newIndex = -slides.length + activeIndex + loopedSlides;
2291      newIndex += loopedSlides;
2292      var slideChanged$1 = swiper.slideTo(newIndex, 0, false, true);
2293      if (slideChanged$1 && diff !== 0) {
2294        swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
2295      }
2296    }
2297    swiper.allowSlidePrev = allowSlidePrev;
2298    swiper.allowSlideNext = allowSlideNext;
2299  }
2300
2301  function loopDestroy () {
2302    var swiper = this;
2303    var $wrapperEl = swiper.$wrapperEl;
2304    var params = swiper.params;
2305    var slides = swiper.slides;
2306    $wrapperEl.children(("." + (params.slideClass) + "." + (params.slideDuplicateClass))).remove();
2307    slides.removeAttr('data-swiper-slide-index');
2308  }
2309
2310  var loop = {
2311    loopCreate: loopCreate,
2312    loopFix: loopFix,
2313    loopDestroy: loopDestroy,
2314  };
2315
2316  function setGrabCursor (moving) {
2317    var swiper = this;
2318    if (Support.touch || !swiper.params.simulateTouch || (swiper.params.watchOverflow && swiper.isLocked)) { return; }
2319    var el = swiper.el;
2320    el.style.cursor = 'move';
2321    el.style.cursor = moving ? '-webkit-grabbing' : '-webkit-grab';
2322    el.style.cursor = moving ? '-moz-grabbin' : '-moz-grab';
2323    el.style.cursor = moving ? 'grabbing' : 'grab';
2324  }
2325
2326  function unsetGrabCursor () {
2327    var swiper = this;
2328    if (Support.touch || (swiper.params.watchOverflow && swiper.isLocked)) { return; }
2329    swiper.el.style.cursor = '';
2330  }
2331
2332  var grabCursor = {
2333    setGrabCursor: setGrabCursor,
2334    unsetGrabCursor: unsetGrabCursor,
2335  };
2336
2337  function appendSlide (slides) {
2338    var swiper = this;
2339    var $wrapperEl = swiper.$wrapperEl;
2340    var params = swiper.params;
2341    if (params.loop) {
2342      swiper.loopDestroy();
2343    }
2344    if (typeof slides === 'object' && 'length' in slides) {
2345      for (var i = 0; i < slides.length; i += 1) {
2346        if (slides[i]) { $wrapperEl.append(slides[i]); }
2347      }
2348    } else {
2349      $wrapperEl.append(slides);
2350    }
2351    if (params.loop) {
2352      swiper.loopCreate();
2353    }
2354    if (!(params.observer && Support.observer)) {
2355      swiper.update();
2356    }
2357  }
2358
2359  function prependSlide (slides) {
2360    var swiper = this;
2361    var params = swiper.params;
2362    var $wrapperEl = swiper.$wrapperEl;
2363    var activeIndex = swiper.activeIndex;
2364
2365    if (params.loop) {
2366      swiper.loopDestroy();
2367    }
2368    var newActiveIndex = activeIndex + 1;
2369    if (typeof slides === 'object' && 'length' in slides) {
2370      for (var i = 0; i < slides.length; i += 1) {
2371        if (slides[i]) { $wrapperEl.prepend(slides[i]); }
2372      }
2373      newActiveIndex = activeIndex + slides.length;
2374    } else {
2375      $wrapperEl.prepend(slides);
2376    }
2377    if (params.loop) {
2378      swiper.loopCreate();
2379    }
2380    if (!(params.observer && Support.observer)) {
2381      swiper.update();
2382    }
2383    swiper.slideTo(newActiveIndex, 0, false);
2384  }
2385
2386  function addSlide (index, slides) {
2387    var swiper = this;
2388    var $wrapperEl = swiper.$wrapperEl;
2389    var params = swiper.params;
2390    var activeIndex = swiper.activeIndex;
2391    var activeIndexBuffer = activeIndex;
2392    if (params.loop) {
2393      activeIndexBuffer -= swiper.loopedSlides;
2394      swiper.loopDestroy();
2395      swiper.slides = $wrapperEl.children(("." + (params.slideClass)));
2396    }
2397    var baseLength = swiper.slides.length;
2398    if (index <= 0) {
2399      swiper.prependSlide(slides);
2400      return;
2401    }
2402    if (index >= baseLength) {
2403      swiper.appendSlide(slides);
2404      return;
2405    }
2406    var newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + 1 : activeIndexBuffer;
2407
2408    var slidesBuffer = [];
2409    for (var i = baseLength - 1; i >= index; i -= 1) {
2410      var currentSlide = swiper.slides.eq(i);
2411      currentSlide.remove();
2412      slidesBuffer.unshift(currentSlide);
2413    }
2414
2415    if (typeof slides === 'object' && 'length' in slides) {
2416      for (var i$1 = 0; i$1 < slides.length; i$1 += 1) {
2417        if (slides[i$1]) { $wrapperEl.append(slides[i$1]); }
2418      }
2419      newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + slides.length : activeIndexBuffer;
2420    } else {
2421      $wrapperEl.append(slides);
2422    }
2423
2424    for (var i$2 = 0; i$2 < slidesBuffer.length; i$2 += 1) {
2425      $wrapperEl.append(slidesBuffer[i$2]);
2426    }
2427
2428    if (params.loop) {
2429      swiper.loopCreate();
2430    }
2431    if (!(params.observer && Support.observer)) {
2432      swiper.update();
2433    }
2434    if (params.loop) {
2435      swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
2436    } else {
2437      swiper.slideTo(newActiveIndex, 0, false);
2438    }
2439  }
2440
2441  function removeSlide (slidesIndexes) {
2442    var swiper = this;
2443    var params = swiper.params;
2444    var $wrapperEl = swiper.$wrapperEl;
2445    var activeIndex = swiper.activeIndex;
2446
2447    var activeIndexBuffer = activeIndex;
2448    if (params.loop) {
2449      activeIndexBuffer -= swiper.loopedSlides;
2450      swiper.loopDestroy();
2451      swiper.slides = $wrapperEl.children(("." + (params.slideClass)));
2452    }
2453    var newActiveIndex = activeIndexBuffer;
2454    var indexToRemove;
2455
2456    if (typeof slidesIndexes === 'object' && 'length' in slidesIndexes) {
2457      for (var i = 0; i < slidesIndexes.length; i += 1) {
2458        indexToRemove = slidesIndexes[i];
2459        if (swiper.slides[indexToRemove]) { swiper.slides.eq(indexToRemove).remove(); }
2460        if (indexToRemove < newActiveIndex) { newActiveIndex -= 1; }
2461      }
2462      newActiveIndex = Math.max(newActiveIndex, 0);
2463    } else {
2464      indexToRemove = slidesIndexes;
2465      if (swiper.slides[indexToRemove]) { swiper.slides.eq(indexToRemove).remove(); }
2466      if (indexToRemove < newActiveIndex) { newActiveIndex -= 1; }
2467      newActiveIndex = Math.max(newActiveIndex, 0);
2468    }
2469
2470    if (params.loop) {
2471      swiper.loopCreate();
2472    }
2473
2474    if (!(params.observer && Support.observer)) {
2475      swiper.update();
2476    }
2477    if (params.loop) {
2478      swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
2479    } else {
2480      swiper.slideTo(newActiveIndex, 0, false);
2481    }
2482  }
2483
2484  function removeAllSlides () {
2485    var swiper = this;
2486
2487    var slidesIndexes = [];
2488    for (var i = 0; i < swiper.slides.length; i += 1) {
2489      slidesIndexes.push(i);
2490    }
2491    swiper.removeSlide(slidesIndexes);
2492  }
2493
2494  var manipulation = {
2495    appendSlide: appendSlide,
2496    prependSlide: prependSlide,
2497    addSlide: addSlide,
2498    removeSlide: removeSlide,
2499    removeAllSlides: removeAllSlides,
2500  };
2501
2502  var Device = (function Device() {
2503    var ua = win.navigator.userAgent;
2504
2505    var device = {
2506      ios: false,
2507      android: false,
2508      androidChrome: false,
2509      desktop: false,
2510      windows: false,
2511      iphone: false,
2512      ipod: false,
2513      ipad: false,
2514      cordova: win.cordova || win.phonegap,
2515      phonegap: win.cordova || win.phonegap,
2516    };
2517
2518    var windows = ua.match(/(Windows Phone);?[\s\/]+([\d.]+)?/); // eslint-disable-line
2519    var android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
2520    var ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
2521    var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
2522    var iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
2523
2524
2525    // Windows
2526    if (windows) {
2527      device.os = 'windows';
2528      device.osVersion = windows[2];
2529      device.windows = true;
2530    }
2531    // Android
2532    if (android && !windows) {
2533      device.os = 'android';
2534      device.osVersion = android[2];
2535      device.android = true;
2536      device.androidChrome = ua.toLowerCase().indexOf('chrome') >= 0;
2537    }
2538    if (ipad || iphone || ipod) {
2539      device.os = 'ios';
2540      device.ios = true;
2541    }
2542    // iOS
2543    if (iphone && !ipod) {
2544      device.osVersion = iphone[2].replace(/_/g, '.');
2545      device.iphone = true;
2546    }
2547    if (ipad) {
2548      device.osVersion = ipad[2].replace(/_/g, '.');
2549      device.ipad = true;
2550    }
2551    if (ipod) {
2552      device.osVersion = ipod[3] ? ipod[3].replace(/_/g, '.') : null;
2553      device.iphone = true;
2554    }
2555    // iOS 8+ changed UA
2556    if (device.ios && device.osVersion && ua.indexOf('Version/') >= 0) {
2557      if (device.osVersion.split('.')[0] === '10') {
2558        device.osVersion = ua.toLowerCase().split('version/')[1].split(' ')[0];
2559      }
2560    }
2561
2562    // Desktop
2563    device.desktop = !(device.os || device.android || device.webView);
2564
2565    // Webview
2566    device.webView = (iphone || ipad || ipod) && ua.match(/.*AppleWebKit(?!.*Safari)/i);
2567
2568    // Minimal UI
2569    if (device.os && device.os === 'ios') {
2570      var osVersionArr = device.osVersion.split('.');
2571      var metaViewport = doc.querySelector('meta[name="viewport"]');
2572      device.minimalUi = !device.webView
2573        && (ipod || iphone)
2574        && (osVersionArr[0] * 1 === 7 ? osVersionArr[1] * 1 >= 1 : osVersionArr[0] * 1 > 7)
2575        && metaViewport && metaViewport.getAttribute('content').indexOf('minimal-ui') >= 0;
2576    }
2577
2578    // Pixel Ratio
2579    device.pixelRatio = win.devicePixelRatio || 1;
2580
2581    // Export object
2582    return device;
2583  }());
2584
2585  function onTouchStart (event) {
2586    var swiper = this;
2587    var data = swiper.touchEventsData;
2588    var params = swiper.params;
2589    var touches = swiper.touches;
2590    if (swiper.animating && params.preventInteractionOnTransition) {
2591      return;
2592    }
2593    var e = event;
2594    if (e.originalEvent) { e = e.originalEvent; }
2595    data.isTouchEvent = e.type === 'touchstart';
2596    if (!data.isTouchEvent && 'which' in e && e.which === 3) { return; }
2597    if (!data.isTouchEvent && 'button' in e && e.button > 0) { return; }
2598    if (data.isTouched && data.isMoved) { return; }
2599    if (params.noSwiping && $(e.target).closest(params.noSwipingSelector ? params.noSwipingSelector : ("." + (params.noSwipingClass)))[0]) {
2600      swiper.allowClick = true;
2601      return;
2602    }
2603    if (params.swipeHandler) {
2604      if (!$(e).closest(params.swipeHandler)[0]) { return; }
2605    }
2606
2607    touches.currentX = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
2608    touches.currentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
2609    var startX = touches.currentX;
2610    var startY = touches.currentY;
2611
2612    // Do NOT start if iOS edge swipe is detected. Otherwise iOS app (UIWebView) cannot swipe-to-go-back anymore
2613
2614    var edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
2615    var edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
2616    if (
2617      edgeSwipeDetection
2618      && ((startX <= edgeSwipeThreshold)
2619      || (startX >= win.screen.width - edgeSwipeThreshold))
2620    ) {
2621      return;
2622    }
2623
2624    Utils.extend(data, {
2625      isTouched: true,
2626      isMoved: false,
2627      allowTouchCallbacks: true,
2628      isScrolling: undefined,
2629      startMoving: undefined,
2630    });
2631
2632    touches.startX = startX;
2633    touches.startY = startY;
2634    data.touchStartTime = Utils.now();
2635    swiper.allowClick = true;
2636    swiper.updateSize();
2637    swiper.swipeDirection = undefined;
2638    if (params.threshold > 0) { data.allowThresholdMove = false; }
2639    if (e.type !== 'touchstart') {
2640      var preventDefault = true;
2641      if ($(e.target).is(data.formElements)) { preventDefault = false; }
2642      if (
2643        doc.activeElement
2644        && $(doc.activeElement).is(data.formElements)
2645        && doc.activeElement !== e.target
2646      ) {
2647        doc.activeElement.blur();
2648      }
2649
2650      var shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
2651      if (params.touchStartForcePreventDefault || shouldPreventDefault) {
2652        e.preventDefault();
2653      }
2654    }
2655    swiper.emit('touchStart', e);
2656  }
2657
2658  function onTouchMove (event) {
2659    var swiper = this;
2660    var data = swiper.touchEventsData;
2661    var params = swiper.params;
2662    var touches = swiper.touches;
2663    var rtl = swiper.rtlTranslate;
2664    var e = event;
2665    if (e.originalEvent) { e = e.originalEvent; }
2666    if (!data.isTouched) {
2667      if (data.startMoving && data.isScrolling) {
2668        swiper.emit('touchMoveOpposite', e);
2669      }
2670      return;
2671    }
2672    if (data.isTouchEvent && e.type === 'mousemove') { return; }
2673    var