https://waldoswonders-project-id.web.app/build/swiper/swiper.bundle.js

1/**
2 * SSR Window 2.0.0
3 * Better handling for window object in SSR environment
4 * https://github.com/nolimits4web/ssr-window
5 *
6 * Copyright 2020, Vladimir Kharlampidi
7 *
8 * Licensed under MIT
9 *
10 * Released on: May 12, 2020
11 */
12/* eslint-disable no-param-reassign */
13function isObject(obj) {
14    return (obj !== null &&
15        typeof obj === 'object' &&
16        'constructor' in obj &&
17        obj.constructor === Object);
18}
19function extend(target, src) {
20    if (target === void 0) { target = {}; }
21    if (src === void 0) { src = {}; }
22    Object.keys(src).forEach(function (key) {
23        if (typeof target[key] === 'undefined')
24            target[key] = src[key];
25        else if (isObject(src[key]) &&
26            isObject(target[key]) &&
27            Object.keys(src[key]).length > 0) {
28            extend(target[key], src[key]);
29        }
30    });
31}
32
33var doc = typeof document !== 'undefined' ? document : {};
34var ssrDocument = {
35    body: {},
36    addEventListener: function () { },
37    removeEventListener: function () { },
38    activeElement: {
39        blur: function () { },
40        nodeName: '',
41    },
42    querySelector: function () {
43        return null;
44    },
45    querySelectorAll: function () {
46        return [];
47    },
48    getElementById: function () {
49        return null;
50    },
51    createEvent: function () {
52        return {
53            initEvent: function () { },
54        };
55    },
56    createElement: function () {
57        return {
58            children: [],
59            childNodes: [],
60            style: {},
61            setAttribute: function () { },
62            getElementsByTagName: function () {
63                return [];
64            },
65        };
66    },
67    createElementNS: function () {
68        return {};
69    },
70    importNode: function () {
71        return null;
72    },
73    location: {
74        hash: '',
75        host: '',
76        hostname: '',
77        href: '',
78        origin: '',
79        pathname: '',
80        protocol: '',
81        search: '',
82    },
83};
84extend(doc, ssrDocument);
85
86var win = typeof window !== 'undefined' ? window : {};
87var ssrWindow = {
88    document: ssrDocument,
89    navigator: {
90        userAgent: '',
91    },
92    location: {
93        hash: '',
94        host: '',
95        hostname: '',
96        href: '',
97        origin: '',
98        pathname: '',
99        protocol: '',
100        search: '',
101    },
102    history: {
103        replaceState: function () { },
104        pushState: function () { },
105        go: function () { },
106        back: function () { },
107    },
108    CustomEvent: function CustomEvent() {
109        return this;
110    },
111    addEventListener: function () { },
112    removeEventListener: function () { },
113    getComputedStyle: function () {
114        return {
115            getPropertyValue: function () {
116                return '';
117            },
118        };
119    },
120    Image: function () { },
121    Date: function () { },
122    screen: {},
123    setTimeout: function () { },
124    clearTimeout: function () { },
125    matchMedia: function () {
126        return {};
127    },
128};
129extend(win, ssrWindow);
130
131/**
132 * Dom7 2.1.5
133 * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API
134 * http://framework7.io/docs/dom.html
135 *
136 * Copyright 2020, Vladimir Kharlampidi
137 * The iDangero.us
138 * http://www.idangero.us/
139 *
140 * Licensed under MIT
141 *
142 * Released on: May 15, 2020

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

8334.1
834 * Most modern mobile touch slider and framework with hardware accelerated transitions
835 * http://swiperjs.com
836 *
837 * Copyright 2014-2020 Vladimir Kharlampidi
838 *
839 * Released under the MIT License
840 *
841 * Released on: May 20, 2020
842 */
843
844const Methods = {
845  addClass,
846  removeClass,
847  hasClass,
848  toggleClass,
849  attr,
850  removeAttr,
851  data,
852  transform,
853  transition: transition,
854  on,
855  off,
856  trigger,
857  transitionEnd: transitionEnd,
858  outerWidth,
859  outerHeight,
860  offset,
861  css,
862  each,
863  html,
864  text,
865  is,
866  index,
867  eq,
868  append,
869  prepend,
870  next,
871  nextAll,
872  prev,
873  prevAll,
874  parent,
875  parents,
876  closest,
877  find,
878  children,
879  filter,
880  remove,
881  add,
882  styles,
883};
884
885Object.keys(Methods).forEach((methodName) => {
886  $.fn[methodName] = $.fn[methodName] || Methods[methodName];
887});
888
889const Utils = {
890  deleteProps(obj) {
891    const object = obj;
892    Object.keys(object).forEach((key) => {
893      try {
894        object[key] = null;
895      } catch (e) {
896        // no getter for object
897      }
898      try {
899        delete object[key];
900      } catch (e) {
901        // something got wrong
902      }
903    });
904  },
905  nextTick(callback, delay = 0) {
906    return setTimeout(callback, delay);
907  },
908  now() {
909    return Date.now();
910  },
911  getTranslate(el, axis = 'x') {
912    let matrix;
913    let curTransform;
914    let transformMatrix;
915
916    const curStyle = win.getComputedStyle(el, null);
917
918    if (win.WebKitCSSMatrix) {
919      curTransform = curStyle.transform || curStyle.webkitTransform;
920      if (curTransform.split(',').length > 6) {
921        curTransform = curTransform.split(', ').map((a) => a.replace(',', '.')).join(', ');
922      }
923      // Some old versions of Webkit choke when 'none' is passed; pass
924      // empty string instead in this case
925      transformMatrix = new win.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
926    } else {
927      transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
928      matrix = transformMatrix.toString().split(',');
929    }
930
931    if (axis === 'x') {
932      // Latest Chrome and webkits Fix
933      if (win.WebKitCSSMatrix) curTransform = transformMatrix.m41;
934      // Crazy IE10 Matrix
935      else if (matrix.length === 16) curTransform = parseFloat(matrix[12]);
936      // Normal Browsers
937      else curTransform = parseFloat(matrix[4]);
938    }
939    if (axis === 'y') {
940      // Latest Chrome and webkits Fix
941      if (win.WebKitCSSMatrix) curTransform = transformMatrix.m42;
942      // Crazy IE10 Matrix
943      else if (matrix.length === 16) curTransform = parseFloat(matrix[13]);
944      // Normal Browsers
945      else curTransform = parseFloat(matrix[5]);
946    }
947    return curTransform || 0;
948  },
949  parseUrlQuery(url) {
950    const query = {};
951    let urlToParse = url || win.location.href;
952    let i;
953    let params;
954    let param;
955    let length;
956    if (typeof urlToParse === 'string' && urlToParse.length) {
957      urlToParse = urlToParse.indexOf('?') > -1 ? urlToParse.replace(/\S*\?/, '') : '';
958      params = urlToParse.split('&').filter((paramsPart) => paramsPart !== '');
959      length = params.length;
960
961      for (i = 0; i < length; i += 1) {
962        param = params[i].replace(/#\S+/g, '').split('=');
963        query[decodeURIComponent(param[0])] = typeof param[1] === 'undefined' ? undefined : decodeURIComponent(param[1]) || '';
964      }
965    }
966    return query;
967  },
968  isObject(o) {
969    return typeof o === 'object' && o !== null && o.constructor && o.constructor === Object;
970  },
971  extend(...args) {
972    const to = Object(args[0]);
973    for (let i = 1; i < args.length; i += 1) {
974      const nextSource = args[i];
975      if (nextSource !== undefined && nextSource !== null) {

1001 0,
1002
1003    observer: (function checkObserver() {
1004      return ('MutationObserver' in win || 'WebkitMutationObserver' in win);
1005    }()),
1006
1007    passiveListener: (function checkPassiveListener() {
1008      let supportsPassive = false;
1009      try {
1010        const opts = Object.defineProperty({}, 'passive', {
1011          // eslint-disable-next-line
1012          get() {
1013            supportsPassive = true;
1014          },
1015        });
1016        win.addEventListener('testPassiveListener', null, opts);
1017      } catch (e) {
1018        // No support
1019      }
1020      return supportsPassive;
1021    }()),
1022
1023    gestures: (function checkGestures() {
1024      return 'ongesturestart' in win;
1025    }()),
1026  };
1027}());
1028
1029class SwiperClass {
1030  constructor(params = {}) {
1031    const self = this;
1032    self.params = params;
1033
1034    // Events
1035    self.eventsListeners = {};
1036
1037    if (self.params && self.params.on) {
1038      Object.keys(self.params.on).forEach((eventName) => {
1039        self.on(eventName, self.params.on[eventName]);
1040      });
1041    }
1042  }
1043
1044  on(events, handler, priority) {
1045    const self = this;
1046    if (typeof handler !== 'function') return self;
1047    const method = priority ? 'unshift' : 'push';
1048    events.split(' ').forEach((event) => {
1049      if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
1050      self.eventsListeners[event][method](handler);
1051    });
1052    return self;
1053  }
1054
1055  once(events, handler, priority) {
1056    const self = this;
1057    if (typeof handler !== 'function') return self;
1058    function onceHandler(...args) {
1059      self.off(events, onceHandler);
1060      if (onceHandler.f7proxy) {
1061        delete onceHandler.f7proxy;
1062      }
1063      handler.apply(self, args);
1064    }
1065    onceHandler.f7proxy = handler;
1066    return self.on(events, onceHandler, priority);
1067  }
1068
1069  off(events, handler) {
1070    const self = this;
1071    if (!self.eventsListeners) return self;
1072    events.split(' ').forEach((event) => {
1073      if (typeof handler === 'undefined') {
1074        self.eventsListeners[event] = [];
1075      } else if (self.eventsListeners[event] && self.eventsListeners[event].length) {
1076        self.eventsListeners[event].forEach((eventHandler, index) => {
1077          if (eventHandler === handler || (eventHandler.f7proxy && eventHandler.f7proxy === handler)) {
1078            self.eventsListeners[event].splice(index, 1);
1079          }
1080        });
1081      }
1082    });
1083    return self;
1084  }
1085
1086  emit(...args) {
1087    const self = this;
1088    if (!self.eventsListeners) return self;
1089    let events;
1090    let data;
1091    let context;
1092    if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1093      events = args[0];
1094      data = args.slice(1, args.length);
1095      context = self;
1096    } else {
1097      events = args[0].events;
1098      data = args[0].data;
1099      context = args[0].context || self;
1100    }
1101    const eventsArray = Array.isArray(events) ? events : events.split(' ');
1102    eventsArray.forEach((event) => {
1103      if (self.eventsListeners && self.eventsListeners[event]) {
1104        const handlers = [];
1105        self.eventsListeners[event].forEach((eventHandler) => {
1106          handlers.push(eventHandler);
1107        });
1108        handlers.forEach((eventHandler) => {
1109          eventHandler.apply(context, data);
1110        });
1111      }
1112    });
1113    return self;
1114  }
1115
1116  useModulesParams(instanceParams) {
1117    const instance = this;
1118    if (!instance.modules) return;
1119    Object.keys(instance.modules).forEach((moduleName) => {
1120      const module = instance.modules[moduleName];
1121      // Extend params
1122      if (module.params) {
1123        Utils.extend(instanceParams, module.params);
1124      }
1125    });
1126  }
1127
1128  useModules(modulesParams = {}) {
1129    const instance = this;
1130    if (!instance.modules) return;
1131    Object.keys(instance.modules).forEach((moduleName) => {
1132      const module = instance.modules[moduleName];
1133      const moduleParams = modulesParams[moduleName] || {};
1134      // Extend instance methods and props
1135      if (module.instance) {
1136        Object.keys(module.instance).forEach((modulePropName) => {
1137          const moduleProp = module.instance[modulePropName];
1138          if (typeof moduleProp === 'function') {
1139            instance[modulePropName] = moduleProp.bind(instance);
1140          } else {
1141            instance[modulePropName] = moduleProp;
1142          }
1143        });
1144      }
1145      // Add event listeners
1146      if (module.on && instance.on) {
1147        Object.keys(module.on).forEach((moduleEventName) => {
1148          instance.on(moduleEventName, module.on[moduleEventName]);
1149        });
1150      }
1151
1152      // Module create callback
1153      if (module.create) {
1154        module.create.bind(instance)(moduleParams);
1155      }
1156    });
1157  }
1158
1159  static set components(components) {
1160    const Class = this;
1161    if (!Class.use) return;
1162    Class.use(components);
1163  }
1164
1165  static installModule(module, ...params) {
1166    const Class = this;
1167    if (!Class.prototype.modules) Class.prototype.modules = {};
1168    const name = module.name || (`${Object.keys(Class.prototype.modules).length}_${Utils.now()}`);
1169    Class.prototype.modules[name] = module;
1170    // Prototype
1171    if (module.proto) {
1172      Object.keys(module.proto).forEach((key) => {
1173        Class.prototype[key] = module.proto[key];
1174      });
1175    }
1176    // Class
1177    if (module.static) {
1178      Object.keys(module.static).forEach((key) => {
1179        Class[key] = module.static[key];
1180      });
1181    }
1182    // Callback
1183    if (module.install) {
1184      module.install.apply(Class, params);
1185    }
1186    return Class;
1187  }
1188
1189  static use(module, ...params) {
1190    const Class = this;
1191    if (Array.isArray(module)) {
1192      module.forEach((m) => Class.installModule(m));
1193      return Class;
1194    }
1195    return Class.installModule(module, ...params);
1196  }
1197}
1198
1199function updateSize () {
1200  const swiper = this;
1201  let width;
1202  let height;
1203  const $el = swiper.$el;
1204  if (typeof swiper.params.width !== 'undefined') {
1205    width = swiper.params.width;
1206  } else {
1207    width = $el[0].clientWidth;
1208  }
1209  if (typeof swiper.params.height !== 'undefined') {
1210    height = swiper.params.height;
1211  } else {
1212    height = $el[0].clientHeight;
1213  }
1214  if ((width === 0 && swiper.isHorizontal()) || (height === 0 && swiper.isVertical())) {
1215    return;
1216  }
1217
1218  // Subtract paddings
1219  width = width - parseInt($el.css('padding-left'), 10) - parseInt($el.css('padding-right'), 10);
1220  height = height - parseInt($el.css('padding-top'), 10) - parseInt($el.css('padding-bottom'), 10);
1221
1222  Utils.extend(swiper, {
1223    width,
1224    height,
1225    size: swiper.isHorizontal() ? width : height,
1226  });
1227}
1228
1229function updateSlides () {
1230  const swiper = this;
1231  const params = swiper.params;
1232
1233  const {
1234    $wrapperEl, size: swiperSize, rtlTranslate: rtl, wrongRTL,
1235  } = swiper;
1236  const isVirtual = swiper.virtual && params.virtual.enabled;
1237  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1238  const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);
1239  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1240  let snapGrid = [];
1241  const slidesGrid = [];
1242  const slidesSizesGrid = [];
1243
1244  function slidesForMargin(slideIndex) {
1245    if (!params.cssMode) return true;
1246    if (slideIndex === slides.length - 1) {
1247      return false;
1248    }
1249    return true;
1250  }
1251
1252  let offsetBefore = params.slidesOffsetBefore;
1253  if (typeof offsetBefore === 'function') {
1254    offsetBefore = params.slidesOffsetBefore.call(swiper);
1255  }
1256
1257  let offsetAfter = params.slidesOffsetAfter;
1258  if (typeof offsetAfter === 'function') {
1259    offsetAfter = params.slidesOffsetAfter.call(swiper);
1260  }
1261
1262  const previousSnapGridLength = swiper.snapGrid.length;
1263  const previousSlidesGridLength = swiper.snapGrid.length;
1264
1265  let spaceBetween = params.spaceBetween;
1266  let slidePosition = -offsetBefore;
1267  let prevSlideSize = 0;
1268  let index = 0;
1269  if (typeof swiperSize === 'undefined') {
1270    return;
1271  }
1272  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1273    spaceBetween = (parseFloat(spaceBetween.replace('%', '')) / 100) * swiperSize;
1274  }
1275
1276  swiper.virtualSize = -spaceBetween;
1277
1278  // reset margins
1279  if (rtl) slides.css({ marginLeft: '', marginTop: '' });
1280  else slides.css({ marginRight: '', marginBottom: '' });
1281
1282  let slidesNumberEvenToRows;
1283  if (params.slidesPerColumn > 1) {
1284    if (Math.floor(slidesLength / params.slidesPerColumn) === slidesLength / swiper.params.slidesPerColumn) {
1285      slidesNumberEvenToRows = slidesLength;
1286    } else {
1287      slidesNumberEvenToRows = Math.ceil(slidesLength / params.slidesPerColumn) * params.slidesPerColumn;
1288    }
1289    if (params.slidesPerView !== 'auto' && params.slidesPerColumnFill === 'row') {
1290      slidesNumberEvenToRows = Math.max(slidesNumberEvenToRows, params.slidesPerView * params.slidesPerColumn);
1291    }
1292  }
1293
1294  // Calc slides
1295  let slideSize;
1296  const slidesPerColumn = params.slidesPerColumn;
1297  const slidesPerRow = slidesNumberEvenToRows / slidesPerColumn;
1298  const numFullColumns = Math.floor(slidesLength / params.slidesPerColumn);
1299  for (let i = 0; i < slidesLength; i += 1) {
1300    slideSize = 0;
1301    const slide = slides.eq(i);
1302    if (params.slidesPerColumn > 1) {
1303      // Set slides order
1304      let newSlideOrderIndex;
1305      let column;
1306      let row;
1307      if (params.slidesPerColumnFill === 'row' && params.slidesPerGroup > 1) {
1308        const groupIndex = Math.floor(i / (params.slidesPerGroup * params.slidesPerColumn));
1309        const slideIndexInGroup = i - params.slidesPerColumn * params.slidesPerGroup * groupIndex;
1310        const columnsInGroup = groupIndex === 0
1311          ? params.slidesPerGroup
1312          : Math.min(Math.ceil((slidesLength - groupIndex * slidesPerColumn * params.slidesPerGroup) / slidesPerColumn), params.slidesPerGroup);
1313        row = Math.floor(slideIndexInGroup / columnsInGroup);
1314        column = (slideIndexInGroup - row * columnsInGroup) + groupIndex * params.slidesPerGroup;
1315
1316        newSlideOrderIndex = column + ((row * slidesNumberEvenToRows) / slidesPerColumn);
1317        slide
1318          .css({
1319            '-webkit-box-ordinal-group': newSlideOrderIndex,
1320            '-moz-box-ordinal-group': newSlideOrderIndex,
1321            '-ms-flex-order': newSlideOrderIndex,
1322            '-webkit-order': newSlideOrderIndex,
1323            order: newSlideOrderIndex,
1324          });
1325      } else if (params.slidesPerColumnFill === 'column') {
1326        column = Math.floor(i / slidesPerColumn);
1327        row = i - (column * slidesPerColumn);
1328        if (column > numFullColumns || (column === numFullColumns && row === slidesPerColumn - 1)) {
1329          row += 1;
1330          if (row >= slidesPerColumn) {
1331            row = 0;
1332            column += 1;
1333          }
1334        }
1335      } else {
1336        row = Math.floor(i / slidesPerRow);
1337        column = i - (row * slidesPerRow);
1338      }
1339      slide.css(
1340        `margin-${swiper.isHorizontal() ? 'top' : 'left'}`,
1341        (row !== 0 && params.spaceBetween) && (`${params.spaceBetween}px`)
1342      );
1343    }
1344    if (slide.css('display') === 'none') continue; // eslint-disable-line
1345
1346    if (params.slidesPerView === 'auto') {
1347      const slideStyles = win.getComputedStyle(slide[0], null);
1348      const currentTransform = slide[0].style.transform;
1349      const currentWebKitTransform = slide[0].style.webkitTransform;
1350      if (currentTransform) {
1351        slide[0].style.transform = 'none';
1352      }
1353      if (currentWebKitTransform) {
1354        slide[0].style.webkitTransform = 'none';
1355      }
1356      if (params.roundLengths) {
1357        slideSize = swiper.isHorizontal()
1358          ? slide.outerWidth(true)
1359          : slide.outerHeight(true);
1360      } else {
1361        // eslint-disable-next-line
1362        if (swiper.isHorizontal()) {
1363          const width = parseFloat(slideStyles.getPropertyValue('width'));
1364          const paddingLeft = parseFloat(slideStyles.getPropertyValue('padding-left'));
1365          const paddingRight = parseFloat(slideStyles.getPropertyValue('padding-right'));
1366          const marginLeft = parseFloat(slideStyles.getPropertyValue('margin-left'));
1367          const marginRight = parseFloat(slideStyles.getPropertyValue('margin-right'));
1368          const boxSizing = slideStyles.getPropertyValue('box-sizing');
1369          if (boxSizing && boxSizing === 'border-box') {
1370            slideSize = width + marginLeft + marginRight;
1371          } else {
1372            slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight;
1373          }
1374        } else {
1375          const height = parseFloat(slideStyles.getPropertyValue('height'));
1376          const paddingTop = parseFloat(slideStyles.getPropertyValue('padding-top'));
1377          const paddingBottom = parseFloat(slideStyles.getPropertyValue('padding-bottom'));
1378          const marginTop = parseFloat(slideStyles.getPropertyValue('margin-top'));
1379          const marginBottom = parseFloat(slideStyles.getPropertyValue('margin-bottom'));
1380          const boxSizing = slideStyles.getPropertyValue('box-sizing');
1381          if (boxSizing && boxSizing === 'border-box') {
1382            slideSize = height + marginTop + marginBottom;
1383          } else {
1384            slideSize = height + paddingTop + paddingBottom + marginTop + marginBottom;
1385          }
1386        }
1387      }
1388      if (currentTransform) {
1389        slide[0].style.transform = currentTransform;
1390      }
1391      if (currentWebKitTransform) {
1392        slide[0].style.webkitTransform = currentWebKitTransform;
1393      }
1394      if (params.roundLengths) slideSize = Math.floor(slideSize);
1395    } else {
1396      slideSize = (swiperSize - ((params.slidesPerView - 1) * spaceBetween)) / params.slidesPerView;
1397      if (params.roundLengths) slideSize = Math.floor(slideSize);
1398
1399      if (slides[i]) {
1400        if (swiper.isHorizontal()) {
1401          slides[i].style.width = `${slideSize}px`;
1402        } else {
1403          slides[i].style.height = `${slideSize}px`;
1404        }
1405      }
1406    }
1407    if (slides[i]) {
1408      slides[i].swiperSlideSize = slideSize;
1409    }
1410    slidesSizesGrid.push(slideSize);
1411
1412
1413    if (params.centeredSlides) {
1414      slidePosition = slidePosition + (slideSize / 2) + (prevSlideSize / 2) + spaceBetween;
1415      if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - (swiperSize / 2) - spaceBetween;
1416      if (i === 0) slidePosition = slidePosition - (swiperSize / 2) - spaceBetween;
1417      if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
1418      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1419      if ((index) % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1420      slidesGrid.push(slidePosition);
1421    } else {
1422      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1423      if ((index

1423 - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1424      slidesGrid.push(slidePosition);
1425      slidePosition = slidePosition + slideSize + spaceBetween;
1426    }
1427
1428    swiper.virtualSize += slideSize + spaceBetween;
1429
1430    prevSlideSize = slideSize;
1431
1432    index += 1;
1433  }
1434  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1435  let newSlidesGrid;
1436
1437  if (
1438    rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
1439    $wrapperEl.css({ width: `${swiper.virtualSize + params.spaceBetween}px` });
1440  }
1441  if (params.setWrapperSize) {
1442    if (swiper.isHorizontal()) $wrapperEl.css({ width: `${swiper.virtualSize + params.spaceBetween}px` });
1443    else $wrapperEl.css({ height: `${swiper.virtualSize + params.spaceBetween}px` });
1444  }
1445
1446  if (params.slidesPerColumn > 1) {
1447    swiper.virtualSize = (slideSize + params.spaceBetween) * slidesNumberEvenToRows;
1448    swiper.virtualSize = Math.ceil(swiper.virtualSize / params.slidesPerColumn) - params.spaceBetween;
1449    if (swiper.isHorizontal()) $wrapperEl.css({ width: `${swiper.virtualSize + params.spaceBetween}px` });
1450    else $wrapperEl.css({ height: `${swiper.virtualSize + params.spaceBetween}px` });
1451    if (params.centeredSlides) {
1452      newSlidesGrid = [];
1453      for (let i = 0; i < snapGrid.length; i += 1) {
1454        let slidesGridItem = snapGrid[i];
1455        if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1456        if (snapGrid[i] < swiper.virtualSize + snapGrid[0]) newSlidesGrid.push(slidesGridItem);
1457      }
1458      snapGrid = newSlidesGrid;
1459    }
1460  }
1461
1462  // Remove last grid elements depending on width
1463  if (!params.centeredSlides) {
1464    newSlidesGrid = [];
1465    for (let i = 0; i < snapGrid.length; i += 1) {
1466      let slidesGridItem = snapGrid[i];
1467      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
1468      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
1469        newSlidesGrid.push(slidesGridItem);
1470      }
1471    }
1472    snapGrid = newSlidesGrid;
1473    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1474      snapGrid.push(swiper.virtualSize - swiperSize);
1475    }
1476  }
1477  if (snapGrid.length === 0) snapGrid = [0];
1478
1479  if (params.spaceBetween !== 0) {
1480    if (swiper.isHorizontal()) {
1481      if (rtl) slides.filter(slidesForMargin).css({ marginLeft: `${spaceBetween}px` });
1482      else slides.filter(slidesForMargin).css({ marginRight: `${spaceBetween}px` });
1483    } else slides.filter(slidesForMargin).css({ marginBottom: `${spaceBetween}px` });
1484  }
1485
1486  if (params.centeredSlides && params.centeredSlidesBounds) {
1487    let allSlidesSize = 0;
1488    slidesSizesGrid.forEach((slideSizeValue) => {
1489      allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1490    });
1491    allSlidesSize -= params.spaceBetween;
1492    const maxSnap = allSlidesSize - swiperSize;
1493    snapGrid = snapGrid.map((snap) => {
1494      if (snap < 0) return -offsetBefore;
1495      if (snap > maxSnap) return maxSnap + offsetAfter;
1496      return snap;
1497    });
1498  }
1499
1500  if (params.centerInsufficientSlides) {
1501    let allSlidesSize = 0;
1502    slidesSizesGrid.forEach((slideSizeValue) => {
1503      allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
1504    });
1505    allSlidesSize -= params.spaceBetween;
1506    if (allSlidesSize < swiperSize) {
1507      const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1508      snapGrid.forEach((snap, snapIndex) => {
1509        snapGrid[snapIndex] = snap - allSlidesOffset;
1510      });
1511      slidesGrid.forEach((snap, snapIndex) => {
1512        slidesGrid[snapIndex] = snap + allSlidesOffset;
1513      });
1514    }
1515  }
1516
1517  Utils.extend(swiper, {
1518    slides,
1519    snapGrid,
1520    slidesGrid,
1521    slidesSizesGrid,
1522  });
1523
1524  if (slidesLength !== previousSlidesLength) {
1525    swiper.emit('slidesLengthChange');
1526  }
1527  if (snapGrid.length !== previousSnapGridLength) {
1528    if (swiper.params.watchOverflow) swiper.checkOverflow();
1529    swiper.emit('snapGridLengthChange');
1530  }
1531  if (slidesGrid.length !== previousSlidesGridLength) {
1532    swiper.emit('slidesGridLengthChange');
1533  }
1534
1535  if (params.watchSlidesProgress || params.watchSlidesVisibility) {
1536    swiper.updateSlidesOffset();
1537  }
1538}
1539
1540function updateAutoHeight (speed) {
1541  const swiper = this;
1542  const activeSlides = [];
1543  let newHeight = 0;
1544  let i;
1545  if (typeof speed === 'number') {
1546    swiper.setTransition(speed);
1547  } else if (speed === true) {
1548    swiper.setTransition(swiper.params.speed);
1549  }
1550  // Find slides currently in view
1551  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1552    if (swiper.params.centeredSlides) {
1553      swiper.visibleSlides.each((index, slide) => {
1554        activeSlides.push(slide);
1555      });
1556    } else {
1557      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1558        const index = swiper.activeIndex + i;
1559        if (index > swiper.slides.length) break;
1560        activeSlides.push(swiper.slides.eq(index)[0]);
1561      }
1562    }
1563  } else {
1564    activeSlides.push(swiper.slides.eq(swiper.activeIndex)[0]);
1565  }
1566
1567  // Find new height from highest slide in view
1568  for (i = 0; i < activeSlides.length; i += 1) {
1569    if (typeof activeSlides[i] !== 'undefined') {
1570      const height = activeSlides[i].offsetHeight;
1571      newHeight = height > newHeight ? height : newHeight;
1572    }
1573  }
1574
1575  // Update Height
1576  if (newHeight) swiper.$wrapperEl.css('height', `${newHeight}px`);
1577}
1578
1579function updateSlidesOffset () {
1580  const swiper = this;
1581  const slides = swiper.slides;
1582  for (let i = 0; i < slides.length; i += 1) {
1583    slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;
1584  }
1585}
1586
1587function updateSlidesProgress (translate = (this && this.translate) || 0) {
1588  const swiper = this;
1589  const params = swiper.params;
1590
1591  const { slides, rtlTranslate: rtl } = swiper;
1592
1593  if (slides.length === 0) return;
1594  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
1595
1596  let offsetCenter = -translate;
1597  if (rtl) offsetCenter = translate;
1598
1599  // Visible Slides
1600  slides.removeClass(params.slideVisibleClass);
1601
1602  swiper.visibleSlidesIndexes = [];
1603  swiper.visibleSlides = [];
1604
1605  for (let i = 0; i < slides.length; i += 1) {
1606    const slide = slides[i];
1607    const slideProgress = (
1608      (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0)) - slide.swiperSlideOffset
1609    ) / (slide.swiperSlideSize + params.spaceBetween);
1610    if (params.watchSlidesVisibility || (params.centeredSlides && params.autoHeight)) {
1611      const slideBefore = -(offsetCenter - slide.swiperSlideOffset);
1612      const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1613      const isVisible = (slideBefore >= 0 && slideBefore < swiper.size - 1)
1614                || (slideAfter > 1 && slideAfter <= swiper.size)
1615                || (slideBefore <= 0 && slideAfter >= swiper.size);
1616      if (isVisible) {
1617        swiper.visibleSlides.push(slide);
1618        swiper.visibleSlidesIndexes.push(i);
1619        slides.eq(i).addClass(params.slideVisibleClass);
1620      }
1621    }
1622    slide.progress = rtl ? -slideProgress : slideProgress;
1623  }
1624  swiper.visibleSlides = $(swiper.visibleSlides);
1625}
1626
1627function updateProgress (translate) {
1628  const swiper = this;
1629  if (typeof translate === 'undefined') {
1630    const multiplier = swiper.rtlTranslate ? -1 : 1;
1631    // eslint-disable-next-line
1632    translate = (swiper && swiper.translate && (swiper.translate * multiplier)) || 0;
1633  }
1634  const params = swiper.params;
1635  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1636  let { progress, isBeginning, isEnd } = swiper;
1637  const wasBeginning = isBeginning;
1638  const wasEnd = isEnd;
1639  if (translatesDiff === 0) {
1640    progress = 0;
1641    isBeginning = true;
1642    isEnd = true;
1643  } else {
1644    progress = (translate - swiper.minTranslate()) / (translatesDiff);
1645    isBeginning = progress <= 0;
1646    isEnd = progress >= 1;
1647  }
1648  Utils.extend(swiper, {
1649    progress,
1650    isBeginning,
1651    isEnd,
1652  });
1653
1654  if (params.watchSlidesProgress || params.watchSlidesVisibility || (params.centeredSlides && params.autoHeight)) swiper.updateSlidesProgress(translate);
1655
1656  if (isBeginning && !wasBeginning) {
1657    swiper.emit('reachBeginning toEdge');
1658  }
1659  if (isEnd && !wasEnd) {
1660    swiper.emit('reachEnd toEdge');
1661  }

1662  if ((wasBeginning && !isBeginning) || (wasEnd && !isEnd)) {
1663    swiper.emit('fromEdge');
1664  }
1665
1666  swiper.emit('progress', progress);
1667}
1668
1669function updateSlidesClasses () {
1670  const swiper = this;
1671
1672  const {
1673    slides, params, $wrapperEl, activeIndex, realIndex,
1674  } = swiper;
1675  const isVirtual = swiper.virtual && params.virtual.enabled;
1676
1677  slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);
1678
1679  let activeSlide;
1680  if (isVirtual) {
1681    activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index="${activeIndex}"]`);
1682  } else {
1683    activeSlide = slides.eq(activeIndex);
1684  }
1685
1686  // Active classes
1687  activeSlide.addClass(params.slideActiveClass);
1688
1689  if (params.loop) {
1690    // Duplicate to all looped slides
1691    if (activeSlide.hasClass(params.slideDuplicateClass)) {
1692      $wrapperEl
1693        .children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${realIndex}"]`)
1694        .addClass(params.slideDuplicateActiveClass);
1695    } else {
1696      $wrapperEl
1697        .children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${realIndex}"]`)
1698        .addClass(params.slideDuplicateActiveClass);
1699    }
1700  }
1701  // Next Slide
1702  let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);
1703  if (params.loop && nextSlide.length === 0) {
1704    nextSlide = slides.eq(0);
1705    nextSlide.addClass(params.slideNextClass);
1706  }
1707  // Prev Slide
1708  let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);
1709  if (params.loop && prevSlide.length === 0) {
1710    prevSlide = slides.eq(-1);
1711    prevSlide.addClass(params.slidePrevClass);
1712  }
1713  if (params.loop) {
1714    // Duplicate to all looped slides
1715    if (nextSlide.hasClass(params.slideDuplicateClass)) {
1716      $wrapperEl
1717        .children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`)
1718        .addClass(params.slideDuplicateNextClass);
1719    } else {
1720      $wrapperEl
1721        .children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`)
1722        .addClass(params.slideDuplicateNextClass);
1723    }
1724    if (prevSlide.hasClass(params.slideDuplicateClass)) {
1725      $wrapperEl
1726        .children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`)
1727        .addClass(params.slideDuplicatePrevClass);
1728    } else {
1729      $wrapperEl
1730        .children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`)
1731        .addClass(params.slideDuplicatePrevClass);
1732    }
1733  }
1734}
1735
1736function updateActiveIndex (newActiveIndex) {
1737  const swiper = this;
1738  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1739  const {
1740    slidesGrid, snapGrid, params, activeIndex: previousIndex, realIndex: previousRealIndex, snapIndex: previousSnapIndex,
1741  } = swiper;
1742  let activeIndex = newActiveIndex;
1743  let snapIndex;
1744  if (typeof activeIndex === 'undefined') {
1745    for (let i = 0; i < slidesGrid.length; i += 1) {
1746      if (typeof slidesGrid[i + 1] !== 'undefined') {
1747        if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - ((slidesGrid[i + 1] - slidesGrid[i]) / 2)) {
1748          activeIndex = i;
1749        } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1750          activeIndex = i + 1;
1751        }
1752      } else if (translate >= slidesGrid[i]) {
1753        activeIndex = i;
1754      }
1755    }
1756    // Normalize slideIndex
1757    if (params.normalizeSlideIndex) {
1758      if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1759    }
1760  }
1761  if (snapGrid.indexOf(translate) >= 0) {
1762    snapIndex = snapGrid.indexOf(translate);
1763  } else {
1764    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1765    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1766  }
1767  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1768  if (activeIndex === previousIndex) {
1769    if (snapIndex !== previousSnapIndex) {
1770      swiper.snapIndex = snapIndex;
1771      swiper.emit('snapIndexChange');
1772    }
1773    return;
1774  }
1775
1776  // Get real index
1777  const realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);
1778
1779  Utils.extend(swiper, {
1780    snapIndex,
1781    realIndex,
1782    previousIndex,
1783    activeIndex,
1784  });
1785  swiper.emit('activeIndexChange');
1786  swiper.emit('snapIndexChange');
1787  if (previousRealIndex !== realIndex) {
1788    swiper.emit('realIndexChange');
1789  }
1790  if (swiper.initialized || swiper.params

1790.runCallbacksOnInit) {
1791    swiper.emit('slideChange');
1792  }
1793}
1794
1795function updateClickedSlide (e) {
1796  const swiper = this;
1797  const params = swiper.params;
1798  const slide = $(e.target).closest(`.${params.slideClass}`)[0];
1799  let slideFound = false;
1800  if (slide) {
1801    for (let i = 0; i < swiper.slides.length; i += 1) {
1802      if (swiper.slides[i] === slide) slideFound = true;
1803    }
1804  }
1805
1806  if (slide && slideFound) {
1807    swiper.clickedSlide = slide;
1808    if (swiper.virtual && swiper.params.virtual.enabled) {
1809      swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);
1810    } else {
1811      swiper.clickedIndex = $(slide).index();
1812    }
1813  } else {
1814    swiper.clickedSlide = undefined;
1815    swiper.clickedIndex = undefined;
1816    return;
1817  }
1818  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1819    swiper.slideToClickedSlide();
1820  }
1821}
1822
1823var update = {
1824  updateSize,
1825  updateSlides,
1826  updateAutoHeight,
1827  updateSlidesOffset,
1828  updateSlidesProgress,
1829  updateProgress,
1830  updateSlidesClasses,
1831  updateActiveIndex,
1832  updateClickedSlide,
1833};
1834
1835function getTranslate (axis = this.isHorizontal() ? 'x' : 'y') {
1836  const swiper = this;
1837
1838  const {
1839    params, rtlTranslate: rtl, translate, $wrapperEl,
1840  } = swiper;
1841
1842  if (params.virtualTranslate) {
1843    return rtl ? -translate : translate;
1844  }
1845  if (params.cssMode) {
1846    return translate;
1847  }
1848
1849  let currentTranslate = Utils.getTranslate($wrapperEl[0], axis);
1850  if (rtl) currentTranslate = -currentTranslate;
1851
1852  return currentTranslate || 0;
1853}
1854
1855function setTranslate (translate, byController) {
1856  const swiper = this;
1857  const {
1858    rtlTranslate: rtl, params, $wrapperEl, wrapperEl, progress,
1859  } = swiper;
1860  let x = 0;
1861  let y = 0;
1862  const z = 0;
1863
1864  if (swiper.isHorizontal()) {
1865    x = rtl ? -translate : translate;
1866  } else {
1867    y = translate;
1868  }
1869
1870  if (params.roundLengths) {
1871    x = Math.floor(x);
1872    y = Math.floor(y);
1873  }
1874
1875  if (params.cssMode) {
1876    wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
1877  } else if (!params.virtualTranslate) {
1878    $wrapperEl.transform(`translate3d(${x}px, ${y}px, ${z}px)`);
1879  }
1880  swiper.previousTranslate = swiper.translate;
1881  swiper.translate = swiper.isHorizontal() ? x : y;
1882
1883  // Check if we need to update progress
1884  let newProgress;
1885  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1886  if (translatesDiff === 0) {
1887    newProgress = 0;
1888  } else {
1889    newProgress = (translate - swiper.minTranslate()) / (translatesDiff);
1890  }
1891  if (newProgress !== progress) {
1892    swiper.updateProgress(translate);
1893  }
1894
1895  swiper.emit('setTranslate', swiper.translate, byController);
1896}
1897
1898function minTranslate () {
1899  return (-this.snapGrid[0]);
1900}
1901
1902function maxTranslate () {
1903  return (-this.snapGrid[this.snapGrid.length - 1]);
1904}
1905
1906function translateTo (translate = 0, speed = this.params.speed, runCallbacks = true, translateBounds = true, internal) {
1907  const swiper = this;
1908
1909  const {
1910    params,
1911    wrapperEl,
1912  } = swiper;
1913
1914  if (swiper.animating && params.preventInteractionOnTransition) {
1915    return false;
1916  }
1917
1918  const minTranslate = swiper.minTranslate();
1919  const maxTranslate = swiper.maxTranslate();
1920  let newTranslate;
1921  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;
1922  else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;
1923  else newTranslate = translate;
1924
1925  // Update progress
1926  swiper.updateProgress(newTranslate);
1927
1928  if (params.cssMode) {
1929    const isH = swiper.isHorizontal();
1930    if (speed === 0) {
1931      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1932    } else {
1933      // eslint-disable-next-line
1934      if (wrapperEl.scrollTo) {
1935        wrapperEl.scrollTo({
1936          [isH ? 'left' : 'top']: -newTranslate,
1937          behavior: 'smooth',
1938        });
1939      } else {
1940        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1941      }
1942    }
1943    return true;
1944  }
1945
1946  if (speed === 0) {
1947    swiper.setTransition(0);
1948    swiper.setTranslate(newTranslate);
1949    if (runCallbacks) {
1950      swiper.emit('beforeTransitionStart', speed, internal);
1951      swiper.emit('transitionEnd');
1952    }
1953  } else {
1954    swiper.setTransition(speed);
1955    swiper.setTranslate(newTranslate);
1956    if (runCallbacks) {
1957      swiper.emit('beforeTransitionStart', speed, internal);
1958      swiper.emit('transitionStart');
1959    }
1960    if (!swiper.animating) {
1961      swiper.animating = true;
1962      if (!swiper.onTranslateToWrapperTransitionEnd) {
1963        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1964          if (!swiper || swiper.destroyed) return;
1965          if (e.target !== this) return;
1966          swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1967          swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
1968          swiper.onTranslateToWrapperTransitionEnd = null;
1969          delete swiper.onTranslateToWrapperTransitionEnd;
1970          if (runCallbacks) {
1971            swiper.emit('transitionEnd');
1972          }
1973        };
1974      }
1975      swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1976      swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
1977    }
1978  }
1979
1980  return true;
1981}
1982
1983var translate = {
1984  getTranslate,
1985  setTranslate,
1986  minTranslate,
1987  maxTranslate,
1988  translateTo,
1989};
1990
1991function setTransition (duration, byController) {
1992  const swiper = this;
1993
1994  if (!swiper.params.cssMode) {
1995    swiper.$wrapperEl.transition(duration);
1996  }
1997
1998  swiper.emit('setTransition', duration, byController);
1999}
2000
2001function transitionStart (runCallbacks = true, direction) {
2002  const swiper = this;
2003  const { activeIndex, params, previousIndex } = swiper;
2004  if (params.cssMode) return;
2005  if (params.autoHeight) {
2006    swiper.updateAutoHeight();
2007  }
2008
2009  let dir = direction;
2010  if (!dir) {
2011    if (activeIndex > previousIndex) dir = 'next';
2012    else if (activeIndex < previousIndex) dir = 'prev';
2013    else dir = 'reset';
2014  }
2015
2016  swiper.emit('transitionStart');
2017
2018  if (runCallbacks && activeIndex !== previousIndex) {
2019    if (dir === 'reset') {
2020      swiper.emit('slideResetTransitionStart');
2021      return;
2022    }
2023    swiper.emit('slideChangeTransitionStart');
2024    if (dir === 'next') {
2025      swiper.emit('slideNextTransitionStart');
2026    } else {
2027      swiper.emit('slidePrevTransitionStart');
2028    }
2029  }
2030}
2031
2032function transitionEnd$1 (runCallbacks = true, direction) {
2033  const swiper = this;
2034  const { activeIndex, previousIndex, params } = swiper;
2035  swiper.animating = false;
2036  if (params.cssMode) return;
2037  swiper.setTransition(0);
2038
2039  let dir = direction;
2040  if (!dir) {
2041    if (activeIndex > previousIndex) dir = 'next';
2042    else if (activeIndex < previousIndex) dir = 'prev';
2043    else dir = 'reset';
2044  }
2045
2046  swiper.emit('transitionEnd');
2047
2048  if (runCallbacks && activeIndex !== previousIndex) {
2049    if (dir === 'reset') {
2050      swiper.emit('slideResetTransitionEnd');
2051      return;
2052    }
2053    swiper.emit('slideChangeTransitionEnd');
2054    if (dir === 'next') {
2055      swiper.emit('slideNextTransitionEnd');
2056    } else {
2057      swiper.emit('slidePrevTransitionEnd');
2058    }
2059  }
2060}
2061
2062var transition$1 = {
2063  setTransition,
2064  transitionStart,
2065  transitionEnd: transitionEnd$1,
2066};
2067
2068function slideTo (index = 0, speed = this.params.speed, runCallbacks = true, internal) {
2069  const swiper = this;
2070  let slideIndex = index;
2071  if (slideIndex < 0) slideIndex = 0;
2072
2073  const {
2074    params, snapGrid, slidesGrid, previousIndex, activeIndex, rtlTranslate: rtl, wrapperEl,
2075  } = swiper;
2076  if (swiper.animating && params.preventInteractionOnTransition) {
2077    return false;
2078  }
2079
2080  

2080const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
2081  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
2082  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2083
2084  if ((activeIndex || params.initialSlide || 0) === (previousIndex || 0) && runCallbacks) {
2085    swiper.emit('beforeSlideChangeStart');
2086  }
2087
2088  const translate = -snapGrid[snapIndex];
2089
2090  // Update progress
2091  swiper.updateProgress(translate);
2092
2093  // Normalize slideIndex
2094  if (params.normalizeSlideIndex) {
2095    for (let i = 0; i < slidesGrid.length; i += 1) {
2096      if (-Math.floor(translate * 100) >= Math.floor(slidesGrid[i] * 100)) {
2097        slideIndex = i;
2098      }
2099    }
2100  }
2101  // Directions locks
2102  if (swiper.initialized && slideIndex !== activeIndex) {
2103    if (!swiper.allowSlideNext && translate < swiper.translate && translate < swiper.minTranslate()) {
2104      return false;
2105    }
2106    if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
2107      if ((activeIndex || 0) !== slideIndex) return false;
2108    }
2109  }
2110
2111  let direction;
2112  if (slideIndex > activeIndex) direction = 'next';
2113  else if (slideIndex < activeIndex) direction = 'prev';
2114  else direction = 'reset';
2115
2116
2117  // Update Index
2118  if ((rtl && -translate === swiper.translate) || (!rtl && translate === swiper.translate)) {
2119    swiper.updateActiveIndex(slideIndex);
2120    // Update Height
2121    if (params.autoHeight) {
2122      swiper.updateAutoHeight();
2123    }
2124    swiper.updateSlidesClasses();
2125    if (params.effect !== 'slide') {
2126      swiper.setTranslate(translate);
2127    }
2128    if (direction !== 'reset') {
2129      swiper.transitionStart(runCallbacks, direction);
2130      swiper.transitionEnd(runCallbacks, direction);
2131    }
2132    return false;
2133  }
2134  if (params.cssMode) {
2135    const isH = swiper.isHorizontal();
2136    let t = -translate;
2137    if (rtl) {
2138      t = wrapperEl.scrollWidth - wrapperEl.offsetWidth - t;
2139    }
2140    if (speed === 0) {
2141      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
2142    } else {
2143      // eslint-disable-next-line
2144      if (wrapperEl.scrollTo) {
2145        wrapperEl.scrollTo({
2146          [isH ? 'left' : 'top']: t,
2147          behavior: 'smooth',
2148        });
2149      } else {
2150        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
2151      }
2152    }
2153    return true;
2154  }
2155
2156  if (speed === 0) {
2157    swiper.setTransition(0);
2158    swiper.setTranslate(translate);
2159    swiper.updateActiveIndex(slideIndex);
2160    swiper.updateSlidesClasses();
2161    swiper.emit('beforeTransitionStart', speed, internal);
2162    swiper.transitionStart(runCallbacks, direction);
2163    swiper.transitionEnd(runCallbacks, direction);
2164  } else {
2165    swiper.setTransition(speed);
2166    swiper.setTranslate(translate);
2167    swiper.updateActiveIndex(slideIndex);
2168    swiper.updateSlidesClasses();
2169    swiper.emit('beforeTransitionStart', speed, internal);
2170    swiper.transitionStart(runCallbacks, direction);
2171    if (!swiper.animating) {
2172      swiper.animating = true;
2173      if (!swiper.onSlideToWrapperTransitionEnd) {
2174        swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2175          if (!swiper || swiper.destroyed) return;
2176          if (e.target !== this) return;
2177          swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2178          swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2179          swiper.onSlideToWrapperTransitionEnd = null;
2180          delete swiper.onSlideToWrapperTransitionEnd;
2181          swiper.transitionEnd(runCallbacks, direction);
2182        };
2183      }
2184      swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2185      swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2186    }
2187  }
2188
2189  return true;
2190}
2191
2192function slideToLoop (index = 0, speed = this.params.speed, runCallbacks = true, internal) {
2193  const swiper = this;
2194  let newIndex = index;
2195  if (swiper.params.loop) {
2196    newIndex += swiper.loopedSlides;
2197  }
2198
2199  return swiper.slideTo(newIndex, speed, runCallbacks, internal);
2200}
2201
2202/* eslint no-unused-vars: "off" */
2203function slideNext (speed = this.params.speed, runCallbacks = true, internal) {
2204  const swiper = this;
2205  const { params, animating } = swiper;
2206  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup;
2207  if (params.loop) {
2208    if (animating) return false;
2209    swiper.loopFix();
2210    // eslint-disable-next-line
2211    swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2212  }
2213  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2214}
2215
2216/* eslint no-unused-vars: "off" */
2217function slidePrev (speed = this.params.speed, runCallbacks = true, internal) {
2218  const swiper = this;
2219  const {
2220    params, animating, snapGrid, slidesGrid, rtlTranslate,
2221  } = swiper;
2222
2223  if (params.loop) {
2224    if (animating) return false;
2225    swiper.loopFix();
2226    // eslint-disable-next-line
2227    swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2228  }
2229  const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2230  function normalize(val) {
2231    if (val < 0) return -Math.floor(Math.abs(val));
2232    return Math.floor(val);
2233  }
2234  const normalizedTranslate = normalize(translate);
2235  const normalizedSnapGrid = snapGrid.map((val) => normalize(val));
2236  const normalizedSlidesGrid = slidesGrid.map((val) => normalize(val));
2237
2238  const currentSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate)];
2239  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2240  if (typeof prevSnap === 'undefined' && params.cssMode) {
2241    snapGrid.forEach((snap) => {
2242      if (!prevSnap && normalizedTranslate >= snap) prevSnap = snap;
2243    });
2244  }
2245  let prevIndex;
2246  if (typeof prevSnap !== 'undefined') {
2247    prevIndex = slidesGrid.indexOf(prevSnap);
2248    if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2249  }
2250  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2251}
2252
2253/* eslint no-unused-vars: "off" */
2254function slideReset (speed = this.params.speed, runCallbacks = true, internal) {
2255  const swiper = this;
2256  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2257}
2258
2259/* eslint no-unused-vars: "off" */
2260function slideToClosest (speed = this.params.speed, runCallbacks = true, internal, threshold = 0.5) {
2261  const swiper = this;
2262  let index = swiper.activeIndex;
2263  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2264  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2265
2266  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2267
2268  if (translate >= swiper.snapGrid[snapIndex]) {
2269    // The current translate is on or after the current snap index, so the choice
2270    // is between the current index and the one after it.
2271    const currentSnap = swiper.snapGrid[snapIndex];
2272    const nextSnap = swiper.snapGrid[snapIndex + 1];
2273    if ((translate - currentSnap) > (nextSnap - currentSnap) * threshold) {
2274      index += swiper.params.slidesPerGroup;
2275    }
2276  } else {
2277    // The current translate is before the current snap index, so the choice
2278    // is between the current index and the one before it.
2279    const prevSnap = swiper.snapGrid[snapIndex - 1];
2280    const currentSnap = swiper.snapGrid[snapIndex];
2281    if ((translate - prevSnap) <= (currentSnap - prevSnap) * threshold) {
2282      index -= swiper.params.slidesPerGroup;
2283    }
2284  }
2285  index = Math.max(index, 0);
2286  index = Math.min(index, swiper.slides

2286Grid.length - 1);
2287
2288  return swiper.slideTo(index, speed, runCallbacks, internal);
2289}
2290
2291function slideToClickedSlide () {
2292  const swiper = this;
2293  const { params, $wrapperEl } = swiper;
2294
2295  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2296  let slideToIndex = swiper.clickedIndex;
2297  let realIndex;
2298  if (params.loop) {
2299    if (swiper.animating) return;
2300    realIndex = parseInt($(swiper.clickedSlide).attr('data-swiper-slide-index'), 10);
2301    if (params.centeredSlides) {
2302      if (
2303        (slideToIndex < swiper.loopedSlides - (slidesPerView / 2))
2304        || (slideToIndex > (swiper.slides.length - swiper.loopedSlides) + (slidesPerView / 2))
2305      ) {
2306        swiper.loopFix();
2307        slideToIndex = $wrapperEl
2308          .children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`)
2309          .eq(0)
2310          .index();
2311
2312        Utils.nextTick(() => {
2313          swiper.slideTo(slideToIndex);
2314        });
2315      } else {
2316        swiper.slideTo(slideToIndex);
2317      }
2318    } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2319      swiper.loopFix();
2320      slideToIndex = $wrapperEl
2321        .children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`)
2322        .eq(0)
2323        .index();
2324
2325      Utils.nextTick(() => {
2326        swiper.slideTo(slideToIndex);
2327      });
2328    } else {
2329      swiper.slideTo(slideToIndex);
2330    }
2331  } else {
2332    swiper.slideTo(slideToIndex);
2333  }
2334}
2335
2336var slide = {
2337  slideTo,
2338  slideToLoop,
2339  slideNext,
2340  slidePrev,
2341  slideReset,
2342  slideToClosest,
2343  slideToClickedSlide,
2344};
2345
2346function loopCreate () {
2347  const swiper = this;
2348  const { params, $wrapperEl } = swiper;
2349  // Remove duplicated slides
2350  $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}`).remove();
2351
2352  let slides = $wrapperEl.children(`.${params.slideClass}`);
2353
2354  if (params.loopFillGroupWithBlank) {
2355    const blankSlidesNum = params.slidesPerGroup - (slides.length % params.slidesPerGroup);
2356    if (blankSlidesNum !== params.slidesPerGroup) {
2357      for (let i = 0; i < blankSlidesNum; i += 1) {
2358        const blankNode = $(doc.createElement('div')).addClass(`${params.slideClass} ${params.slideBlankClass}`);
2359        $wrapperEl.append(blankNode);
2360      }
2361      slides = $wrapperEl.children(`.${params.slideClass}`);
2362    }
2363  }
2364
2365  if (params.slidesPerView === 'auto' && !params.loopedSlides) params.loopedSlides = slides.length;
2366
2367  swiper.loopedSlides = Math.ceil(parseFloat(params.loopedSlides || params.slidesPerView, 10));
2368  swiper.loopedSlides += params.loopAdditionalSlides;
2369  if (swiper.loopedSlides > slides.length) {
2370    swiper.loopedSlides = slides.length;
2371  }
2372
2373  const prependSlides = [];
2374  const appendSlides = [];
2375  slides.each((index, el) => {
2376    const slide = $(el);
2377    if (index < swiper.loopedSlides) appendSlides.push(el);
2378    if (index < slides.length && index >= slides.length - swiper.loopedSlides) prependSlides.push(el);
2379    slide.attr('data-swiper-slide-index', index);
2380  });
2381  for (let i = 0; i < appendSlides.length; i += 1) {
2382    $wrapperEl.append($(appendSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
2383  }
2384  for (let i = prependSlides.length - 1; i >= 0; i -= 1) {
2385    $wrapperEl.prepend($(prependSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
2386  }
2387}
2388
2389function loopFix () {
2390  const swiper = this;
2391
2392  swiper.emit('beforeLoopFix');
2393
2394  const {
2395    activeIndex, slides, loopedSlides, allowSlidePrev, allowSlideNext, snapGrid, rtlTranslate: rtl,
2396  } = swiper;
2397  let newIndex;
2398  swiper.allowSlidePrev = true;
2399  swiper.allowSlideNext = true;
2400
2401  const snapTranslate = -snapGrid[activeIndex];
2402  const diff = snapTranslate - swiper.getTranslate();
2403
2404  // Fix For Negative Oversliding
2405  if (activeIndex < loopedSlides) {
2406    newIndex = (slides.length - (loopedSlides * 3)) + activeIndex;
2407    newIndex += loopedSlides;
2408    const slideChanged = swiper.slideTo(newIndex, 0, false, true);
2409    if (slideChanged && diff !== 0) {
2410      swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
2411    }
2412  } else if (activeIndex >= slides.length - loopedSlides) {
2413    // Fix For Positive Oversliding
2414    newIndex = -slides.length + activeIndex + loopedSlides;
2415    newIndex += loopedSlides;
2416    const slideChanged = swiper.slideTo(newIndex, 0, false, true);
2417    if (slideChanged && diff !== 0) {
2418      swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
2419    }
2420  }
2421  swiper.allowSlidePrev = allowSlidePrev;
2422  swiper.allowSlideNext = allowSlideNext;
2423
2424  swiper.emit('loopFix');
2425}
2426
2427function loopDestroy () {
2428  const swiper = this;
2429  const { $wrapperEl, params, slides } = swiper;
2430  $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass},.${params.slideClass}.${params.slideBlankClass}`).remove();
2431  slides.removeAttr('data-swiper-slide-index');
2432}
2433
2434var loop = {
2435  loopCreate,
2436  loopFix,
2437  loopDestroy,
2438};
2439
2440function setGrabCursor (moving) {
2441  const swiper = this;
2442  if (Support.touch || !swiper.params.simulateTouch || (swiper.params.watchOverflow && swiper.isLocked) || swiper.params.cssMode) return;
2443  const el = swiper.el;
2444  el.style.cursor = 'move';
2445  el.style.cursor = moving ? '-webkit-grabbing' : '-webkit-grab';
2446  el.style.cursor = moving ? '-moz-grabbin' : '-moz-grab';
2447  el.style.cursor = moving ? 'grabbing' : 'grab';
2448}
2449
2450function unsetGrabCursor () {
2451  const swiper = this;
2452  if (Support.touch || (swiper.params.watchOverflow && swiper.isLocked) || swiper.params.cssMode) return;
2453  swiper.el.style.cursor = '';
2454}
2455
2456var grabCursor = {
2457  setGrabCursor,
2458  unsetGrabCursor,
2459};
2460
2461function appendSlide (slides) {
2462  const swiper = this;
2463  const { $wrapperEl, params } = swiper;
2464  if (params.loop) {
2465    swiper.loopDestroy();
2466  }
2467  if (typeof slides === 'object' && 'length' in slides) {
2468    for (let i = 0; i < slides.length; i += 1) {
2469      if (slides[i]) $wrapperEl.append(slides[i]);
2470    }
2471  } else {
2472    $wrapperEl.append(slides);
2473  }
2474  if (params.loop) {
2475    swiper.loopCreate();
2476  }
2477  if (!(params.observer && Support.observer)) {
2478    swiper.update();
2479  }
2480}
2481
2482function prependSlide (slides) {
2483  const swiper = this;
2484  const { params, $wrapperEl, activeIndex } = swiper;
2485
2486  if (params.loop) {
2487    swiper.loopDestroy();
2488  }
2489  let newActiveIndex = activeIndex + 1;
2490  if (typeof slides === 'object' && 'length' in slides) {
2491    for (let i = 0; i < slides.length; i += 1) {
2492      if (slides[i]) $wrapperEl.prepend(slides[i]);
2493    }
2494    newActiveIndex = activeIndex + slides.length;
2495  } else {
2496    $wrapperEl.prepend(slides);
2497  }
2498  if (params.loop) {
2499    swiper.loopCreate();
2500  }
2501  if (!(params.observer && Support.observer)) {
2502    swiper.update();
2503  }
2504  swiper.slideTo(newActiveIndex, 0, false);
2505}
2506
2507function addSlide (index, slides) {
2508  const swiper = this;
2509  const { $wrapperEl, params, activeIndex } = swiper;
2510  let activeIndexBuffer = activeIndex;
2511  if (params.loop) {
2512    activeIndexBuffer -= swiper.loopedSlides;
2513    swiper.loopDestroy();
2514    swiper.slides = $wrapperEl.children(`.${params.slideClass}`);
2515  }
2516  const baseLength = swiper.slides.length;
2517  if (index <= 0) {
2518    swiper.prependSlide(slides);
2519    return;
2520  }
2521  if (index >= baseLength) {
2522    swiper.appendSlide(slides);
2523    return;
2524  }
2525  let newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + 1 : activeIndexBuffer;
2526
2527  const slidesBuffer = [];
2528  for (let i = baseLength - 1; i >= index; i -= 1) {
2529    const currentSlide = swiper.slides.eq(i);
2530    currentSlide.remove();
2531    slidesBuffer.unshift(currentSlide);
2532  }
2533
2534  if (typeof slides === 'object' && 'length' in slides) {
2535    for (let i = 0; i < slides.length; i += 1) {
2536      if (slides[i]) $wrapperEl.append(slides[i]);
2537    }
2538    newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + slides.length : activeIndexBuffer;
2539  } else {
2540    $wrapperEl.append(slides);
2541  }
2542
2543  for (let i = 0; i < slidesBuffer.length; i += 1) {
2544    $wrapperEl.append(slidesBuffer[i]);
2545  }
2546
2547  if (params.loop) {
2548    swiper.loopCreate();
2549  }
2550  if (!(params.observer && Support.observer)) {
2551    swiper.update();
2552  }
2553  if (params.loop) {
2554    swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
2555  } else {
2556    swiper.slideTo(newActiveIndex, 0, false);
2557  }
2558}
2559
2560function removeSlide (slidesIndexes) {
2561  const swiper = this;
2562  const { params, $wrapperEl, activeIndex } = swiper;
2563
2564  let activeIndexBuffer = activeIndex;
2565  if (params.loop) {
2566    activeIndexBuffer -= swiper.loopedSlides;
2567    swiper.loopDestroy();
2568    swiper.slides = $wrapperEl.children(`.${params.slideClass}`);
2569  }
2570  let newActiveIndex = activeIndexBuffer;
2571  let indexToRemove;
2572
2573  if (typeof slidesIndexes === 'object' && 'length' in slidesIndexes) {
2574    for (let i = 0; i < slidesIndexes.length; i += 1) {
2575      indexToRemove = slidesIndexes[i];
2576      if (swiper.slides[indexToRemove]) swiper.slides.eq(indexToRemove).remove();
2577      if (indexToRemove < newActiveIndex) newActiveIndex -= 1;
2578    }
2579    newActiveIndex = Math.max(newActiveIndex, 0);
2580  } else {
2581    indexToRemove = slidesIndexes;
2582    if (swiper.slides[indexToRemove]) swiper.slides.eq(indexToRemove).remove();
2583    if (indexToRemove < newActiveIndex) newActiveIndex -= 1;
2584    newActiveIndex = Math.max(newActiveIndex, 0);
2585  }
2586
2587  if (params.loop) {
2588    swiper.loopCreate();
2589  }
2590
2591  if (!(params.observer && Support.observer)) {
2592    swiper.update();
2593  }
2594  if (params.loop) {
2595    swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
2596  } else {
2597    swiper.slideTo(newActiveIndex, 0, false);
2598  }
2599}
2600
2601function removeAllSlides () {
2602  const swiper = this;
2603
2604  const slidesIndexes = [];
2605  for (let i = 0; i < swiper.slides.length; i += 1) {
2606    slidesIndexes.push(i);
2607  }
2608  swiper.removeSlide(slidesIndexes);
2609}
2610
2611var manipulation = {
2612  appendSlide,
2613  prependSlide,
2614  addSlide,
2615  removeSlide,
2616  removeAllSlides,
2617};
2618
2619const Device = (function Device() {
2620  const platform = win.navigator.platform;
2621  const ua = win.navigator.userAgent;
2622
2623  const device = {
2624    ios: false,
2625    android: false,
2626    androidChrome: false,
2627    desktop: false,
2628    iphone: false,
2629    ipod: false,
2630    ipad: false,
2631    edge: false,
2632    ie: false,
2633    firefox: false,
2634    macos: false,
2635    windows: false,
2636    cordova: !!(win.cordova || win.phonegap),
2637    phonegap: !!(win.cordova || win.phonegap),
2638    electron: false,
2639  };
2640
2641  const screenWidth = win.screen.width;
2642  const screenHeight = win.screen.height;
2643
2644  const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
2645  let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
2646  const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
2647  const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
2648  const ie = ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;
2649  const edge = ua.indexOf('Edge/') >= 0;
2650  const firefox = ua.indexOf('Gecko/') >= 0 && ua.indexOf('Firefox/') >= 0;
2651  const windows = platform === 'Win32';
2652  const electron = ua.toLowerCase().indexOf('electron') >= 0;
2653  let macos = platform === 'MacIntel';
2654
2655  // iPadOs 13 fix
2656  if (!ipad
2657    && macos
2658    && Support.touch
2659    && (
2660      (screenWidth === 1024 && screenHeight === 1366) // Pro 12.9
2661      || (screenWidth === 834 && screenHeight === 1194) // Pro 11
2662      || (screenWidth === 834 && screenHeight === 1112) // Pro 10.5
2663      || (screenWidth === 768 && screenHeight === 1024) // other
2664    )
2665  ) {
2666    ipad = ua.match(/(Version)\/([\d.]+)/);
2667    macos = false;
2668  }
2669
2670  device.ie = ie;
2671  device.edge = edge;
2672  device.firefox = firefox;
2673
2674  // Android
2675  if (android && !windows) {
2676    device.os = 'android';
2677    device.osVersion = android[2];
2678    device.android = true;
2679    device.androidChrome = ua.toLowerCase().indexOf('chrome') >= 0;
2680  }
2681  if (ipad || iphone || ipod) {
2682    device.os = 'ios';
2683    device.ios = true;
2684  }
2685  // iOS
2686  if (iphone && !ipod) {
2687    device.osVersion = iphone[2].replace(/_/g, '.');
2688    device.iphone = true;
2689  }
2690  if (ipad) {
2691    device.osVersion = ipad[2].replace(/_/g, '.');
2692    device.ipad = true;
2693  }
2694  if (ipod) {
2695    device.osVersion = ipod[3] ? ipod[3].replace(/_/g, '.') : null;
2696    device.ipod = true;
2697  }
2698  // iOS 8+ changed UA
2699  if (device.ios && device.osVersion && ua.indexOf('Version/') >= 0) {
2700    if (device.osVersion.split('.')[0] === '10') {
2701      device.osVersion = ua.toLowerCase().split('version/')[1].split(' ')[0];
2702    }
2703  }
2704
2705  // Webview
2706  device.webView = !!((iphone || ipad || ipod) && (ua.match(/.*AppleWebKit(?!.*Safari)/i) || win.navigator.standalone))
2707    || (win.matchMedia && win.matchMedia('(display-mode: standalone)').matches);
2708  device.webview = device.webView;
2709  device.standalone = device.webView;
2710
2711  // Desktop
2712  device.desktop = !(device.ios || device.android) || electron;
2713  if (device.desktop) {
2714    device.electron = electron;
2715    device.macos = macos;
2716    device.windows = windows;
2717    if (device.macos) {
2718      device.os = 'macos';
2719    }
2720    if (device.windows) {
2721      device.os = 'windows';
2722    }
2723  }
2724
2725  // Pixel Ratio
2726  device.pixelRatio = win.devicePixelRatio || 1;
2727
2728  // Export object
2729  return device;
2730}());
2731
2732function onTouchStart (event) {
2733  const swiper = this;
2734  const data = swiper.touchEventsData;
2735  const { params, touches } = swiper;
2736
2737  if (swiper.animating && params.preventInteractionOnTransition) {
2738    return;
2739  }
2740  let e = event;
2741  if (e.originalEvent) e = e.originalEvent;
2742  const $targetEl = $(e.target);
2743
2744  if (params.touchEventsTarget === 'wrapper') {
2745    if (!$targetEl.closest(swiper.wrapperEl).length) return;
2746  }
2747  data.isTouchEvent = e.type === 'touchstart';
2748  if (!data.isTouchEvent && 'which' in e && e.which === 3) return;
2749  if (!data.isTouchEvent && 'button' in e && e.button > 0) return;
2750  if (data.isTouched && data.isMoved) return;
2751  if (params.noSwiping && $targetEl.closest(params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`)[0]) {
2752    swiper.allowClick = true;
2753    return;
2754  }
2755  if (params.swipeHandler) {
2756    if (!$targetEl.closest(params.swipeHandler)[0]) return;
2757  }
2758
2759  touches.currentX = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
2760  touches.currentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
2761  const startX = touches.currentX;
2762  const startY = touches.currentY;
2763
2764  // Do NOT start if iOS edge swipe is detected. Otherwise iOS app (UIWebView) cannot swipe-to-go-back anymore
2765
2766  const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
2767  const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
2768  if (
2769    edgeSwipeDetection
2770    && ((startX <= edgeSwipeThreshold)
2771    || (startX >= win.screen.width - edgeSwipeThreshold))
2772  ) {
2773    return;
2774  }
2775
2776  Utils.extend(data, {
2777    isTouched: true,
2778    isMoved: false,
2779    allowTouchCallbacks: true,
2780    isScrolling: undefined,
2781    startMoving: undefined,
2782  });
2783
2784  touches.startX = startX;
2785  touches.startY = startY;
2786  data.touchStartTime = Utils.now();
2787  swiper.allowClick = true;
2788  swiper.updateSize();
2789  swiper.swipeDirection = undefined;
2790  if (params.threshold > 0) data.allowThresholdMove = false;
2791  if (e.type !== 'touchstart') {
2792    let preventDefault = true;
2793    if ($targetEl.is(data.formElements)) preventDefault = false;
2794    if (
2795      doc.activeElement
2796      && $(doc.activeElement).is(data.formElements)
2797      && doc.activeElement !== $targetEl[0]
2798    ) {
2799      doc.activeElement.blur();
2800    }
2801
2802    const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
2803    if (params.touchStartForcePreventDefault || shouldPreventDefault) {
2804      e.preventDefault();
2805    }
2806  }
2807  swiper.emit('touchStart', e);
2808}
2809
2810function onTouchMove (event) {
2811  const swiper = this;
2812  const data = swiper.touchEventsData;
2813  const { params, touches, rtlTranslate: rtl } = swiper;
2814  let e = event;
2815  if (e.originalEvent) e = e.originalEvent;
2816  if (!data.isTouched) {
2817    if (data.startMoving && data.isScrolling) {
2818      swiper.emit('touchMoveOpposite', e);
2819    }
2820    return;
2821  }
2822  if (data.isTouchEvent && e.type