https://buergerbuehne.de/wp-content/plugins/colibri-page-builder-p…/static/swiper/js/swiper.js?ver=1.0.430-pro

1/**
2 * Swiper
3 * Most modern mobile touch slider and framework with hardware accelerated transitions
4 * http://www.idangero.us/swiper/
5 *
6 * Copyright Vladimir Kharlampidi
7 *
8 * Released under the MIT License
9 *
10 */
11
12(function (global, factory) {
13  typeof exports === 'object' && typeof module !== 'undefined'
14    ? (module.exports = factory())
15    : typeof define === 'function' && define.amd
16      ? define(factory)
17      : (global.Swiper = factory());
18})(this, function () {
19  'use strict';
20
21
22  var doc =
23    typeof document === 'undefined'
24      ? {
25        body: {},
26        addEventListener: function addEventListener() {},
27        removeEventListener: function removeEventListener() {},
28        activeElement: {
29          blur: function blur() {},
30          nodeName: '',
31        },
32        querySelector: function querySelector() {
33          return null;
34        },
35        querySelectorAll: function querySelectorAll() {
36          return [];
37        },
38        getElementById: function getElementById() {
39          return null;
40        },
41        createEvent: function createEvent() {
42          return {
43            initEvent: function initEvent() {},
44          };
45        },
46        createElement: function createElement() {
47          return {
48            children: [],
49            childNodes: [],
50            style: {},
51            setAttribute: function setAttribute() {},
52            getElementsByTagName: function getElementsByTagName() {
53              return [];
54            },
55          };
56        },
57        location: { hash: '' },
58      }
59      : document; // eslint-disable-line
60
61  var win =
62    typeof window === 'undefined'
63      ? {
64        document: doc,
65        navigator: {
66          userAgent: '',
67        },
68        location: {},
69        history: {},
70        CustomEvent: function CustomEvent() {
71          return this;
72        },
73        addEventListener: function addEventListener() {},
74        removeEventListener: function removeEventListener() {},
75        getComputedStyle: function getComputedStyle() {
76          return {
77            getPropertyValue: function getPropertyValue() {
78              return '';
79            },
80          };
81        },
82        Image: function Image() {},
83        Date: function Date() {},
84        screen: {},
85        setTimeout: function setTimeout() {},
86        clearTimeout: function clearTimeout() {},
87      }
88      : window; // eslint-disable-line
89
90
91  var Dom7 = function Dom7(arr) {
92    var self = this;
93    // Create array-like object
94    for (var i = 0; i < arr.length; i += 1) {
95      self[i] = arr[i];
96    }
97    self.length = arr.length;
98    // Return collection with methods
99    return this;
100  };
101
102  function $(selector, context) {
103    var arr = [];
104    var i = 0;
105    if (selector && !context) {
106      if (selector instanceof Dom7) {
107        return selector;
108      }
109    }
110    if (selector) {
111      // String
112      if (typeof selector === 'string') {
113        var els;
114        var tempParent;
115        var html = selector.trim();
116        if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {
117          var toCreate = 'div';
118          if (html.indexOf('<li') === 0) {
119            toCreate = 'ul';
120          }
121          if (html.indexOf('<tr') === 0) {
122            toCreate = 'tbody';
123          }
124          if (
125            html.indexOf('<td') === 0 ||
126            html.indexOf('<th') === 0
127          ) {
128            toCreate = 'tr';
129          }
130          if (html.indexOf('<tbody') === 0) {
131            toCreate = 'table';
132          }
133          if (html.indexOf('<option') === 0) {
134            toCreate = 'select';
135          }
136          tempParent = doc.createElement(toCreate);
137          tempParent.innerHTML = html;
138          for (i = 0; i < tempParent.childNodes.length; i += 1) {
139            arr.push(tempParent.childNodes[i]);
140          }
141        } else {
142          if (
143            !context &&
144            selector[0] === '#' &&
145            !selector.match(/[ .<>:~]/)
146          ) {
147            // Pure ID selector
148            els = [
149              doc.getElementById(selector.trim().split('#')[1]),
150            ];
151          } else {
152            // Other selectors
153            els = (context || doc).querySelectorAll(
154              selector.trim()
155            );
156          }
157          for (i = 0; i < els.length; i += 1) {
158            if (els[i]) {
159              arr.push(els[i]);
160            }
161          }
162        }
163      } else if (
164        selector.nodeType ||
165        selector === win ||
166        selector === doc
167      ) {
168        // Node/element
169        arr.push(selector);
170      } else if (selector.length > 0 && selector[0].nodeType) {
171        // Array of elements or instance of Dom
172        for (i = 0; i < selector.length; i += 1) {
173          arr.push(selector[i]);
174        }
175      }
176    }
177    return new Dom7(arr);
178  }
179
180  $.fn = Dom7.prototype;
181  $.Class = Dom7;
182  $.Dom7 = Dom7;
183
184  function unique(arr) {
185    var uniqueArray = [];
186    for (var i = 0; i < arr.length; i += 1) {

369    }
370
371    function handleLiveEvent(e) {
372      var target = e.target;
373      if (!target) {
374        return;
375      }
376      var eventData = e.target.dom7EventData || [];
377      if (eventData.indexOf(e) < 0) {
378        eventData.unshift(e);
379      }
380      if ($(target).is(targetSelector)) {
381        listener.apply(target, eventData);
382      } else {
383        var parents = $(target).parents(); // eslint-disable-line
384        for (var k = 0; k < parents.length; k += 1) {
385          if ($(parents[k]).is(targetSelector)) {
386            listener.apply(parents[k], eventData);
387          }
388        }
389      }
390    }
391    function handleEvent(e) {
392      var eventData = e && e.target ? e.target.dom7EventData || [] : [];
393      if (eventData.indexOf(e) < 0) {
394        eventData.unshift(e);
395      }
396      listener.apply(this, eventData);
397    }
398    var events = eventType.split(' ');
399    var j;
400    for (var i = 0; i < this.length; i += 1) {
401      var el = this$1[i];
402      if (!targetSelector) {
403        for (j = 0; j < events.length; j += 1) {
404          var event = events[j];
405          if (!el.dom7Listeners) {
406            el.dom7Listeners = {};
407          }
408          if (!el.dom7Listeners[event]) {
409            el.dom7Listeners[event] = [];
410          }
411          el.dom7Listeners[event].push({
412            listener: listener,
413            proxyListener: handleEvent,
414          });
415          el.addEventListener(event, handleEvent, capture);
416        }
417      } else {
418        // Live events
419        for (j = 0; j < events.length; j += 1) {
420          var event$1 = events[j];
421          if (!el.dom7LiveListeners) {
422            el.dom7LiveListeners = {};
423          }
424          if (!el.dom7LiveListeners[event$1]) {
425            el.dom7LiveListeners[event$1] = [];
426          }
427          el.dom7LiveListeners[event$1].push({
428            listener: listener,
429            proxyListener: handleLiveEvent,
430          });
431          el.addEventListener(event$1, handleLiveEvent, capture);
432        }
433      }
434    }
435    return this;
436  }
437  function off() {
438    var this$1 = this;
439    var assign;
440
441    var args = [],
442      len = arguments.length;
443    while (len--) args[len] = arguments[len];
444    var eventType = args[0];
445    var targetSelector = args[1];
446    var listener = args[2];
447    var capture = args[3];
448    if (typeof args[1] === 'function') {
449      (assign = args),
450        (eventType = assign[0]),
451        (listener = assign[1]),
452        (capture = assign[2]);
453      targetSelector = undefined;
454    }
455    if (!capture) {
456      capture = false;
457    }
458
459    var events = eventType.split(' ');
460    for (var i = 0; i < events.length; i += 1) {
461      var event = events[i];
462      for (var j = 0; j < this.length; j += 1) {
463        var el = this$1[j];
464        var handlers = void 0;
465        if (!targetSelector && el.dom7Listeners) {
466          handlers = el.dom7Listeners[event];
467        } else if (targetSelector && el.dom7LiveListeners) {
468          handlers = el.dom7LiveListeners[event];
469        }
470        if (handlers && handlers.length) {
471          for (var k = handlers.length - 1; k >= 0; k -= 1) {
472            var handler = handlers[k];
473            if (listener && handler.listener === listener) {
474              el.removeEventListener(
475                event,
476                handler.proxyListener,
477                capture
478              );
479              handlers.splice(k, 1);
480            } else if (!listener) {
481              el.removeEventListener(
482                event,
483                handler.proxyListener,
484                capture
485              );
486              handlers.splice(k, 1);
487            }
488          }
489        }
490      }
491    }
492    return this;
493  }
494  function trigger() {
495    var this$1 = this;
496    var args = [],
497      len = arguments.length;
498    while (len--) args[len] = arguments[len];
499
500    var events = args[0].split(' ');
501    var eventData = args[1];
502    for (var i = 0; i < events.length; i += 1) {
503      var event = events[i];
504      for (var j = 0; j < this.length; j += 1) {
505        var el = this$1[j];
506        var evt = void 0;
507        try {
508          evt = new win.CustomEvent(event, {
509            detail: eventData,
510            bubbles: true,
511            cancelable: true,
512          });
513        } catch (e) {
514          evt = doc.createEvent('Event');
515          evt.initEvent(event, true, true);
516          evt.detail = eventData;
517        }
518        // eslint-disable-next-line
519        el.dom7EventData = args.filter(function (data, dataIndex) {
520          return dataIndex > 0;
521        });
522        el.dispatchEvent(evt);
523        el.dom7EventData = [];
524        delete el.dom7EventData;
525      }
526    }
527    return this;
528  }
529  function transitionEnd(callback) {

692 else if (el.msMatchesSelector) {
693        return el.msMatchesSelector(selector);
694      }
695
696      compareWith = $(selector);
697      for (i = 0; i < compareWith.length; i += 1) {
698        if (compareWith[i] === el) {
699          return true;
700        }
701      }
702      return false;
703    } else if (selector === doc) {
704      return el === doc;
705    } else if (selector === win) {
706      return el === win;
707    }
708
709    if (selector.nodeType || selector instanceof Dom7) {
710      compareWith = selector.nodeType ? [selector] : selector;
711      for (i = 0; i < compareWith.length; i += 1) {
712        if (compareWith[i] === el) {
713          return true;
714        }
715      }
716      return false;
717    }
718    return false;
719  }
720  function index() {
721    var child = this[0];
722    var i;
723    if (child) {
724      i = 0;
725      // eslint-disable-next-line
726      while ((child = child.previousSibling) !== null) {
727        if (child.nodeType === 1) {
728          i += 1;
729        }
730      }
731      return i;
732    }
733    return undefined;
734  }
735  // eslint-disable-next-line
736  function eq(index) {
737    if (typeof index === 'undefined') {
738      return this;
739    }
740    var length = this.length;
741    var returnIndex;
742    if (index > length - 1) {
743      return new Dom7([]);
744    }
745    if (index < 0) {
746      returnIndex = length + index;
747      if (returnIndex < 0) {
748        return new Dom7([]);
749      }
750      return new Dom7([this[returnIndex]]);
751    }
752    return new Dom7([this[index]]);
753  }
754  function append() {
755    var this$1 = this;
756    var args = [],
757      len = arguments.length;
758    while (len--) args[len] = arguments[len];
759
760    var newChild;
761
762    for (var k = 0; k < args.length; k += 1) {
763      newChild = args[k];
764      for (var i = 0; i < this.length; i += 1) {
765        if (typeof newChild === 'string') {
766          var tempDiv = doc.createElement('div');
767          tempDiv.innerHTML = newChild;
768          while (tempDiv.firstChild) {
769            this$1[i].appendChild(tempDiv.firstChild);
770          }
771        } else if (newChild instanceof Dom7) {
772          for (var j = 0; j < newChild.length; j += 1) {
773            this$1[i].appendChild(newChild[j]);
774          }
775        } else {
776          this$1[i].appendChild(newChild);
777        }
778      }
779    }
780
781    return this;
782  }
783  function prepend(newChild) {
784    var this$1 = this;
785
786    var i;
787    var j;
788    for (i = 0; i < this.length; i += 1) {
789      if (typeof newChild === 'string') {
790        var tempDiv = doc.createElement('div');
791        tempDiv.innerHTML = newChild;
792        for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
793          this$1[i].insertBefore(
794            tempDiv.childNodes[j],
795            this$1[i].childNodes[0]
796          );
797        }
798      } else if (newChild instanceof Dom7) {
799        for (j = 0; j < newChild.length; j += 1) {
800          this$1[i].insertBefore(
801            newChild[j],
802            this$1[i].childNodes[0]
803          );
804        }
805      } else {
806        this$1[i].insertBefore(newChild, this$1[i].childNodes[0]);
807      }
808    }
809    return this;
810  }
811  function next(selector) {
812    if (this.length > 0) {
813      if (selector) {
814        if (
815          this[0].nextElementSibling &&
816          $(this[0].nextElementSibling).is(selector)
817        ) {
818          return new Dom7([this[0].nextElementSibling]);
819        }
820        return new Dom7([]);
821      }
822
823      if (this[0].nextElementSibling) {
824        return new Dom7([this[0].nextElementSibling]);
825      }
826      return new Dom7([]);
827    }
828    return new Dom7([]);
829  }
830  function nextAll(selector) {
831    var nextEls = [];
832    var el = this[0];
833    if (!el) {
834      return new Dom7([]);
835    }
836    while (el.nextElementSibling) {
837      var next = el.nextElementSibling; // eslint-disable-line
838      if (selector) {
839        if ($(next).is(selector)) {
840          nextEls.push(next);
841        }
842      } else {
843        nextEls.push(next);
844      }
845      el = next;
846    }
847    return new Dom7(nextEls);
848  }
849  function prev(selector) {
850    if (this.length > 0) {
851      var el = this[0];
852      if (selector) {
853        if (
854          el.previousElementSibling &&
855          $(el.previousElementSibling).is(selector)
856        ) {
857          return new Dom7([el.previousElementSibling]);
858        }
859        return new Dom7([]);
860      }
861
862      if (el.previousElementSibling) {
863        return new Dom7([el.previousElementSibling]);
864      }
865      return new Dom7([]);
866    }
867    return new Dom7([]);
868  }
869  function prevAll(selector) {
870    var prevEls = [];
871    var el = this[0];
872    if (!el) {
873      return new Dom7([]);
874    }
875    while (el.previousElementSibling) {
876      var prev = el.previousElementSibling; // eslint-disable-line
877      if (selector) {
878        if ($(prev).is(selector)) {
879          prevEls.push(prev);
880        }
881      } else {
882        prevEls.push(prev);
883      }
884      el = prev;
885    }
886    return new Dom7(prevEls);
887  }
888  function parent(selector) {
889    var this$1 = this;
890
891    var parents = []; // eslint-disable-line
892    for (var i = 0; i < this.length; i += 1) {
893      if (this$1[i].parentNode !== null) {
894        if (selector) {
895          if ($(this$1[i].parentNode).is(selector)) {
896            parents.push(this$1[i].parentNode);
897          }
898        } else {
899          parents.push(this$1[i].parentNode);
900        }
901      }
902    }
903    return $(unique(parents));
904  }
905  function parents(selector) {
906    var this$1 = this;
907
908    var parents = []; // eslint-disable-line
909    for (var i = 0; i < this.length; i += 1) {
910      var parent = this$1[i].parentNode; // eslint-disable-line
911      while (parent) {
912        if (selector) {
913          if ($(parent).is(selector)) {
914            parents.push(parent);
915          }
916        } else {
917          parents.push(parent);
918        }
919        parent = parent.parentNode;
920      }
921    }
922    return $(unique(parents));
923  }
924  function closest(selector) {
925    var closest = this; // eslint-disable-line
926    if (typeof selector === 'undefined') {
927      return new Dom7([]);
928    }
929    if (!closest.is(selector)) {
930      closest = closest.parents(selector).eq(0);
931    }
932    return closest;
933  }
934  function find(selector) {
935    var this$1 = this;
936
937    var foundElements = [];
938    for (var i = 0; i < this.length; i += 1) {
939      var found = this$1[i].querySelectorAll(selector);
940      for (var j = 0; j < found.length; j += 1) {
941        foundElements.push(found[j]);
942      }
943    }
944    return new Dom7(foundElements);
945  }
946  function children(selector) {
947    var this$1 = this;
948
949    var children = []; // eslint-disable-line
950    for (var i = 0; i < this.length; i += 1) {
951      var childNodes = this$1[i].childNodes;
952
953      for (var j = 0; j < childNodes.length; j += 1) {
954        if (!selector) {
955          if (childNodes[j].nodeType === 1) {
956            children.push(childNodes[j]);
957          }
958        } else if (
959          childNodes[j].nodeType === 1 &&
960          $(childNodes[j]).is(selector)
961        ) {
962          children.push(childNodes[j]);
963        }
964      }
965    }
966    return new Dom7(unique(children));
967  }
968  function remove() {
969    var this$1 = this;
970
971    for (var i = 0; i < this.length; i += 1) {
972      if (this$1[i].parentNode) {
973        this$1[i].parentNode.removeChild(this$1[i]);
974      }
975    }
976    return this;
977  }
978  function add() {
979    var args = [],
980      len = arguments.length;
981    while (len--) args[len] = arguments[len];
982
983    var dom = this;
984    var i;
985    var j;
986    for (i = 0; i < args.length; i += 1) {
987      var toAdd = $(args[i]);
988      for (j = 0; j < toAdd.length; j += 1) {
989        dom[dom.length] = toAdd[j];
990        dom.length += 1;
991      }
992    }
993    return dom;
994  }
995
996  var Methods = {
997    addClass: addClass,
998    removeClass: removeClass,
999    hasClass: hasClass,
1000    toggleClass: toggleClass,
1001    attr: attr,
1002    removeAttr: removeAttr,
1003    data: data,
1004    transform: transform,
1005    transition: transition,
1006    on: on,
1007    off: off,
1008    trigger: trigger,
1009    transitionEnd: transitionEnd,
1010    outerWidth: outerWidth,
1011    outerHeight: outerHeight,
1012    offset: offset,
1013    css: css,
1014    each: each,
1015    html: html,
1016    text: text,
1017    is: is,
1018    index: index,
1019    eq: eq,
1020    append: append,
1021    prepend: prepend,
1022    next: next,
1023    nextAll: nextAll,
1024    prev: prev,
1025    prevAll: prevAll,
1026    parent: parent,
1027    parents: parents,
1028    closest: closest,
1029    find: find,
1030    children: children,
1031    remove: remove,
1032    add: add,
1033    styles: styles,
1034  };
1035
1036  Object.keys(Methods).forEach(function (methodName) {
1037    $.fn[methodName] = Methods[methodName];
1038  });
1039
1040  var Utils = {
1041    deleteProps: function deleteProps(obj) {
1042      var object = obj;
1043      Object.keys(object).forEach(function (key) {
1044        try {
1045          object[key] = null;
1046        } catch (e) {
1047          // no getter for object
1048        }
1049        try {
1050          delete object[key];
1051        } catch (e) {
1052          // something got wrong
1053        }
1054      });
1055    },
1056    nextTick: function nextTick(callback, delay) {
1057      if (delay === void 0) delay = 0;
1058
1059      return setTimeout(callback, delay);
1060    },
1061    now: function now() {
1062      return Date.now();
1063    },
1064    getTranslate: function getTranslate(el, axis) {
1065      if (axis === void 0) axis = 'x';
1066
1067      var matrix;
1068      var curTransform;
1069      var transformMatrix;
1070
1071      var curStyle = win.getComputedStyle(el, null);
1072
1073      if (win.WebKitCSSMatrix) {
1074        curTransform = curStyle.transform || curStyle.webkitTransform;
1075        if (curTransform.split(',').length > 6) {
1076          curTransform = curTransform
1077            .split(', ')
1078            .map(function (a) {
1079              return a.replace(',', '.');
1080            })
1081            .join(', ');
1082        }
1083        // Some old versions of Webkit choke when 'none' is passed; pass
1084        // empty string instead in this case
1085        transformMatrix = new win.WebKitCSSMatrix(
1086          curTransform === 'none' ? '' : curTransform
1087        );
1088      } else {
1089        transformMatrix =
1090          curStyle.MozTransform ||
1091          curStyle.OTransform ||
1092          curStyle.MsTransform ||
1093          curStyle.msTransform ||
1094          curStyle.transform ||
1095          curStyle
1096            .getPropertyValue('transform')
1097            .replace('translate(', 'matrix(1, 0, 0, 1,');
1098        matrix = transformMatrix.toString().split(',');
1099      }
1100
1101      if (axis === 'x') {
1102        // Latest Chrome and webkits Fix
1103        if (win.WebKitCSSMatrix) {
1104          curTransform = transformMatrix.m41;
1105        }
1106        // Crazy IE10 Matrix
1107        else if (matrix.length === 16) {
1108          curTransform = parseFloat(matrix[12]);
1109        }
1110        // Normal Browsers
1111        else {
1112          curTransform = parseFloat(matrix[4]);
1113        }
1114      }
1115      if (axis === 'y') {
1116        // Latest Chrome and webkits Fix
1117        if (win.WebKitCSSMatrix) {
1118          curTransform = transformMatrix.m42;
1119        }
1120        // Crazy IE10 Matrix
1121        else if (matrix.length === 16) {
1122          curTransform = parseFloat(matrix[13]);
1123        }
1124        // Normal Browsers
1125        else {
1126          curTransform = parseFloat(matrix[5]);
1127        }
1128      }
1129      return curTransform || 0;
1130    },
1131    parseUrlQuery: function parseUrlQuery(url) {
1132      var query = {};
1133      var urlToParse = url || win.location.href;
1134      var i;
1135      var params;
1136      var param;
1137      var length;
1138      if (typeof urlToParse === 'string' && urlToParse.length) {
1139        urlToParse =
1140          urlToParse.indexOf('?') > -1
1141            ? urlToParse.replace(/\S*\?/, '')
1142            : '';
1143        params = urlToParse.split('&').filter(function (paramsPart) {
1144          return paramsPart !== '';
1145        });
1146        length = params.length;
1147
1148        for (i = 0; i < length; i += 1) {
1149          param = params[i].replace(/#\S+/g, '').split('=');
1150          query[decodeURIComponent(param[0])] =
1151            typeof param[1] === 'undefined'
1152              ? undefined
1153              : decodeURIComponent(param[1]) || '';
1154        }
1155      }
1156      return query;
1157    },
1158    isObject: function isObject(o) {
1159      return (
1160        typeof o === 'object' &&
1161        o !== null &&
1162        o.constructor &&
1163        o.constructor === Object
1164      );
1165    },
1166    extend: function extend() {
1167      var args = [],
1168        len$1 = arguments.length;
1169      while (len$1--) args[len$1] = arguments[len$1];
1170
1171      var to = Object(args[0]);
1172      for (var i = 1; i < args.length; i += 1) {
1173        var nextSource = args[i];
1174        if (nextSource !== undefined && nextSource !== null) {
1175          var keysArray = Object.keys(Object(nextSource));
1176          for (
1177            var nextIndex = 0, len = keysArray.length;
1178            nextIndex < len;
1179            nextIndex += 1
1180          ) {
1181            var nextKey = keysArray[nextIndex];
1182            // Prototype pollution guard. Direct string comparisons
1183            // (not indexOf) so a poisoned Array.prototype.indexOf
1184            // cannot bypass the check — that was the 12.1.2 bypass.
1185            if (
1186              nextKey === '__proto__' ||
1187              nextKey === 'constructor' ||
1188              nextKey === 'prototype'
1189            ) {
1190              continue;
1191            }
1192            var desc = Object.getOwnPropertyDescriptor(
1193              nextSource,
1194              nextKey
1195            );
1196            if (desc !== undefined && desc.enumerable) {
1197              if (
1198                Utils.isObject(to[nextKey]) &&
1199                Utils.isObject(nextSource[nextKey])
1200              ) {
1201                Utils.extend(to[nextKey], nextSource[nextKey]);
1202              } else if (
1203                !Utils.isObject(to[nextKey]) &&
1204                Utils.isObject(nextSource[nextKey])
1205              ) {
1206                to[nextKey] = {};
1207                Utils.extend(to[nextKey], nextSource[nextKey]);
1208              } else {
1209                to[nextKey] = nextSource[nextKey];
1210              }
1211            }
1212          }
1213        }
1214      }
1215      return to;
1216    },
1217  };
1218
1219  var Support = (function Support() {
1220    var testDiv = doc.createElement('div');
1221    return {
1222      touch:
1223        (win.Modernizr && win.Modernizr.touch === true) ||
1224        (function checkTouch() {
1225          return !!(
1226            'ontouchstart' in win ||
1227            (win.DocumentTouch && doc instanceof win.DocumentTouch)
1228          );
1229        })(),
1230
1231      pointerEvents: !!(win.navigator.pointerEnabled || win.PointerEvent),
1232      prefixedPointerEvents: !!win.navigator.msPointerEnabled,
1233
1234      transition: (function checkTransition() {
1235        var style = testDiv.style;
1236        return (
1237          'transition' in style ||
1238          'webkitTransition' in style ||
1239          'MozTransition' in style
1240        );
1241      })(),
1242      transforms3d:
1243        (win.Modernizr && win.Modernizr.csstransforms3d === true) ||
1244        (function checkTransforms3d() {
1245          var style = testDiv.style;
1246          return (
1247            'webkitPerspective' in style ||
1248            'MozPerspective' in style ||
1249            'OPerspective' in style ||
1250            'MsPerspective' in style ||
1251            'perspective' in style
1252          );
1253        })(),
1254
1255      flexbox: (function checkFlexbox() {
1256        var style = testDiv.style;
1257        var styles = 'alignItems webkitAlignItems webkitBoxAlign msFlexAlign mozBoxAlign webkitFlexDirection msFlexDirection mozBoxDirection mozBoxOrient webkitBoxDirection webkitBoxOrient'.split(
1258          ' '
1259        );
1260        for (var i = 0; i < styles.length; i += 1) {
1261          if (styles[i] in style) {
1262            return true;
1263          }
1264        }
1265        return false;
1266      })(),
1267
1268      observer: (function checkObserver() {
1269        return (
1270          'MutationObserver' in win || 'WebkitMutationObserver' in win
1271        );
1272      })(),
1273
1274      passiveListener: (function checkPassiveListener() {
1275        var supportsPassive = false;
1276        try {
1277          var opts = Object.defineProperty({}, 'passive', {
1278            // eslint-disable-next-line
1279            get: function get() {
1280              supportsPassive = true;
1281            },
1282          });
1283          win.addEventListener('testPassiveListener', null, opts);
1284        } catch (e) {
1285          // No support
1286        }
1287        return supportsPassive;
1288      })(),
1289
1290      gestures: (function checkGestures() {
1291        return 'ongesturestart' in win;
1292      })(),
1293    };
1294  })();
1295
1296  var SwiperClass = function SwiperClass(params) {
1297    if (params === void 0) params = {};
1298
1299    var self = this;
1300    self.params = params;
1301
1302    // Events
1303    self.eventsListeners = {};
1304
1305    if (self.params && self.params.on) {
1306      Object.keys(self.params.on).forEach(function (eventName) {
1307        self.on(eventName, self.params.on[eventName]);
1308      });
1309    }
1310  };
1311
1312  var staticAccessors = { components: { configurable: true } };
1313
1314  SwiperClass.prototype.on = function on(events, handler, priority) {
1315    var self = this;
1316    if (typeof handler !== 'function') {
1317      return self;
1318    }
1319    var method = priority ? 'unshift' : 'push';
1320    events.split(' ').forEach(function (event) {
1321      if (!self.eventsListeners[event]) {
1322        self.eventsListeners[event] = [];
1323      }
1324      self.eventsListeners[event][method](handler);
1325    });
1326    return self;
1327  };
1328
1329  SwiperClass.prototype.once = function once(events, handler, priority) {
1330    var self = this;
1331    if (typeof handler !== 'function') {
1332      return self;
1333    }
1334    function onceHandler() {
1335      var args = [],
1336        len = arguments.length;
1337      while (len--) args[len] = arguments[len];
1338
1339      handler.apply(self, args);
1340      self.off(events, onceHandler);
1341    }
1342    return self.on(events, onceHandler, priority);
1343  };
1344
1345  SwiperClass.prototype.off = function off(events, handler) {
1346    var self = this;
1347    if (!self.eventsListeners) {
1348      return self;
1349    }
1350    events.split(' ').forEach(function (event) {
1351      if (typeof handler === 'undefined') {
1352        self.eventsListeners[event] = [];
1353      } else {
1354        self.eventsListeners[event].forEach(function (
1355          eventHandler,
1356          index
1357        ) {
1358          if (eventHandler === handler) {
1359            self.eventsListeners[event].splice(index, 1);
1360          }
1361        });
1362      }
1363    });
1364    return self;
1365  };
1366
1367  SwiperClass.prototype.emit = function emit() {
1368    var args = [],
1369      len = arguments.length;
1370    while (len--) args[len] = arguments[len];
1371
1372    var self = this;
1373    if (!self.eventsListeners) {
1374      return self;
1375    }
1376    var events;
1377    var data;
1378    var context;
1379    if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1380      events = args[0];
1381      data = args.slice(1, args.length);
1382      context = self;
1383    } else {
1384      events = args[0].events;
1385      data = args[0].data;
1386      context = args[0].context || self;
1387    }
1388    var eventsArray = Array.isArray(events) ? events : events.split(' ');
1389    eventsArray.forEach(function (event) {
1390      if (self.eventsListeners && self.eventsListeners[event]) {
1391        var handlers = [];
1392        self.eventsListeners[event].forEach(function (eventHandler) {
1393          handlers.push(eventHandler);
1394        });
1395        handlers.forEach(function (eventHandler) {
1396          eventHandler.apply(context, data);
1397        });
1398      }
1399    });
1400    return self;
1401  };
1402
1403  SwiperClass.prototype.useModulesParams = function useModulesParams(
1404    instanceParams
1405  ) {
1406    var instance = this;
1407    if (!instance.modules) {
1408      return;
1409    }
1410    Object.keys(instance.modules).forEach(function (moduleName) {
1411      var module = instance.modules[moduleName];
1412      // Extend params
1413      if (module.params) {
1414        Utils.extend(instanceParams, module.params);
1415      }
1416    });
1417  };
1418
1419  SwiperClass.prototype.useModules = function useModules(modulesParams) {
1420    if (modulesParams === void 0) modulesParams = {};
1421
1422    var instance = this;
1423    if (!instance.modules) {
1424      return;
1425    }
1426    Object.keys(instance.modules).forEach(function (moduleName) {
1427      var module = instance.modules[moduleName];
1428      var moduleParams = modulesParams[moduleName] || {};
1429      // Extend instance methods and props
1430      if (module.instance) {
1431        Object.keys(module.instance).forEach(function (modulePropName) {
1432          var moduleProp = module.instance[modulePropName];
1433          if (typeof moduleProp === 'function') {
1434            instance[modulePropName] = moduleProp.bind(instance);
1435          } else {
1436            instance[modulePropName] = moduleProp;
1437          }
1438        });
1439      }
1440      // Add event listeners
1441      if (module.on && instance.on) {
1442        Object.keys(module.on).forEach(function (moduleEventName) {
1443          instance.on(moduleEventName, module.on[moduleEventName]);
1444        });
1445      }
1446
1447      // Module create callback
1448      if (module.create) {
1449        module.create.bind(instance)(moduleParams);
1450      }
1451    });
1452  };
1453
1454  staticAccessors.components.set = function (components) {
1455    var Class = this;
1456    if (!Class.use) {
1457      return;
1458    }
1459    Class.use(components);
1460  };
1461
1462  SwiperClass.installModule = function installModule(module) {
1463    var params = [],
1464      len = arguments.length - 1;
1465    while (len-- > 0) params[len] = arguments[len + 1];
1466
1467    var Class = this;
1468    if (!Class.prototype.modules) {
1469      Class.prototype.modules = {};
1470    }
1471    var name =
1472      module.name ||
1473      Object.keys(Class.prototype.modules).length + '_' + Utils.now();
1474    Class.prototype.modules[name] = module;
1475    // Prototype
1476    if (module.proto) {
1477      Object.keys(module.proto).forEach(function (key) {
1478        Class.prototype[key] = module.proto[key];
1479      });
1480    }
1481    // Class
1482    if (module.static) {
1483      Object.keys(module.static).forEach(function (key) {
1484        Class[key] = module.static[key];
1485      });
1486    }
1487    // Callback
1488    if (module.install) {
1489      module.install.apply(Class, params);
1490    }
1491    return Class;
1492  };
1493
1494  SwiperClass.use = function use(module) {
1495    var params = [],
1496      len = arguments.length - 1;
1497    while (len-- > 0) params[len] = arguments[len + 1];
1498
1499    var Class = this;
1500    if (Array.isArray(module)) {
1501      module.forEach(function (m) {
1502        return Class.installModule(m);
1503      });
1504      return Class;
1505    }
1506    return Class.installModule.apply(Class, [module].concat(params));
1507  };
1508
1509  Object.defineProperties(SwiperClass, staticAccessors);
1510
1511  function updateSize() {
1512    var swiper = this;
1513    var width;
1514    var height;
1515    var $el = swiper.$el;
1516    if (typeof swiper.params.width !== 'undefined') {
1517      width = swiper.params.width;
1518    } else {
1519      width = $el[0].clientWidth;
1520    }
1521    if (typeof swiper.params.height !== 'undefined') {
1522      height = swiper.params.height;
1523    } else {
1524      height = $el[0].clientHeight;
1525    }
1526    if (
1527      (width === 0 && swiper.isHorizontal()) ||
1528      (height === 0 && swiper.isVertical())
1529    ) {
1530      return;
1531    }
1532
1533    // Subtract paddings
1534    width =
1535      width -
1536      parseInt($el.css('padding-left'), 10) -
1537      parseInt($el.css('padding-right'), 10);
1538    height =
1539      height -
1540      parseInt($el.css('padding-top'), 10) -
1541      parseInt($el.css('padding-bottom'), 10);
1542
1543    Utils.extend(swiper, {
1544      width: width,
1545      height: height,
1546      size: swiper.isHorizontal() ? width : height,
1547    });
1548  }
1549
1550  function updateSlides() {
1551    var swiper = this;
1552    var params = swiper.params;
1553
1554    var $wrapperEl = swiper.$wrapperEl;
1555    var swiperSize = swiper.size;
1556    var rtl = swiper.rtlTranslate;
1557    var wrongRTL = swiper.wrongRTL;
1558    var isVirtual = swiper.virtual && params.virtual.enabled;
1559    var previousSlidesLength = isVirtual
1560      ? swiper.virtual.slides.length
1561      : swiper.slides.length;
1562    var slides = $wrapperEl.children('.' + swiper.params.slideClass);
1563    var slidesLength = isVirtual
1564      ? swiper.virtual.slides.length
1565      : slides.length;
1566    var snapGrid = [];
1567    var slidesGrid = [];
1568    var slidesSizesGrid = [];
1569
1570    var offsetBefore = params.slidesOffsetBefore;
1571    if (typeof offsetBefore === 'function') {

2187      : -swiper.translate;
2188    var slidesGrid = swiper.slidesGrid;
2189    var snapGrid = swiper.snapGrid;
2190    var params = swiper.params;
2191    var previousIndex = swiper.activeIndex;
2192    var previousRealIndex = swiper.realIndex;
2193    var previousSnapIndex = swiper.snapIndex;
2194    var activeIndex = newActiveIndex;
2195    var snapIndex;
2196    if (typeof activeIndex === 'undefined') {
2197      for (var i = 0; i < slidesGrid.length; i += 1) {
2198        if (typeof slidesGrid[i + 1] !== 'undefined') {
2199          if (
2200            translate >= slidesGrid[i] &&
2201            translate <
2202            slidesGrid[i + 1] -
2203            (slidesGrid[i + 1] - slidesGrid[i]) / 2
2204          ) {
2205            activeIndex = i;
2206          } else if (
2207            translate >= slidesGrid[i] &&
2208            translate < slidesGrid[i + 1]
2209          ) {
2210            activeIndex = i + 1;
2211          }
2212        } else if (translate >= slidesGrid[i]) {
2213          activeIndex = i;
2214        }
2215      }
2216      // Normalize slideIndex
2217      if (params.normalizeSlideIndex) {
2218        if (activeIndex < 0 || typeof activeIndex === 'undefined') {
2219          activeIndex = 0;
2220        }
2221      }
2222    }
2223    if (snapGrid.indexOf(translate) >= 0) {
2224      snapIndex = snapGrid.indexOf(translate);
2225    } else {
2226      snapIndex = Math.floor(activeIndex / params.slidesPerGroup);
2227    }
2228    if (snapIndex >= snapGrid.length) {
2229      snapIndex = snapGrid.length - 1;
2230    }
2231    if (activeIndex === previousIndex) {
2232      if (snapIndex !== previousSnapIndex) {
2233        swiper.snapIndex = snapIndex;
2234        swiper.emit('snapIndexChange');
2235      }
2236      return;
2237    }
2238
2239    // Get real index
2240    var realIndex = parseInt(
2241      swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') ||
2242      activeIndex,
2243      10
2244    );
2245
2246    Utils.extend(swiper, {
2247      snapIndex: snapIndex,
2248      realIndex: realIndex,
2249      previousIndex: previousIndex,
2250      activeIndex: activeIndex,
2251    });
2252    swiper.emit('activeIndexChange');
2253    swiper.emit('snapIndexChange');
2254    if (previousRealIndex !== realIndex) {
2255      swiper.emit('realIndexChange');
2256    }
2257    swiper.emit('slideChange');
2258  }
2259
2260  function updateClickedSlide(e) {
2261    var swiper = this;
2262    var params = swiper.params;
2263    var slide = $(e.target).closest('.' + params.slideClass)[0];
2264    var slideFound = false;
2265    if (slide) {
2266      for (var i = 0; i < swiper.slides.length; i += 1) {
2267        if (swiper.slides[i] === slide) {
2268          slideFound = true;
2269        }
2270      }
2271    }
2272
2273    if (slide && slideFound) {
2274      swiper.clickedSlide = slide;
2275      if (swiper.virtual && swiper.params.virtual.enabled) {
2276        swiper.clickedIndex = parseInt(
2277          $(slide).attr('data-swiper-slide-index'),
2278          10
2279        );
2280      } else {
2281        swiper.clickedIndex = $(slide).index();
2282      }
2283    } else {
2284      swiper.clickedSlide = undefined;
2285      swiper.clickedIndex = undefined;
2286      return;
2287    }
2288    if (
2289      params.slideToClickedSlide &&
2290      swiper.clickedIndex !== undefined &&
2291      swiper.clickedIndex !== swiper.activeIndex
2292    ) {
2293      swiper.slideToClickedSlide();
2294    }
2295  }
2296
2297  var update = {
2298    updateSize: updateSize,
2299    updateSlides: updateSlides,
2300    updateAutoHeight: updateAutoHeight,
2301    updateSlidesOffset: updateSlidesOffset,
2302    updateSlidesProgress: updateSlidesProgress,
2303    updateProgress: updateProgress,
2304    updateSlidesClasses: updateSlidesClasses,
2305    updateActiveIndex: updateActiveIndex,
2306    updateClickedSlide: updateClickedSlide,
2307  };
2308
2309  function getTranslate(axis) {
2310    if (axis === void 0) axis = this.isHorizontal() ? 'x' : 'y';
2311
2312    var swiper = this;
2313
2314    var params = swiper.params;
2315    var rtl = swiper.rtlTranslate;
2316    var translate = swiper.translate;
2317    var $wrapperEl = swiper.$wrapperEl;
2318
2319    if (params.virtualTranslate) {
2320      return rtl ? -translate : translate;
2321    }
2322
2323    var currentTranslate = Utils.getTranslate($wrapperEl[0], axis);
2324    if (rtl) {
2325      currentTranslate = -currentTranslate;
2326    }
2327
2328    return currentTranslate || 0;
2329  }
2330
2331  function setTranslate(translate, byController) {
2332    var swiper = this;
2333    var rtl = swiper.rtlTranslate;
2334    var params = swiper.params;
2335    var $wrapperEl = swiper.$wrapperEl;
2336    var progress = swiper.progress;
2337    var x = 0;
2338    var y = 0;
2339    var z = 0;
2340
2341    if (swiper.isHorizontal()) {
2342      x = rtl ? -translate : translate;
2343    } else {
2344      y = translate;
2345    }
2346
2347    if (params.roundLengths) {
2348      x = Math.floor(x);
2349      y = Math.floor(y);
2350    }
2351
2352    if (!params.virtualTranslate) {
2353      if (Support.transforms3d) {
2354        $wrapperEl.transform(
2355          'translate3d(' + x + 'px, ' + y + 'px, ' + z + 'px)'
2356        );
2357      } else {
2358        $wrapperEl.transform('translate(' + x + 'px, ' + y + 'px)');
2359      }
2360    }
2361    swiper.previousTranslate = swiper.translate;
2362    swiper.translate = swiper.isHorizontal() ? x : y;
2363
2364    // Check if we need to update progress
2365    var newProgress;
2366    var translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2367    if (translatesDiff === 0) {
2368      newProgress = 0;
2369    } else {
2370      newProgress = (translate - swiper.minTranslate()) / translatesDiff;
2371    }
2372    if (newProgress !== progress) {
2373      swiper.updateProgress(translate);
2374    }
2375
2376    swiper.emit('setTranslate', swiper.translate, byController);
2377  }
2378
2379  function minTranslate() {
2380    return -this.snapGrid[0];
2381  }
2382
2383  function maxTranslate() {
2384    return -this.snapGrid[this.snapGrid.length - 1];
2385  }
2386
2387  var translate = {
2388    getTranslate: getTranslate,
2389    setTranslate: setTranslate,
2390    minTranslate: minTranslate,
2391    maxTranslate: maxTranslate,
2392  };
2393
2394  function setTransition(duration, byController) {
2395    var swiper = this;
2396
2397    swiper.$wrapperEl.transition(duration);
2398
2399    swiper.emit('setTransition', duration, byController);
2400  }
2401
2402  function transitionStart(runCallbacks, direction) {
2403    if (runCallbacks === void 0) runCallbacks = true;
2404
2405    var swiper = this;
2406    var activeIndex = swiper.activeIndex;
2407    var params = swiper.params;
2408    var previousIndex = swiper.previousIndex;
2409    if (params.autoHeight) {
2410      swiper.updateAutoHeight();
2411    }
2412
2413    var dir = direction;
2414    if (!dir) {
2415      if (activeIndex > previousIndex) {
2416        dir = 'next';
2417      } else if (activeIndex < previousIndex) {
2418        dir = 'prev';
2419      } else {
2420        dir = 'reset';
2421      }
2422    }
2423
2424    swiper.emit('transitionStart');
2425
2426    if (runCallbacks && activeIndex !== previousIndex) {
2427      if (dir === 'reset') {
2428        swiper.emit('slideResetTransitionStart');
2429        return;
2430      }
2431      swiper.emit('slideChangeTransitionStart');
2432      if (dir === 'next') {
2433        swiper.emit('slideNextTransitionStart');
2434      } else {
2435        swiper.emit('slidePrevTransitionStart');
2436      }
2437    }
2438  }
2439
2440  function transitionEnd$1(runCallbacks, direction) {
2441    if (runCallbacks === void 0) runCallbacks = true;
2442
2443    var swiper = this;
2444    var activeIndex = swiper.activeIndex;
2445    var previousIndex = swiper.previousIndex;
2446    swiper.animating = false;
2447    swiper.setTransition(0);
2448
2449    var dir = direction;
2450    if (!dir) {
2451      if (activeIndex > previousIndex) {
2452        dir = 'next';
2453      } else if (activeIndex < previousIndex) {
2454        dir = 'prev';
2455      } else {
2456        dir = 'reset';
2457      }
2458    }
2459
2460    swiper.emit('transitionEnd');
2461
2462    if (runCallbacks && activeIndex !== previousIndex) {
2463      if (dir === 'reset') {
2464        swiper.emit('slideResetTransitionEnd');
2465        return;
2466      }
2467      swiper.emit('slideChangeTransitionEnd');
2468      if (dir === 'next') {
2469        swiper.emit('slideNextTransitionEnd');
2470      } else {
2471        swiper.emit('slidePrevTransitionEnd');
2472      }
2473    }
2474  }
2475
2476  var transition$1 = {
2477    setTransition: setTransition,
2478    transitionStart: transitionStart,
2479    transitionEnd: transitionEnd$1,
2480  };
2481
2482  function slideTo(index, speed, runCallbacks, internal) {
2483    if (index === void 0) index = 0;
2484    if (speed === void 0) speed = this.params.speed;
2485    if (runCallbacks === void 0) runCallbacks = true;
2486
2487    var swiper = this;
2488    var slideIndex = index;
2489    if (slideIndex < 0) {
2490      slideIndex = 0;
2491    }
2492
2493    var params = swiper.params;
2494    var snapGrid = swiper.snapGrid;
2495    var slidesGrid = swiper.slidesGrid;
2496    var previousIndex = swiper.previousIndex;
2497    var activeIndex = swiper.activeIndex;
2498    var rtl = swiper.rtlTranslate;
2499    if (swiper.animating && params.preventInteractionOnTransition) {
2500      return false;
2501    }
2502
2503    var snapIndex = Math.floor(slideIndex / params.slidesPerGroup);
2504    if (snapIndex >= snapGrid.length) {
2505      snapIndex = snapGrid.length - 1;
2506    }
2507
2508    if (
2509      (activeIndex || params.initialSlide || 0) ===
2510      (previousIndex || 0) &&
2511      runCallbacks
2512    ) {
2513      swiper.emit('beforeSlideChangeStart');
2514    }
2515
2516    var translate = -snapGrid[snapIndex];
2517
2518    // Update progress
2519    swiper.updateProgress(translate);
2520
2521    // Normalize slideIndex
2522    if (params.normalizeSlideIndex) {
2523      for (var i = 0; i < slidesGrid.length; i += 1) {
2524        if (
2525          -Math.floor(translate * 100) >=
2526          Math.floor(slidesGrid[i] * 100)
2527        ) {
2528          slideIndex = i;
2529        }
2530      }
2531    }
2532    // Directions locks
2533    if (swiper.initialized && slideIndex !== activeIndex) {
2534      if (
2535        !swiper.allowSlideNext &&
2536        translate < swiper.translate &&
2537        translate < swiper.minTranslate()
2538      ) {
2539        return false;
2540      }
2541      if (
2542        !swiper.allowSlidePrev &&
2543        translate > swiper.translate &&
2544        translate > swiper.maxTranslate()
2545      ) {
2546        if ((activeIndex || 0) !== slideIndex) {
2547          return false;
2548        }
2549      }
2550    }
2551
2552    var direction;
2553    if (slideIndex > activeIndex) {
2554      direction = 'next';
2555    } else if (slideIndex < activeIndex) {
2556      direction = 'prev';
2557    } else {
2558      direction = 'reset';
2559    }
2560
2561    // Update Index
2562    if (
2563      (rtl && -translate === swiper.translate) ||
2564      (!rtl && translate === swiper.translate)
2565    ) {
2566      swiper.updateActiveIndex(slideIndex);
2567      // Update Height
2568      if (params.autoHeight) {
2569        swiper.updateAutoHeight();
2570      }
2571      swiper.updateSlidesClasses();
2572      if (params.effect !== 'slide') {
2573        swiper.setTranslate(translate);
2574      }
2575      if (direction !== 'reset') {
2576        swiper.transitionStart(runCallbacks, direction);
2577        swiper.transitionEnd(runCallbacks, direction);
2578      }
2579      return false;
2580    }
2581
2582    if (speed === 0 || !Support.transition) {
2583      swiper.setTransition(0);
2584      swiper.setTranslate(translate);
2585      swiper.updateActiveIndex(slideIndex);
2586      swiper.updateSlidesClasses();
2587      swiper.emit('beforeTransitionStart', speed, internal);
2588      swiper.transitionStart(runCallbacks, direction);
2589      swiper.transitionEnd(runCallbacks, direction);
2590    } else {
2591      swiper.setTransition(speed);
2592      swiper.setTranslate(translate);
2593      swiper.updateActiveIndex(slideIndex);
2594      swiper.updateSlidesClasses();
2595      swiper.emit('beforeTransitionStart', speed, internal);
2596      swiper.transitionStart(runCallbacks, direction);
2597      if (!swiper.animating) {
2598        swiper.animating = true;
2599        if (!swiper.onSlideToWrapperTransitionEnd) {
2600          swiper.onSlideToWrapperTransitionEnd = function transitionEnd(
2601            e
2602          ) {
2603            if (!swiper || swiper.destroyed) {
2604              return;
2605            }
2606            if (e.target !== this) {
2607              return;
2608            }
2609            swiper.$wrapperEl[0].removeEventListener(
2610              'transitionend',
2611              swiper.onSlideToWrapperTransitionEnd
2612            );
2613            swiper.$wrapperEl[0].removeEventListener(
2614              'webkitTransitionEnd',
2615              swiper.onSlideToWrapperTransitionEnd
2616            );
2617            swiper.onSlideToWrapperTransitionEnd = null;
2618            delete swiper.onSlideToWrapperTransitionEnd;
2619            swiper.transitionEnd(runCallbacks, direction);
2620          };
2621        }
2622        swiper.$wrapperEl[0].addEventListener(
2623          'transitionend',
2624          swiper.onSlideToWrapperTransitionEnd
2625        );
2626        swiper.$wrapperEl[0].addEventListener(
2627          'webkitTransitionEnd',
2628          swiper.onSlideToWrapperTransitionEnd
2629        );
2630      }
2631    }
2632
2633    return true;
2634  }
2635
2636  function slideToLoop(index, speed, runCallbacks, internal) {
2637    if (index === void 0) index = 0;
2638    if (speed === void 0) speed = this.params.speed;
2639    if (runCallbacks === void 0) runCallbacks = true;
2640
2641    var swiper = this;
2642    var newIndex = index;
2643    if (swiper.params.loop) {
2644      newIndex += swiper.loopedSlides;
2645    }
2646
2647    return swiper.slideTo(newIndex, speed, runCallbacks, internal);
2648  }
2649
2650  /* eslint no-unused-vars: "off" */
2651  function slideNext(speed, runCallbacks, internal) {
2652    if (speed === void 0) speed = this.params.speed;
2653    if (runCallbacks === void 0) runCallbacks = true;
2654
2655    var swiper = this;
2656    var params = swiper.params;
2657    var animating = swiper.animating;
2658    if (params.loop) {
2659      if (animating) {
2660        return false;
2661      }
2662      swiper.loopFix();
2663      // eslint-disable-next-line
2664      swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2665      return swiper.slideTo(
2666        swiper.activeIndex + params.slidesPerGroup,
2667        speed,
2668        runCallbacks,
2669        internal
2670      );
2671    }
2672    return swiper.slideTo(
2673      swiper.activeIndex + params.slidesPerGroup,
2674      speed,
2675      runCallbacks,
2676      internal
2677    );
2678  }
2679
2680  /* eslint no-unused-vars: "off" */
2681  function slidePrev(speed, runCallbacks, internal) {
2682    if (speed === void 0) speed = this.params.speed;
2683    if (runCallbacks === void 0) runCallbacks = true;
2684
2685    var swiper = this;
2686    var params = swiper.params;
2687    var animating = swiper.animating;
2688    var snapGrid = swiper.snapGrid;
2689    var slidesGrid = swiper.slidesGrid;
2690    var rtlTranslate = swiper.rtlTranslate;
2691
2692    if (params.loop) {
2693      if (animating) {
2694        return false;
2695      }
2696      swiper.loopFix();
2697      // eslint-disable-next-line
2698      swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2699    }
2700    var translate = rtlTranslate ? swiper.translate : -swiper.translate;
2701    function normalize(val) {
2702      if (val < 0) {
2703        return -Math.floor(Math.abs(val));
2704      }
2705      return Math.floor(val);
2706    }
2707    var normalizedTranslate = normalize(translate);
2708    var normalizedSnapGrid = snapGrid.map(function (val) {
2709      return normalize(val);
2710    });
2711    var normalizedSlidesGrid = slidesGrid.map(function (val) {
2712      return normalize(val);
2713    });
2714
2715    var currentSnap =
2716      snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate)];
2717    var prevSnap =
2718      snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2719    var prevIndex;
2720    if (typeof prevSnap !== 'undefined') {
2721      prevIndex = slidesGrid.indexOf(prevSnap);
2722      if (prevIndex < 0) {
2723        prevIndex = swiper.activeIndex - 1;
2724      }
2725    }
2726    return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2727  }
2728
2729  /* eslint no-unused-vars: "off" */
2730  function slideReset(speed, runCallbacks, internal) {
2731    if (speed === void 0) speed = this.params.speed;
2732    if (runCallbacks === void 0) runCallbacks = true;
2733
2734    var swiper = this;
2735    return swiper.slideTo(
2736      swiper.activeIndex,
2737      speed,
2738      runCallbacks,
2739      internal
2740    );
2741  }
2742
2743  /* eslint no-unused-vars: "off" */
2744  function slideToClosest(speed, runCallbacks, internal) {
2745    if (speed === void 0) speed = this.params.speed;
2746    if (runCallbacks === void 0) runCallbacks = true;
2747
2748    var swiper = this;
2749    var index = swiper.activeIndex;
2750    var snapIndex = Math.floor(index / swiper.params.slidesPerGroup);
2751
2752    if (snapIndex < swiper.snapGrid.length - 1) {
2753      var translate = swiper.rtlTranslate
2754        ? swiper.translate
2755        : -swiper.translate;
2756
2757      var currentSnap = swiper.snapGrid[snapIndex];
2758      var nextSnap = swiper.snapGrid[snapIndex + 1];
2759
2760      if (translate - currentSnap > (nextSnap - currentSnap) / 2) {
2761        index = swiper.params.slidesPerGroup;
2762      }
2763    }
2764
2765    return swiper.slideTo(index, speed, runCallbacks, internal);
2766  }
2767
2768  function slideToClickedSlide() {
2769    var swiper = this;
2770    var params = swiper.params;
2771    var $wrapperEl = swiper.$wrapperEl;
2772
2773    var slidesPerView =
2774      params.slidesPerView === 'auto'
2775        ? swiper.slidesPerViewDynamic()
2776        : params.slidesPerView;
2777    var slideToIndex = swiper.clickedIndex;
2778    var realIndex;
2779    if (params.loop) {
2780      if (swiper.animating) {
2781        return;
2782      }
2783      realIndex = parseInt(
2784        $(swiper.clickedSlide).attr('data-swiper-slide-index'),
2785        10
2786      );
2787      if (params.centeredSlides) {
2788        if (
2789          slideToIndex < swiper.loopedSlides - slidesPerView / 2 ||
2790          slideToIndex >
2791          swiper.slides.length -
2792          swiper.loopedSlides +
2793          slidesPerView / 2
2794        ) {
2795          swiper.loopFix();
2796          slideToIndex = $wrapperEl
2797            .children(
2798              '.' +
2799              params.slideClass +
2800              '[data-swiper-slide-index="' +
2801              realIndex +
2802              '"]:not(.' +
2803              params.slideDuplicateClass +
2804              ')'
2805            )
2806            .eq(0)
2807            .index();
2808
2809          Utils.nextTick(function () {
2810            swiper.slideTo(slideToIndex);
2811          });
2812        } else {
2813          swiper.slideTo(slideToIndex);
2814        }
2815      } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2816        swiper.loopFix();
2817        slideToIndex = $wrapperEl
2818          .children(
2819            '.' +
2820            params.slideClass +
2821            '[data-swiper-slide-index="' +
2822            realIndex +
2823            '"]:not(.' +
2824            params.slideDuplicateClass +
2825            ')'
2826          )
2827          .eq(0)
2828          .index();
2829
2830        Utils.nextTick(function () {
2831          swiper.slideTo(slideToIndex);
2832        });
2833      } else {
2834        swiper.slideTo(slideToIndex);
2835      }
2836    } else {
2837      swiper.slideTo(slideToIndex);
2838    }
2839  }
2840
2841  var slide = {
2842    slideTo: slideTo,
2843    slideToLoop: slideToLoop,
2844    slideNext: slideNext,
2845    slidePrev: slidePrev,
2846    slideReset: slideReset,
2847    slideToClosest: slideToClosest,
2848    slideToClickedSlide: slideToClickedSlide,
2849  };
2850
2851  function loopCreate() {
2852    var swiper = this;
2853    var params = swiper.params;
2854    var $wrapperEl = swiper.$wrapperEl;
2855    // Remove duplicated slides
2856    $wrapperEl
2857      .children(
2858        '.' + params.slideClass + '.' + params.slideDuplicateClass
2859      )
2860      .remove();
2861
2862    var slides = $wrapperEl.children('.' + params.slideClass);
2863
2864    if (params.loopFillGroupWithBlank) {
2865      var blankSlidesNum =
2866        params.slidesPerGroup - (slides.length % params.slidesPerGroup);
2867      if (blankSlidesNum !== params.slidesPerGroup) {
2868        for (var i = 0; i < blankSlidesNum; i += 1) {
2869          var blankNode = $(doc.createElement('div')).addClass(
2870            params.slideClass + ' ' + params.slideBlankClass
2871          );
2872          $wrapperEl.append(blankNode);
2873        }
2874        slides = $wrapperEl.children('.' + params.slideClass);
2875      }
2876    }
2877
2878    if (params.slidesPerView === 'auto' && !params.loopedSlides) {
2879      params.loopedSlides = slides.length;
2880    }
2881
2882    swiper.loopedSlides = parseInt(
2883      params.loopedSlides || params.slidesPerView,
2884      10
2885    );
2886    swiper.loopedSlides += params.loopAdditionalSlides;
2887    if (swiper.loopedSlides > slides.length) {
2888      swiper.loopedSlides = slides.length;
2889    }
2890
2891    var prependSlides = [];
2892    var appendSlides = [];
2893    slides.each(function (index, el) {
2894      var slide = $(el);
2895      if (index < swiper.loopedSlides) {
2896        appendSlides.push(el);
2897      }
2898      if (
2899        index < slides.length &&
2900        index >= slides.length - swiper.loopedSlides
2901      ) {
2902        prependSlides.push(el);
2903      }
2904      slide.attr('data-swiper-slide-index', index);
2905    });
2906    for (var i$1 = 0; i$1 < appendSlides.length; i$1 += 1) {
2907      $wrapperEl.append(
2908        $(appendSlides[i$1].cloneNode(true)).addClass(
2909          params.slideDuplicateClass
2910        )
2911      );
2912    }
2913    for (var i$2 = prependSlides.length - 1; i$2 >= 0; i$2 -= 1) {
2914      $wrapperEl.prepend(
2915        $(prependSlides[i$2].cloneNode(true)).addClass(
2916          params.slideDuplicateClass
2917        )
2918      );
2919    }
2920  }
2921
2922  function loopFix() {
2923    var swiper = this;
2924    var params = swiper.params;
2925    var activeIndex = swiper.activeIndex;
2926    var slides = swiper.slides;
2927    var loopedSlides = swiper.loopedSlides;
2928    var allowSlidePrev = swiper.allowSlidePrev;
2929    var allowSlideNext = swiper.allowSlideNext;
2930    var snapGrid = swiper.snapGrid;
2931    var rtl = swiper.rtlTranslate;
2932    var newIndex;
2933    swiper.allowSlidePrev = true;
2934    swiper.allowSlideNext = true;
2935
2936    var snapTranslate = -snapGrid[activeIndex];
2937    var diff = snapTranslate - swiper.getTranslate();
2938
2939    // Fix For Negative Oversliding
2940    if (activeIndex < loopedSlides) {
2941      newIndex = slides.length - loopedSlides * 3 + activeIndex;
2942      newIndex += loopedSlides;
2943      var slideChanged = swiper.slideTo(newIndex, 0, false, true);
2944      if (slideChanged && diff !== 0) {
2945        swiper.setTranslate(
2946          (rtl ? -swiper.translate : swiper.translate) - diff
2947        );
2948      }
2949    } else if (
2950      (params.slidesPerView === 'auto' &&
2951        activeIndex >= loopedSlides * 2) ||
2952      activeIndex >= slides.length - loopedSlides
2953    ) {
2954      // Fix For Positive Oversliding
2955      newIndex = -slides.length + activeIndex + loopedSlides;
2956      newIndex += loopedSlides;
2957      var slideChanged$1 = swiper.slideTo(newIndex, 0, false, true);
2958      if (slideChanged$1 && diff !== 0) {
2959        swiper.setTranslate(
2960          (rtl ? -swiper.translate : swiper.translate) - diff
2961        );
2962      }
2963    }
2964    swiper.allowSlidePrev = allowSlidePrev;
2965    swiper.allowSlideNext = allowSlideNext;
2966  }
2967
2968  function loopDestroy() {
2969    var swiper = this;
2970    var $wrapperEl = swiper.$wrapperEl;
2971    var params = swiper.params;
2972    var slides = swiper.slides;
2973    $wrapperEl
2974      .children(
2975        '.' + params.slideClass + '.' + params.slideDuplicateClass
2976      )
2977      .remove();
2978    slides.removeAttr('data-swiper-slide-index');
2979  }
2980
2981  var loop = {
2982    loopCreate: loopCreate,
2983    loopFix: loopFix,
2984    loopDestroy: loopDestroy,
2985  };
2986
2987  function setGrabCursor(moving) {
2988    var swiper = this;
2989    if (
2990      Support.touch ||
2991      !swiper.params.simulateTouch ||
2992      (swiper.params.watchOverflow && swiper.isLocked)
2993    ) {
2994      return;
2995    }
2996    var el = swiper.el;
2997    el.style.cursor = 'move';
2998    el.style.cursor = moving ? '-webkit-grabbing' : '-webkit-grab';
2999    el.style.cursor = moving ? '-moz-grabbin' : '-moz-grab';
3000    el.style.cursor = moving ? 'grabbing' : 'grab';
3001  }
3002
3003  function unsetGrabCursor() {
3004    var swiper = this;
3005    if (Support.touch || (swiper.params.watchOverflow && swiper.isLocked)) {
3006      return;
3007    }
3008    swiper.el.style.cursor = '';
3009  }
3010
3011  var grabCursor = {
3012    setGrabCursor: setGrabCursor,
3013    unsetGrabCursor: unsetGrabCursor,
3014  };
3015
3016  function appendSlide(slides) {
3017    var swiper = this;
3018    var $wrapperEl = swiper.$wrapperEl;
3019    var params = swiper.params;
3020    if (params.loop) {
3021      swiper.loopDestroy();
3022    }
3023    if (typeof slides === 'object' && 'length' in slides) {
3024      for (var i = 0; i < slides.length; i += 1) {
3025        if (slides[i]) {
3026          $wrapperEl.append(slides[i]);
3027        }
3028      }
3029    } else {
3030      $wrapperEl.append(slides);
3031    }
3032    if (params.loop) {
3033      swiper.loopCreate();
3034    }
3035    if (!(params.observer && Support.observer)) {
3036      swiper.update();
3037    }
3038  }
3039
3040  function prependSlide(slides) {
3041    var swiper = this;
3042    var params = swiper.params;
3043    var $wrapperEl = swiper.$wrapperEl;
3044    var activeIndex = swiper.activeIndex;
3045
3046    if (params.loop) {
3047      swiper.loopDestroy();
3048    }
3049    var newActiveIndex = activeIndex + 1;
3050    if (typeof slides === 'object' && 'length' in slides) {
3051      for (var i = 0; i < slides.length; i += 1) {
3052        if (slides[i]) {
3053          $wrapperEl.prepend(slides[i]);
3054        }
3055      }
3056      newActiveIndex = activeIndex + slides.length;
3057    } else {
3058      $wrapperEl.prepend(slides);
3059    }
3060    if (params.loop) {
3061      swiper.loopCreate();
3062    }
3063    if (!(params.observer && Support.observer)) {
3064      swiper.update();
3065    }
3066    swiper.slideTo(newActiveIndex, 0, false);
3067  }
3068
3069  function addSlide(index, slides) {
3070    var swiper = this;
3071    var $wrapperEl = swiper.$wrapperEl;
3072    var params = swiper.params;
3073    var activeIndex = swiper.activeIndex;
3074    var activeIndexBuffer = activeIndex;
3075    if (params.loop) {
3076      activeIndexBuffer -= swiper.loopedSlides;
3077      swiper.loopDestroy();
3078      swiper.slides = $wrapperEl.children('.' + params.slideClass);
3079    }
3080    var baseLength = swiper.slides.length;
3081    if (index <= 0) {
3082      swiper.prependSlide(slides);
3083      return;
3084    }
3085    if (index >= baseLength) {
3086      swiper.appendSlide(slides);
3087      return;
3088    }
3089    var newActiveIndex =
3090      activeIndexBuffer > index
3091        ? activeIndexBuffer + 1
3092        : activeIndexBuffer;
3093
3094    var slidesBuffer = [];
3095    for (var i = baseLength - 1; i >= index; i -= 1) {
3096      var currentSlide = swiper.slides.eq(i);
3097      currentSlide.remove();
3098      slidesBuffer.unshift(currentSlide);
3099    }
3100
3101    if (typeof slides === 'object' && 'length' in slides) {
3102      for (var i$1 = 0; i$1 < slides.length; i$1 += 1) {
3103        if (slides[i$1]) {
3104          $wrapperEl.append(slides[i$1]);
3105        }
3106      }
3107      newActiveIndex =
3108        activeIndexBuffer > index
3109          ? activeIndexBuffer + slides.length
3110          : activeIndexBuffer;
3111    } else {
3112      $wrapperEl.append(slides);
3113    }
3114
3115    for (var i$2 = 0; i$2 < slidesBuffer.length; i$2 += 1) {
3116      $wrapperEl.append(slidesBuffer[i$2]);
3117    }
3118
3119    if (params.loop) {
3120      swiper.loopCreate();
3121    }
3122    if (!(params.observer && Support.observer)) {
3123      swiper.update();
3124    }
3125    if (params.loop) {
3126      swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
3127    } else {
3128      swiper.slideTo(newActiveIndex, 0, false);
3129    }
3130  }
3131
3132  function removeSlide(slidesIndexes) {
3133    var swiper = this;
3134    var params = swiper.params;
3135    var $wrapperEl = swiper.$wrapperEl;
3136    var activeIndex = swiper.activeIndex;
3137
3138    var activeIndexBuffer = activeIndex;
3139    if (params.loop) {
3140      activeIndexBuffer -= swiper.loopedSlides;
3141      swiper.loopDestroy();
3142      swiper.slides = $wrapperEl.children('.' + params.slideClass);
3143    }
3144    var newActiveIndex = activeIndexBuffer;
3145    var indexToRemove;
3146
3147    if (typeof slidesIndexes === 'object' && 'length' in slidesIndexes) {
3148      for (var i = 0; i < slidesIndexes.length; i += 1) {
3149        indexToRemove = slidesIndexes[i];
3150        if (swiper.slides[indexToRemove]) {
3151          swiper.slides.eq(indexToRemove).remove();
3152        }
3153        if (indexToRemove < newActiveIndex) {
3154          newActiveIndex -= 1;
3155        }
3156      }
3157      newActiveIndex = Math.max(newActiveIndex, 0);
3158    } else {
3159      indexToRemove = slidesIndexes;
3160      if (swiper.slides[indexToRemove]) {
3161        swiper.slides.eq(indexToRemove).remove();
3162      }
3163      if (indexToRemove < newActiveIndex) {
3164        newActiveIndex -= 1;
3165      }
3166      newActiveIndex = Math.max(newActiveIndex, 0);
3167    }
3168
3169    if (params.loop) {
3170      swiper.loopCreate();
3171    }
3172
3173    if (!(params.observer && Support.observer)) {
3174      swiper.update();
3175    }
3176    if (params.loop) {
3177      swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
3178    } else {
3179      swiper.slideTo(newActiveIndex, 0, false);
3180    }
3181  }
3182
3183  function removeAllSlides() {
3184    var swiper = this;
3185
3186    var slidesIndexes = [];
3187    for (var i = 0; i < swiper.slides.length; i += 1) {
3188      slidesIndexes.push(i);
3189    }
3190    swiper.removeSlide(slidesIndexes);
3191  }
3192
3193  var manipulation = {
3194    appendSlide: appendSlide,
3195    prependSlide: prependSlide,
3196    addSlide: addSlide,
3197    removeSlide: removeSlide,
3198    removeAllSlides: removeAllSlides,
3199  };
3200
3201  var Device = (function Device() {
3202    var ua = win.navigator.userAgent;
3203
3204    var device = {
3205      ios: false,
3206      android: false,
3207      androidChrome: false,
3208      desktop: false,
3209      windows: false,
3210      iphone: false,
3211      ipod: false,
3212      ipad: false,
3213      cordova: win.cordova || win.phonegap,
3214      phonegap: win.cordova || win.phonegap,
3215    };
3216
3217    var windows = ua.match(/(Windows Phone);?[\s\/]+([\d.]+)?/); // eslint-disable-line
3218    var android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
3219    var ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
3220    var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
3221    var iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
3222
3223    // Windows
3224    if (windows) {
3225      device.os = 'windows';
3226      device.osVersion = windows[2];
3227      device.windows = true;
3228    }
3229    // Android
3230    if (android && !windows) {
3231      device.os = 'android';
3232      device.osVersion = android[2];
3233      device.android = true;
3234      device.androidChrome = ua.toLowerCase().indexOf('chrome') >= 0;
3235    }
3236    if (ipad || iphone || ipod) {
3237      device.os = 'ios';
3238      device.ios = true;
3239    }
3240    // iOS
3241    if (iphone && !ipod) {
3242      device.osVersion = iphone[2].replace(/_/g, '.');
3243      device.iphone = true;
3244    }
3245    if (ipad) {
3246      device.osVersion = ipad[2].replace(/_/g, '.');
3247      device.ipad = true;
3248    }
3249    if (ipod) {
3250      device.osVersion = ipod[3] ? ipod[3].replace(/_/g, '.') : null;
3251      device.iphone = true;
3252    }
3253    // iOS 8+ changed UA
3254    if (device.ios && device.osVersion && ua.indexOf('Version/') >= 0) {
3255      if (device.osVersion.split('.')[0] === '10') {
3256        device.osVersion = ua
3257          .toLowerCase()
3258          .split('version/')[1]
3259          .split(' ')[0];
3260      }
3261    }
3262
3263    // Desktop
3264    device.desktop = !(device.os || device.android || device.webView);
3265
3266    // Webview
3267    device.webView =
3268      (iphone || ipad || ipod) && ua.match(/.*AppleWebKit(?!.*Safari)/i);
3269
3270    // Minimal UI
3271    if (device.os && device.os === 'ios') {
3272      var osVersionArr = device.osVersion.split('.');
3273      var metaViewport = doc.querySelector('meta[name="viewport"]');
3274      device.minimalUi =
3275        !device.webView &&
3276        (ipod || iphone) &&
3277        (osVersionArr[0] * 1 === 7
3278          ? osVersionArr[1] * 1 >= 1
3279          : osVersionArr[0] * 1 > 7) &&
3280        metaViewport &&
3281        metaViewport.getAttribute('content').indexOf('minimal-ui') >= 0;
3282    }
3283
3284    // Pixel Ratio
3285    device.pixelRatio = win.devicePixelRatio || 1;
3286
3287    // Export object
3288    return device;
3289  })();
3290
3291  function onTouchStart(event) {
3292    var swiper = this;
3293    var data = swiper.touchEventsData;
3294    var params = swiper.params;
3295    var touches = swiper.touches;
3296    if (swiper.animating && params.preventInteractionOnTransition) {
3297      return;
3298    }
3299    var e = event;
3300    if (e.originalEvent) {
3301      e = e.originalEvent;
3302    }
3303    data.isTouchEvent = e.type === 'touchstart';
3304    if (!data.isTouchEvent && 'which' in e && e.which === 3) {
3305      return;
3306    }
3307    if (data.isTouched && data.isMoved) {
3308      return;
3309    }
3310    if (
3311      params.noSwiping &&
3312      $(e.target).closest(
3313        params.noSwipingSelector
3314          ? params.noSwipingSelector
3315          : '.' + params.noSwipingClass
3316      )[0]
3317    ) {
3318      swiper.allowClick = true;
3319      return;
3320    }
3321    if (params.swipeHandler) {
3322      if (!$(e).closest(params.swipeHandler)[0]) {
3323        return;
3324      }
3325    }
3326
3327    touches.currentX =
3328      e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
3329    touches.currentY =
3330      e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
3331    var startX = touches.currentX;
3332    var startY = touches.currentY;
3333
3334    // Do NOT start if iOS edge swipe is detected. Otherwise iOS app (UIWebView) cannot swipe-to-go-back anymore
3335
3336    var edgeSwipeDetection =
3337      params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
3338    var edgeSwipeThreshold =
3339      params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
3340    if (
3341      edgeSwipeDetection &&
3342      (startX <= edgeSwipeThreshold ||
3343        startX >= win.screen.width - edgeSwipeThreshold)
3344    ) {
3345      return;
3346    }
3347
3348    Utils.extend(data, {
3349      isTouched: true,
3350      isMoved: false,
3351      allowTouchCallbacks: true,
3352      isScrolling: undefined,
3353      startMoving: undefined,
3354    });
3355
3356    touches.startX = startX;
3357    touches.startY = startY;
3358    data.touchStartTime = Utils.now();
3359    swiper.allowClick = true;
3360    swiper.updateSize();
3361    swiper.swipeDirection = undefined;
3362    if (params.threshold > 0) {
3363      data.allowThresholdMove = false;
3364    }
3365    if (e.type !== 'touchstart') {
3366      var preventDefault = true;
3367      if ($(e.target).is(data.formElements)) {
3368        preventDefault = false;
3369      }
3370      if (
3371        doc.activeElement &&
3372        $(doc.activeElement).is(data.formElements) &&
3373        doc.activeElement !== e.target
3374      ) {
3375        doc.activeElement.blur();
3376      }
3377      if (preventDefault && swiper.allowTouchMove) {
3378        e.preventDefault();
3379      }
3380    }
3381    swiper.emit('touchStart', e);
3382  }
3383
3384  function onTouchMove(event) {
3385    var swiper = this;
3386    var data = swiper.touchEventsData;
3387    var params = swiper.params;
3388    var touches = swiper.touches;
3389    var rtl = swiper.rtlTranslate;
3390    var e = event;
3391    if (e.originalEvent) {
3392      e = e.originalEvent;
3393    }
3394    if (!data.isTouched) {
3395      if (data.startMoving && data.isScrolling) {
3396        swiper.emit('touchMoveOpposite', e);
3397      }
3398      return;
3399    }
3400    if (data.isTouchEvent && e.type === 'mousemove') {
3401      return;
3402    }
3403    var pageX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
3404    var pageY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
3405    if (e.preventedByNestedSwiper) {
3406      touches.startX = pageX;
3407      touches.startY = pageY;
3408      return;
3409    }
3410    if (!swiper.allowTouchMove) {
3411      // isMoved = true;
3412      swiper.allowClick = false;
3413      if (data.isTouched) {
3414        Utils.extend(touches, {
3415          startX: pageX,
3416          startY: pageY,
3417          currentX: pageX,
3418          currentY: pageY,
3419        });
3420        data.touchStartTime = Utils.now();
3421      }
3422      return;
3423    }
3424    if (data.isTouchEvent && params.touchReleaseOnEdges && !params.loop) {
3425      if (swiper.isVertical()) {
3426        // Vertical
3427        if (
3428          (pageY < touches.startY &&
3429            swiper.translate <= swiper.maxTranslate()) ||
3430          (pageY > touches.startY &&
3431            swiper.translate >= swiper.minTranslate())
3432        ) {
3433          data.isTouched = false;
3434          data.isMoved = false;
3435          return;
3436        }
3437      } else if (
3438        (pageX < touches.startX &&
3439          swiper.translate <= swiper.maxTranslate()) ||
3440        (pageX > touches.startX &&
3441          swiper.translate >= swiper.minTranslate())
3442      ) {
3443        return;
3444      }
3445    }
3446    if (data.isTouchEvent && doc.activeElement) {
3447      if (
3448        e.target === doc.activeElement &&
3449        $(e.target).is(data.formElements)
3450      ) {
3451        data.isMoved = true;
3452        swiper.allowClick = false;
3453        return;
3454      }
3455    }
3456    if (data.allowTouchCallbacks) {
3457      swiper.emit('touchMove', e);
3458    }
3459    if (e.targetTouches && e.targetTouches.length > 1) {
3460      return;
3461    }
3462
3463    touches.currentX = pageX;
3464    touches.currentY = pageY;
3465
3466    var diffX = touches.currentX - touches.startX;
3467    var diffY = touches.currentY - touches.startY;
3468    if (
3469      swiper.params.threshold &&
3470      Math.sqrt(Math.pow(diffX, 2) + Math.pow(diffY, 2)) <
3471      swiper.params.threshold
3472    ) {
3473      return;
3474    }
3475
3476    if (typeof data.isScrolling === 'undefined') {
3477      var touchAngle;
3478      if (
3479        (swiper.isHorizontal() &&
3480          touches.currentY === touches.startY) ||
3481        (swiper.isVertical() && touches.currentX === touches.startX)
3482      ) {
3483        data.isScrolling = false;
3484      } else {
3485        // eslint-disable-next-line
3486        if (diffX * diffX + diffY * diffY >= 25) {
3487          touchAngle =
3488            (Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180) /
3489            Math.PI;
3490          data.isScrolling = swiper.isHorizontal()
3491            ? touchAngle > params.touchAngle
3492            : 90 - touchAngle > params.touchAngle;
3493        }
3494      }
3495    }
3496    if (data.isScrolling) {
3497      swiper.emit('touchMoveOpposite', e);
3498    }
3499    if (typeof data.startMoving === 'undefined') {
3500      if (
3501        touches.currentX !== touches.startX ||
3502        touches.currentY !== touches.startY
3503      ) {
3504        data.startMoving = true;
3505      }
3506    }
3507    if (data.isScrolling) {
3508      data.isTouched = false;
3509      return;
3510    }
3511    if (!data.startMoving) {
3512      return;
3513    }
3514    swiper.allowClick = false;
3515    e.preventDefault();
3516    if (params.touchMoveStopPropagation && !params.nested) {
3517      e.stopPropagation();
3518    }
3519
3520    if (!data.isMoved) {
3521      if (params.loop) {
3522        swiper.loopFix();
3523      }
3524      data.startTranslate = swiper.getTranslate();
3525      swiper.setTransition(0);
3526      if (swiper.animating) {
3527        swiper.$wrapperEl.trigger('webkitTransitionEnd transitionend');
3528      }
3529      data.allowMomentumBounce = false;
3530      // Grab Cursor
3531      if (
3532        params.grabCursor &&
3533        (swiper.allowSlideNext === true ||
3534          swiper.allowSlidePrev === true)
3535      ) {
3536        swiper.setGrabCursor(true);
3537      }
3538      swiper.emit('sliderFirstMove', e);
3539    }
3540    swiper.emit('sliderMove', e);
3541    data.isMoved = true;
3542
3543    var diff = swiper.isHorizontal() ? diffX : diffY;
3544    touches.diff = diff;
3545
3546    diff *= params.touchRatio;
3547    if (rtl) {
3548      diff = -diff;
3549    }
3550
3551    swiper.swipeDirection = diff > 0 ? 'prev' : 'next';
3552    data.currentTranslate = diff + data.startTranslate;
3553
3554    var disableParentSwiper = true;
3555    var resistanceRatio = params.resistanceRatio;
3556    if (params.touchReleaseOnEdges) {
3557      resistanceRatio = 0;
3558    }
3559    if (diff > 0 && data.currentTranslate > swiper.minTranslate()) {
3560      disableParentSwiper = false;
3561      if (params.resistance) {
3562        data.currentTranslate =
3563          swiper.minTranslate() -
3564          1 +
3565          Math.pow(
3566            -swiper.minTranslate() + data.startTranslate + diff,
3567            resistanceRatio
3568          );
3569      }
3570    } else if (diff < 0 && data.currentTranslate < swiper.maxTranslate()) {
3571      disableParentSwiper = false;
3572      if (params.resistance) {
3573        data.currentTranslate =
3574          swiper.maxTranslate() +
3575          1 -
3576          Math.pow(
3577            swiper.maxTranslate() - data.startTranslate - diff,
3578            resistanceRatio
3579          );
3580      }
3581    }
3582
3583    if (disableParentSwiper) {
3584      e.preventedByNestedSwiper = true;
3585    }
3586
3587    // Directions locks
3588    if (
3589      !swiper.allowSlideNext &&
3590      swiper.swipeDirection === 'next' &&
3591      data.currentTranslate < data.startTranslate
3592    ) {
3593      data.currentTranslate = data.startTranslate;
3594    }
3595    if (
3596      !swiper.allowSlidePrev &&
3597      swiper.swipeDirection === 'prev' &&
3598      data.currentTranslate > data.startTranslate
3599    ) {
3600      data.currentTranslate = data.startTranslate;
3601    }
3602
3603    // Threshold
3604    if (params.threshold > 0) {
3605      if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
3606        if (!data.allowThresholdMove) {
3607          data.allowThresholdMove = true;
3608          touches.startX = touches.currentX;
3609          touches.startY = touches.currentY;
3610          data.currentTranslate = data.startTranslate;
3611          touches.diff = swiper.isHorizontal()
3612            ? touches.currentX - touches.startX
3613            : touches.currentY - touches.startY;
3614          return;
3615        }
3616      } else {
3617        data.currentTranslate = data.startTranslate;
3618        return;
3619      }
3620    }
3621
3622    if (!params.followFinger) {
3623      return;
3624    }
3625
3626    // Update active index in free mode
3627    if (
3628      params.freeMode ||
3629      params.watchSlidesProgress ||
3630      params.watchSlidesVisibility
3631    ) {
3632      swiper.updateActiveIndex();
3633      swiper.updateSlidesClasses();
3634    }
3635    if (params.freeMode) {
3636      // Velocity
3637      if (data.velocities.length === 0) {
3638        data.velocities.push({
3639          position:
3640            touches[swiper.isHorizontal() ? 'startX' : 'startY'],
3641          time: data.touchStartTime,
3642        });
3643      }
3644      data.velocities.push({
3645        position:
3646          touches[swiper.isHorizontal() ? 'currentX' : 'currentY'],
3647        time: Utils.now(),
3648      });
3649    }
3650    // Update progress
3651    swiper.updateProgress(data.currentTranslate);
3652    // Update translate
3653    swiper.setTranslate(data.currentTranslate);
3654  }
3655
3656  function onTouchEnd(event) {
3657    var swiper = this;
3658    var data = swiper.touchEventsData;
3659
3660    var params = swiper.params;
3661    var touches = swiper.touches;
3662    var rtl = swiper.rtlTranslate;
3663    var $wrapperEl = swiper.$wrapperEl;
3664    var slidesGrid = swiper.slidesGrid;
3665    var snapGrid = swiper.snapGrid;
3666    var e = event;
3667    if (e.originalEvent) {
3668      e = e.originalEvent;
3669    }
3670    if (data.allowTouchCallbacks) {
3671      swiper.emit('touchEnd', e);
3672    }
3673    data.allowTouchCallbacks = false;
3674    if (!data.isTouched) {
3675      if (data.isMoved && params.grabCursor) {
3676        swiper.setGrabCursor(false);
3677      }
3678      data.isMoved = false;
3679      data.startMoving = false;
3680      return;
3681    }
3682    // Return Grab Cursor
3683    if (
3684      params.grabCursor &&
3685      data.isMoved &&
3686      data.isTouched &&
3687      (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)
3688    ) {
3689      swiper.setGrabCursor(false);
3690    }
3691
3692    // Time diff
3693    var touchEndTime = Utils.now();
3694    var timeDiff = touchEndTime - data.touchStartTime;
3695
3696    // Tap, doubleTap, Click
3697    if (swiper.allowClick) {
3698      swiper.updateClickedSlide(e);
3699      swiper.emit('tap', e);
3700      if (timeDiff < 300 && touchEndTime - data.lastClickTime > 300) {
3701        if (data.clickTimeout) {
3702          clearTimeout(data.clickTimeout);
3703        }
3704        data.clickTimeout = Utils.nextTick(function () {
3705          if (!swiper || swiper.destroyed) {
3706            return;
3707          }
3708          swiper.emit('click', e);
3709        }, 300);
3710      }
3711      if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {
3712        if (data.clickTimeout) {
3713          clearTimeout(data.clickTimeout);
3714        }
3715        swiper.emit('doubleTap', e);
3716      }
3717    }
3718
3719    data.lastClickTime = Utils.now();
3720    Utils.nextTick(function () {
3721      if (!swiper.destroyed) {
3722        swiper.allowClick = true;
3723      }
3724    });
3725
3726    if (
3727      !data.isTouched ||
3728      !data.isMoved ||
3729      !swiper.swipeDirection ||
3730      touches.diff === 0 ||
3731      data.currentTranslate === data.startTranslate
3732    ) {
3733      data.isTouched = false;
3734      data.isMoved = false;
3735      data.startMoving = false;
3736      return;
3737    }
3738    data.isTouched = false;
3739    data.isMoved = false;
3740    data.startMoving = false;
3741
3742    var currentPos;
3743    if (params.followFinger) {
3744      currentPos = rtl ? swiper.translate : -swiper.translate;
3745    } else {
3746      currentPos = -data.currentTranslate;
3747    }
3748
3749    if (params.freeMode) {
3750      if (currentPos < -swiper.minTranslate()) {
3751        swiper.slideTo(swiper.activeIndex);
3752        return;
3753      }
3754      if (currentPos > -swiper.maxTranslate()) {
3755        if (swiper.slides.length < snapGrid.length) {
3756          swiper.slideTo(snapGrid.length - 1);
3757        } else {
3758          swiper.slideTo(swiper.slides.length - 1);
3759        }
3760        return;
3761      }
3762
3763      if (params.freeModeMomentum) {
3764        if (data.velocities.length > 1) {
3765          var lastMoveEvent = data.velocities.pop();
3766          var velocityEvent = data.velocities.pop();
3767
3768          var distance =
3769            lastMoveEvent.position - velocityEvent.position;
3770          var time = lastMoveEvent.time - velocityEvent.time;
3771          swiper.velocity = distance / time;
3772          swiper.velocity /= 2;
3773          if (
3774            Math.abs(swiper.velocity) <
3775            params.freeModeMinimumVelocity
3776          ) {
3777            swiper.velocity = 0;
3778          }
3779          // this implies that the user stopped moving a finger then released.
3780          // There would be no events with distance zero, so the last event is stale.
3781          if (time > 150 || Utils.now() - lastMoveEvent.time > 300) {
3782            swiper.velocity = 0;
3783          }
3784        } else {
3785          swiper.velocity = 0;
3786        }
3787        swiper.velocity *= params.freeModeMomentumVelocityRatio;
3788
3789        data.velocities.length = 0;
3790        var momentumDuration = 1000 * params.freeModeMomentumRatio;
3791        var momentumDistance = swiper.velocity * momentumDuration;
3792
3793        var newPosition = swiper.translate + momentumDistance;
3794        if (rtl) {
3795          newPosition = -newPosition;
3796        }
3797
3798        var doBounce = false;
3799        var afterBouncePosition;
3800        var bounceAmount =
3801          Math.abs(swiper.velocity) *
3802          20 *
3803          params.freeModeMomentumBounceRatio;
3804        var needsLoopFix;
3805        if (newPosition < swiper.maxTranslate()) {
3806          if (params.freeModeMomentumBounce) {
3807            if (
3808              newPosition + swiper.maxTranslate() <
3809              -bounceAmount
3810            ) {
3811              newPosition = swiper.maxTranslate() - bounceAmount;
3812            }
3813            afterBouncePosition = swiper.maxTranslate();
3814            doBounce = true;
3815            data.allowMomentumBounce = true;
3816          } else {
3817            newPosition = swiper.maxTranslate();
3818          }
3819          if (params.loop && params.centeredSlides) {
3820            needsLoopFix = true;
3821          }
3822        } else if (newPosition > swiper.minTranslate()) {
3823          if (params.freeModeMomentumBounce) {
3824            if (
3825              newPosition - swiper.minTranslate() >
3826              bounceAmount
3827            ) {
3828              newPosition = swiper.minTranslate() + bounceAmount;
3829            }
3830            afterBouncePosition = swiper.minTranslate();
3831            doBounce = true;
3832            data.allowMomentumBounce = true;
3833          } else {
3834            newPosition = swiper.minTranslate();
3835          }
3836          if (params.loop && params.centeredSlides) {
3837            needsLoopFix = true;
3838          }
3839        } else if (params.freeModeSticky) {
3840          var nextSlide;
3841          for (var j = 0; j < snapGrid.length; j += 1) {
3842            if (snapGrid[j] > -newPosition) {
3843              nextSlide = j;
3844              break;
3845            }
3846          }
3847
3848          if (
3849            Math.abs(snapGrid[nextSlide] - newPosition) <
3850            Math.abs(snapGrid[nextSlide - 1] - newPosition) ||
3851            swiper.swipeDirection === 'next'
3852          ) {
3853            newPosition = snapGrid[nextSlide];
3854          } else {
3855            newPosition = snapGrid[nextSlide - 1];
3856          }
3857          newPosition = -newPosition;
3858        }
3859        if (needsLoopFix) {
3860          swiper.once('transitionEnd', function () {
3861            swiper.loopFix();
3862          });
3863        }
3864        // Fix duration
3865        if (swiper.velocity !== 0) {
3866          if (rtl) {
3867            momentumDuration = Math.abs(
3868              (-newPosition - swiper.translate) / swiper.velocity
3869            );
3870          } else {
3871            momentumDuration = Math.abs(
3872              (newPosition - swiper.translate) / swiper.velocity
3873            );
3874          }
3875        } else if (params.freeModeSticky) {
3876          swiper.slideToClosest();
3877          return;
3878        }
3879
3880        if (params.freeModeMomentumBounce && doBounce) {
3881          swiper.updateProgress(afterBouncePosition);
3882          swiper.setTransition(momentumDuration);
3883          swiper.setTranslate(newPosition);
3884          swiper.transitionStart(true, swiper.swipeDirection);
3885          swiper.animating = true;
3886          $wrapperEl.transitionEnd(function () {
3887            if (
3888              !swiper ||
3889              swiper.destroyed ||
3890              !data.allowMomentumBounce
3891            ) {
3892              return;
3893            }
3894            swiper.emit('momentumBounce');
3895
3896            swiper.setTransition(params.speed);
3897            swiper.setTranslate(afterBouncePosition);
3898            $wrapperEl.transitionEnd(function () {
3899              if (!swiper || swiper.destroyed) {
3900                return;
3901              }
3902              swiper.transitionEnd();
3903            });
3904          });
3905        } else if (swiper.velocity) {
3906          swiper.updateProgress(newPosition);
3907          swiper.setTransition(momentumDuration);
3908          swiper.setTranslate(newPosition);
3909          swiper.transitionStart(true, swiper.swipeDirection);
3910          if (!swiper.animating) {
3911            swiper.animating = true;
3912            $wrapperEl.transitionEnd(function () {
3913              if (!swiper || swiper.destroyed) {
3914                return;
3915              }
3916              swiper.transitionEnd();
3917            });
3918          }
3919        } else {
3920          swiper.updateProgress(newPosition);
3921        }
3922
3923        swiper.updateActiveIndex();
3924        swiper.updateSlidesClasses();
3925      } else if (params.freeModeSticky) {
3926        swiper.slideToClosest();
3927        return;
3928      }
3929
3930      if (!params.freeModeMomentum || timeDiff >= params.longSwipesMs) {
3931        swiper.updateProgress();
3932        swiper.updateActiveIndex();
3933        swiper.updateSlidesClasses();
3934      }
3935      return;
3936    }
3937
3938    // Find current slide
3939    var stopIndex = 0;
3940    var groupSize = swiper.slidesSizesGrid[0];
3941    for (var i = 0; i < slidesGrid.length; i += params.slidesPerGroup) {
3942      if (typeof slidesGrid[i + params.slidesPerGroup] !== 'undefined') {
3943        if (
3944          currentPos >= slidesGrid[i] &&
3945          currentPos < slidesGrid[i + params.slidesPerGroup]
3946        ) {
3947          stopIndex = i;
3948          groupSize =
3949            slidesGrid[i + params.slidesPerGroup] - slidesGrid[i];
3950        }
3951      } else if (currentPos >= slidesGrid[i]) {
3952        stopIndex = i;
3953        groupSize =
3954          slidesGrid[slidesGrid.length - 1] -
3955          slidesGrid[slidesGrid.length - 2];
3956      }
3957    }
3958
3959    // Find current slide size
3960    var ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;
3961
3962    if (timeDiff > params.longSwipesMs) {
3963      // Long touches
3964      if (!params.longSwipes) {
3965        swiper.slideTo(swiper.activeIndex);
3966        return;
3967      }
3968      if (swiper.swipeDirection === 'next') {
3969        if (ratio >= params.longSwipesRatio) {
3970          swiper.slideTo(stopIndex + params.slidesPerGroup);
3971        } else {
3972          swiper.slideTo(stopIndex);
3973        }
3974      }
3975      if (swiper.swipeDirection === 'prev') {
3976        if (ratio > 1 - params.longSwipesRatio) {
3977          swiper.slideTo(stopIndex + params.slidesPerGroup);
3978        } else {
3979          swiper.slideTo(stopIndex);
3980        }
3981      }
3982    } else {
3983      // Short swipes
3984      if (!params.shortSwipes) {
3985        swiper.slideTo(swiper.activeIndex);
3986        return;
3987      }
3988      if (swiper.swipeDirection === 'next') {
3989        swiper.slideTo(stopIndex + params.slidesPerGroup);
3990      }
3991      if (swiper.swipeDirection === 'prev') {
3992        swiper.slideTo(stopIndex);
3993      }
3994    }
3995  }
3996
3997  function onResize() {
3998    var swiper = this;
3999
4000    var params = swiper.params;
4001    var el = swiper.el;
4002
4003    if (el && el.offsetWidth === 0) {
4004      return;
4005    }
4006
4007    // Breakpoints
4008    if (params.breakpoints) {
4009      swiper.setBreakpoint();
4010    }
4011
4012    // Save locks
4013    var allowSlideNext = swiper.allowSlideNext;
4014    var allowSlidePrev = swiper.allowSlidePrev;
4015    var snapGrid = swiper.snapGrid;
4016
4017    // Disable locks on resize
4018    swiper.allowSlideNext = true;
4019    swiper.allowSlidePrev = true;
4020
4021    swiper.updateSize();
4022    swiper.updateSlides();
4023
4024    if (params.freeMode) {
4025      var newTranslate = Math.min(
4026        Math.max(swiper.translate, swiper.maxTranslate()),
4027        swiper.minTranslate()
4028      );
4029      swiper.setTranslate(newTranslate);
4030      swiper.updateActiveIndex();
4031      swiper.updateSlidesClasses();
4032
4033      if (params.autoHeight) {
4034        swiper.updateAutoHeight();
4035      }
4036    } else {
4037      swiper.updateSlidesClasses();
4038      if (
4039        (params.slidesPerView === 'auto' || params.slidesPerView > 1) &&
4040        swiper.isEnd &&
4041        !swiper.params.centeredSlides
4042      ) {
4043        swiper.slideTo(swiper.slides.length - 1, 0, false, true);
4044      } else {
4045        swiper.slideTo(swiper.activeIndex, 0, false, true);
4046      }
4047    }
4048    // Return locks after resize
4049    swiper.allowSlidePrev = allowSlidePrev;
4050    swiper.allowSlideNext = allowSlideNext;
4051
4052    if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {
4053      swiper.checkOverflow();
4054    }
4055  }
4056
4057  function onClick(e) {
4058    var swiper = this;
4059    if (!swiper.allowClick) {
4060      if (swiper.params.preventClicks) {
4061        e.preventDefault();
4062      }
4063      if (swiper.params.preventClicksPropagation && swiper.animating) {
4064        e.stopPropagation();
4065        e.stopImmediatePropagation();
4066      }
4067    }
4068  }
4069
4070  function attachEvents() {
4071    var swiper = this;
4072    var params = swiper.params;
4073    var touchEvents = swiper.touchEvents;
4074    var el = swiper.el;
4075    var wrapperEl = swiper.wrapperEl;
4076
4077    {
4078      swiper.onTouchStart = onTouchStart.bind(swiper);
4079      swiper.onTouchMove = onTouchMove.bind(swiper);
4080      swiper.onTouchEnd = onTouchEnd.bind(swiper);
4081    }
4082
4083    swiper.onClick = onClick.bind(swiper);
4084
4085    var target = params.touchEventsTarget === 'container' ? el : wrapperEl;
4086    var capture = !!params.nested;
4087
4088    // Touch Events
4089    {
4090      if (
4091        !Support.touch &&
4092        (Support.pointerEvents || Support.prefixedPointerEvents)
4093      ) {
4094        target.addEventListener(
4095          touchEvents.start,
4096          swiper.onTouchStart,
4097          false
4098        );
4099        doc.addEventListener(
4100          touchEvents.move,
4101          swiper.onTouchMove,
4102          capture
4103        );
4104        doc.addEventListener(touchEvents.end, swiper.onTouchEnd, false);
4105      } else {
4106        if (Support.touch) {
4107          var passiveListener =
4108            touchEvents.start === 'touchstart' &&
4109            Support.passiveListener &&
4110            params.passiveListeners
4111              ? { passive: true, capture: false }
4112              : false;
4113          target.addEventListener(
4114            touchEvents.start,
4115            swiper.onTouchStart,
4116            passiveListener
4117          );
4118          target.addEventListener(
4119            touchEvents.move,
4120            swiper.onTouchMove,
4121            Support.passiveListener
4122              ? { passive: false, capture: capture }
4123              : capture
4124          );
4125          target.addEventListener(
4126            touchEvents.end,
4127            swiper.onTouchEnd,
4128            passiveListener
4129          );
4130        }
4131        if (
4132          (params.simulateTouch && !Device.ios && !Device.android) ||
4133          (params.simulateTouch && !Support.touch && Device.ios)
4134        ) {
4135          target.addEventListener(
4136            'mousedown',
4137            swiper.onTouchStart,
4138            false
4139          );
4140          doc.addEventListener(
4141            'mousemove',
4142            swiper.onTouchMove,
4143            capture
4144          );
4145          doc.addEventListener('mouseup', swiper.onTouchEnd, false);
4146        }
4147      }
4148      // Prevent Links Clicks
4149      if (params.preventClicks || params.preventClicksPropagation) {
4150        target.addEventListener('click', swiper.onClick, true);
4151      }
4152    }
4153
4154    // Resize handler
4155    swiper.on(
4156      Device.ios || Device.android
4157        ? 'resize orientationchange observerUpdate'
4158        : 'resize observerUpdate',
4159      onResize,
4160      true
4161    );
4162  }
4163
4164  function detachEvents() {
4165    var swiper = this;
4166
4167    var params = swiper.params;
4168    var touchEvents = swiper.touchEvents;
4169    var el = swiper.el;
4170    var wrapperEl = swiper.wrapperEl;
4171
4172    var target = params.touchEventsTarget === 'container' ? el : wrapperEl;
4173    var capture = !!params.nested;
4174
4175    // Touch Events
4176    {
4177      if (
4178        !Support.touch &&
4179        (Support.pointerEvents || Support.prefixedPointerEvents)
4180      ) {
4181        target.removeEventListener(
4182          touchEvents.start,
4183          swiper.onTouchStart,
4184          false
4185        );
4186        doc.removeEventListener(
4187          touchEvents.move,
4188          swiper.onTouchMove,
4189          capture
4190        );
4191        doc.removeEventListener(
4192          touchEvents.end,
4193          swiper.onTouchEnd,
4194          false
4195        );
4196      } else {
4197        if (Support.touch) {
4198          var passiveListener =
4199            touchEvents.start === 'onTouchStart' &&
4200            Support.passiveListener &&
4201            params.passiveListeners
4202              ? { passive: true, capture: false }
4203              : false;