https://plasticseurope.org/wp-content/themes/plasticseurope-theme/dist/scripts/block-content-slider.js

142/***/ (function(module, exports) {
143
144module.exports = jQuery;
145
146/***/ }),
147
148/***/ 4:
149/***/ (function(module, exports, __webpack_require__) {
150
151/**
152 * Swiper 8.4.7
153 * Most modern mobile touch slider and framework with hardware accelerated transitions
154 * https://swiperjs.com
155 *
156 * Copyright 2014-2023 Vladimir Kharlampidi
157 *
158 * Released under the MIT License
159 *
160 * Released on: January 30, 2023
161 */
162
163(function (global, factory) {
164     true ? module.exports = factory() :
165    typeof define === 'function' && define.amd ? define(factory) :
166    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Swiper = factory());
167})(this, (function () { 'use strict';
168
169    /**
170     * SSR Window 4.0.2
171     * Better handling for window object in SSR environment
172     * https://github.com/nolimits4web/ssr-window
173     *
174     * Copyright 2021, Vladimir Kharlampidi
175     *
176     * Licensed under MIT
177     *
178     * Released on: December 13, 2021
179     */
180
181    /* eslint-disable no-param-reassign */
182    function isObject$1(obj) {
183      return obj !== null && typeof obj === 'object' && 'constructor' in obj && obj.constructor === Object;
184    }
185
186    function extend$1(target, src) {
187      if (target === void 0) {
188        target = {};
189      }
190
191      if (src === void 0) {
192        src = {};
193      }
194
195      Object.keys(src).forEach(key => {
196        if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject$1(src[key]) && isObject$1(target[key]) && Object.keys(src[key]).length > 0) {
197          extend$1(target[key], src[key]);
198        }
199      });
200    }
201
202    const ssrDocument = {
203      body: {},
204
205      addEventListener() {},
206
207      removeEventListener() {},
208
209      activeElement: {
210        blur() {},
211
212        nodeName: ''
213      },
214
215      querySelector() {
216        return null;
217      },
218
219      querySelectorAll() {
220        return [];
221      },
222
223      getElementById() {
224        return null;
225      },
226
227      createEvent() {
228        return {
229          initEvent() {}
230
231        };
232      },
233
234      createElement() {
235        return {
236          children: [],
237          childNodes: [],
238          style: {},
239
240          setAttribute() {},
241
242          getElementsByTagName() {
243            return [];
244          }
245
246        };
247      },
248
249      createElementNS() {
250        return {};
251      },
252
253      importNode() {
254        return null;
255      },
256
257      location: {
258        hash: '',
259        host: '',
260        hostname: '',
261        href: '',
262        origin: '',
263        pathname: '',
264        protocol: '',
265        search: ''
266      }
267    };
268
269    function getDocument() {
270      const doc = typeof document !== 'undefined' ? document : {};
271      extend$1(doc, ssrDocument);
272      return doc;
273    }
274
275    const ssrWindow = {
276      document: ssrDocument,
277      navigator: {
278        userAgent: ''
279      },
280      location: {
281        hash: '',
282        host: '',
283        hostname: '',
284        href: '',
285        origin: '',
286        pathname: '',
287        protocol: '',
288        search: ''
289      },
290      history: {
291        replaceState() {},
292
293        pushState() {},
294
295        go() {},
296
297        back() {}
298
299      },
300      CustomEvent: function CustomEvent() {
301        return this;
302      },
303
304      addEventListener() {},
305
306      removeEventListener() {},
307
308      getComputedStyle() {
309        return {
310          getPropertyValue() {
311            return '';
312          }
313
314        };
315      },
316
317      Image() {},
318
319      Date() {},
320
321      screen: {},
322
323      setTimeout() {},
324
325      clearTimeout() {},
326
327      matchMedia() {
328        return {};
329      },
330
331      requestAnimationFrame(callback) {
332        if (typeof setTimeout === 'undefined') {
333          callback();
334          return null;
335        }
336
337        return setTimeout(callback, 0);
338      },
339
340      cancelAnimationFrame(id) {
341        if (typeof setTimeout === 'undefined') {
342          return;
343        }
344
345        clearTimeout(id);
346      }
347
348    };
349
350    function getWindow() {
351      const win = typeof window !== 'undefined' ? window : {};
352      extend$1(win, ssrWindow);
353      return win;
354    }
355
356    /**
357     * Dom7 4.0.4
358     * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API
359     * https://framework7.io/docs/dom7.html
360     *
361     * Copyright 2022, Vladimir Kharlampidi
362     *
363     * Licensed under MIT
364     *
365     * Released on: January 11, 2022
366     */
367    /* eslint-disable no-proto */
368
369    function makeReactive(obj) {
370      const proto = obj.__proto__;
371      Object.defineProperty(obj, '__proto__', {
372        get() {
373          return proto;
374        },
375
376        set(value) {
377          proto.__proto__ = value;
378        }
379
380      });
381    }
382
383    class Dom7 extends Array {
384      constructor(items) {
385        if (typeof items === 'number') {
386          super(items);
387        } else {
388          super(...(items || []));
389          makeReactive(this);
390        }
391      }
392
393    }
394
395    function arrayFlat(arr) {
396      if (arr === void 0) {
397        arr = [];
398      }
399
400      const res = [];
401      arr.forEach(el => {
402        if (Array.isArray(el)) {
403          res.push(...arrayFlat(el));
404        } else {
405          res.push(el);
406        }
407      });
408      return res;
409    }
410
411    function arrayFilter(arr, callback) {
412      return Array.prototype.filter.call(arr, callback);
413    }
414
415    function arrayUnique(arr) {
416      const uniqueArray = [];
417
418      for (let i = 0; i < arr.length; i += 1) {

419        if (uniqueArray.indexOf(arr[i]) === -1) uniqueArray.push(arr[i]);
420      }
421
422      return uniqueArray;
423    }
424
425
426    function qsa(selector, context) {
427      if (typeof selector !== 'string') {
428        return [selector];
429      }
430
431      const a = [];
432      const res = context.querySelectorAll(selector);
433
434      for (let i = 0; i < res.length; i += 1) {
435        a.push(res[i]);
436      }
437
438      return a;
439    }
440
441    function $(selector, context) {
442      const window = getWindow();
443      const document = getDocument();
444      let arr = [];
445
446      if (!context && selector instanceof Dom7) {
447        return selector;
448      }
449
450      if (!selector) {
451        return new Dom7(arr);
452      }
453
454      if (typeof selector === 'string') {
455        const html = selector.trim();
456
457        if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {
458          let toCreate = 'div';
459          if (html.indexOf('<li') === 0) toCreate = 'ul';
460          if (html.indexOf('<tr') === 0) toCreate = 'tbody';
461          if (html.indexOf('<td') === 0 || html.indexOf('<th') === 0) toCreate = 'tr';
462          if (html.indexOf('<tbody') === 0) toCreate = 'table';
463          if (html.indexOf('<option') === 0) toCreate = 'select';
464          const tempParent = document.createElement(toCreate);
465          tempParent.innerHTML = html;
466
467          for (let i = 0; i < tempParent.childNodes.length; i += 1) {
468            arr.push(tempParent.childNodes[i]);
469          }
470        } else {
471          arr = qsa(selector.trim(), context || document);
472        } // arr = qsa(selector, document);
473
474      } else if (selector.nodeType || selector === window || selector === document) {
475        arr.push(selector);
476      } else if (Array.isArray(selector)) {
477        if (selector instanceof Dom7) return selector;
478        arr = selector;
479      }
480
481      return new Dom7(arrayUnique(arr));
482    }
483
484    $.fn = Dom7.prototype; // eslint-disable-next-line
485
486    function addClass() {
487      for (var _len = arguments.length, classes = new Array(_len), _key = 0; _key < _len; _key++) {
488        classes[_key] = arguments[_key];
489      }
490
491      const classNames = arrayFlat(classes.map(c => c.split(' ')));
492      this.forEach(el => {
493        el.classList.add(...classNames);
494      });
495      return this;
496    }
497
498    function removeClass() {
499      for (var _len2 = arguments.length, classes = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
500        classes[_key2] = arguments[_key2];
501      }
502
503      const classNames = arrayFlat(classes.map(c => c.split(' ')));
504      this.forEach(el => {
505        el.classList.remove(...classNames);
506      });
507      return this;
508    }
509
510    function toggleClass() {
511      for (var _len3 = arguments.length, classes = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
512        classes[_key3] = arguments[_key3];
513      }
514
515      const classNames = arrayFlat(classes.map(c => c.split(' ')));
516      this.forEach(el => {
517        classNames.forEach(className => {
518          el.classList.toggle(className);
519        });
520      });
521    }
522
523    function hasClass() {
524      for (var _len4 = arguments.length, classes = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
525        classes[_key4] = arguments[_key4];
526      }
527
528      const classNames = arrayFlat(classes.map(c => c.split(' ')));
529      return arrayFilter(this, el => {
530        return classNames.filter(className => el.classList.contains(className)).length > 0;
531      }).length > 0;
532    }
533
534    function attr(attrs, value) {
535      if (arguments.length === 1 && typeof attrs === 'string') {
536        // Get attr
537        if (this[0]) return this[0].getAttribute(attrs);
538        return undefined;
539      } // Set attrs
540
541
542      for (let i = 0; i < this.length; i += 1) {
543        if (arguments.length === 2) {
544          // String
545          this[i].setAttribute(attrs, value);
546        } else {
547          // Object
548          for (const attrName in attrs) {
549            this[i][attrName] = attrs[attrName];
550            this[i].setAttribute(attrName, attrs[attrName]);
551          }
552        }
553      }
554
555      return this;
556    }
557
558    function removeAttr(attr) {
559      for (let i = 0; i < this.length; i += 1) {
560        this[i].removeAttribute(attr);
561      }
562
563      return this;
564    }
565
566    function transform(transform) {
567      for (let i = 0; i < this.length; i += 1) {
568        this[i].style.transform = transform;
569      }
570
571      return this;
572    }
573
574    function transition$1(duration) {
575      for (let i = 0; i < this.length; i += 1) {
576        this[i].style.transitionDuration = typeof duration !== 'string' ? `${duration}ms` : duration;
577      }
578
579      return this;
580    }
581
582    function on() {
583      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
584        args[_key5] = arguments[_key5];
585      }
586
587      let [eventType, targetSelector, listener, capture] = args;
588
589      if (typeof args[1] === 'function') {
590        [eventType, listener, capture] = args;
591        targetSelector = undefined;
592      }
593
594      if (!capture) capture = false;
595
596      function handleLiveEvent(e) {
597        const target = e.target;
598        if (!target) return;
599        const eventData = e.target.dom7EventData || [];
600
601        if (eventData.indexOf(e) < 0) {
602          eventData.unshift(e);
603        }
604
605        if ($(target).is(targetSelector)) listener.apply(target, eventData);else {
606          const parents = $(target).parents(); // eslint-disable-line
607
608          for (let k = 0; k < parents.length; k += 1) {
609            if ($(parents[k]).is(targetSelector)) listener.apply(parents[k], eventData);
610          }
611        }
612      }
613
614      function handleEvent(e) {
615        const eventData = e && e.target ? e.target.dom7EventData || [] : [];
616
617        if (eventData.indexOf(e) < 0) {
618          eventData.unshift(e);
619        }
620
621        listener.apply(this, eventData);
622      }
623
624      const events = eventType.split(' ');
625      let j;
626
627      for (let i = 0; i < this.length; i += 1) {
628        const el = this[i];
629
630        if (!targetSelector) {
631          for (j = 0; j < events.length; j += 1) {
632            const event = events[j];
633            if (!el.dom7Listeners) el.dom7Listeners = {};
634            if (!el.dom7Listeners[event]) el.dom7Listeners[event] = [];
635            el.dom7Listeners[event].push({
636              listener,
637              proxyListener: handleEvent
638            });
639            el.addEventListener(event, handleEvent, capture);
640          }
641        } else {
642          // Live events
643          for (j = 0; j < events.length; j += 1) {
644            const event = events[j];
645            if (!el.dom7LiveListeners) el.dom7LiveListeners = {};
646            if (!el.dom7LiveListeners[event]) el.dom7LiveListeners[event] = [];
647            el.dom7LiveListeners[event].push({
648              listener,
649              proxyListener: handleLiveEvent
650            });
651            el.addEventListener(event, handleLiveEvent, capture);
652          }
653        }
654      }
655
656      return this;
657    }
658
659    function off() {
660      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
661        args[_key6] = arguments[_key6];
662      }
663
664      let [eventType, targetSelector, listener, capture] = args;
665
666      if (typeof args[1] === 'function') {
667        [eventType, listener, capture] = args;
668        targetSelector = undefined;
669      }
670
671      if (!capture) capture = false;
672      const events = eventType.split(' ');
673
674      for (let i = 0; i < events.length; i += 1) {
675        const event = events[i];
676
677        for (let j = 0; j < this.length; j += 1) {
678          const el = this[j];
679          let handlers;
680
681          if (!targetSelector && el.dom7Listeners) {
682            handlers = el.dom7Listeners[event];
683          } else if (targetSelector && el.dom7LiveListeners) {
684            handlers = el.dom7LiveListeners[event];
685          }
686
687          if (handlers && handlers.length) {
688            for (let k = handlers.length - 1; k >= 0; k -= 1) {
689              const handler = handlers[k];
690
691              if (listener && handler.listener === listener) {
692                el.removeEventListener(event, handler.proxyListener, capture);
693                handlers.splice(k, 1);
694              } else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) {
695                el.removeEventListener(event, handler.proxyListener, capture);
696                handlers.splice(k, 1);
697              } else if (!listener) {
698                el.removeEventListener(event, handler.proxyListener, capture);
699                handlers.splice(k, 1);
700              }
701            }
702          }
703        }
704      }
705
706      return this;
707    }
708
709    function trigger() {
710      const window = getWindow();
711
712      for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
713        args[_key9] = arguments[_key9];
714      }
715
716      const events = args[0].split(' ');
717      const eventData = args[1];
718
719      for (let i = 0; i < events.length; i += 1) {
720        const event = events[i];
721
722        for (let j = 0; j < this.length; j += 1) {
723          const el = this[j];
724
725          if (window.CustomEvent) {
726            const evt = new window.CustomEvent(event, {
727              detail: eventData,
728              bubbles: true,
729              cancelable: true
730            });
731            el.dom7EventData = args.filter((data, dataIndex) => dataIndex > 0);
732            el.dispatchEvent(evt);
733            el.dom7EventData = [];
734            delete el.dom7EventData;
735          }
736        }
737      }
738
739      return this;
740    }
741
742    function transitionEnd$1(callback) {
743      const dom = this;
744
745      function fireCallBack(e) {
746        if (e.target !== this) return;
747        callback.call(this, e);
748        dom.off('transitionend', fireCallBack);
749      }
750
751      if (callback) {
752        dom.on('transitionend', fireCallBack);
753      }
754
755      return this;
756    }
757
758    function outerWidth(includeMargins) {
759      if (this.length > 0) {
760        if (includeMargins) {
761          const styles = this.styles();
762          return this[0].offsetWidth + parseFloat(styles.getPropertyValue('margin-right')) + parseFloat(styles.getPropertyValue('margin-left'));
763        }
764
765        return this[0].offsetWidth;
766      }
767
768      return null;
769    }
770
771    function outerHeight(includeMargins) {
772      if (this.length > 0) {
773        if (includeMargins) {
774          const styles = this.styles();
775          return this[0].offsetHeight + parseFloat(styles.getPropertyValue('margin-top')) + parseFloat(styles.getPropertyValue('margin-bottom'));
776        }
777
778        return this[0].offsetHeight;
779      }
780
781      return null;
782    }
783
784    function offset() {
785      if (this.length > 0) {
786        const window = getWindow();
787        const document = getDocument();
788        const el = this[0];
789        const box = el.getBoundingClientRect();
790        const body = document.body;
791        const clientTop = el.clientTop || body.clientTop || 0;
792        const clientLeft = el.clientLeft || body.clientLeft || 0;
793        const scrollTop = el === window ? window.scrollY : el.scrollTop;
794        const scrollLeft = el === window ? window.scrollX : el.scrollLeft;
795        return {
796          top: box.top + scrollTop - clientTop,
797          left: box.left + scrollLeft - clientLeft
798        };
799      }
800
801      return null;
802    }
803
804    function styles() {
805      const window = getWindow();
806      if (this[0]) return window.getComputedStyle(this[0], null);
807      return {};
808    }
809
810    function css(props, value) {
811      const window = getWindow();
812      let i;
813
814      if (arguments.length === 1) {
815        if (typeof props === 'string') {
816          // .css('width')
817          if (this[0]) return window.getComputedStyle(this[0], null).getPropertyValue(props);
818        } else {
819          // .css({ width: '100px' })
820          for (i = 0; i < this.length; i += 1) {
821            for (const prop in props) {
822              this[i].style[prop] = props[prop];
823            }
824          }
825
826          return this;
827        }
828      }
829
830      if (arguments.length === 2 && typeof props === 'string') {
831        // .css('width', '100px')
832        for (i = 0; i < this.length; i += 1) {
833          this[i].style[props] = value;
834        }
835
836        return this;
837      }
838
839      return this;
840    }
841
842    function each(callback) {
843      if (!callback) return this;
844      this.forEach((el, index) => {
845        callback.apply(el, [el, index]);
846      });
847      return this;
848    }
849
850    function filter(callback) {
851      const result = arrayFilter(this, callback);
852      return $(result);
853    }
854
855    function html(html) {
856      if (typeof html === 'undefined') {
857        return this[0] ? this[0].innerHTML : null;
858      }
859
860      for (let i = 0; i < this.length; i += 1) {
861        this[i].innerHTML = html;
862      }
863
864      return this;
865    }
866
867    function text(text) {
868      if (typeof text === 'undefined') {
869        return this[0] ? this[0].textContent.trim() : null;
870      }
871
872      for (let i = 0; i < this.length; i += 1) {
873        this[i].textContent = text;
874      }
875
876      return this;
877    }
878
879    function is(selector) {
880      const window = getWindow();
881      const document = getDocument();
882      const el = this[0];
883      let compareWith;
884      let i;
885      if (!el || typeof selector === 'undefined') return false;

886
887      if (typeof selector === 'string') {
888        if (el.matches) return el.matches(selector);
889        if (el.webkitMatchesSelector) return el.webkitMatchesSelector(selector);
890        if (el.msMatchesSelector) return el.msMatchesSelector(selector);
891        compareWith = $(selector);
892
893        for (i = 0; i < compareWith.length; i += 1) {
894          if (compareWith[i] === el) return true;
895        }
896
897        return false;
898      }
899
900      if (selector === document) {
901        return el === document;
902      }
903
904      if (selector === window) {
905        return el === window;
906      }
907
908      if (selector.nodeType || selector instanceof Dom7) {
909        compareWith = selector.nodeType ? [selector] : selector;
910
911        for (i = 0; i < compareWith.length; i += 1) {
912          if (compareWith[i] === el) return true;
913        }
914
915        return false;
916      }
917
918      return false;
919    }
920
921    function index() {
922      let child = this[0];
923      let i;
924
925      if (child) {
926        i = 0; // eslint-disable-next-line
927
928        while ((child = child.previousSibling) !== null) {
929          if (child.nodeType === 1) i += 1;
930        }
931
932        return i;
933      }
934
935      return undefined;
936    }
937
938    function eq(index) {
939      if (typeof index === 'undefined') return this;
940      const length = this.length;
941
942      if (index > length - 1) {
943        return $([]);
944      }
945
946      if (index < 0) {
947        const returnIndex = length + index;
948        if (returnIndex < 0) return $([]);
949        return $([this[returnIndex]]);
950      }
951
952      return $([this[index]]);
953    }
954
955    function append() {
956      let newChild;
957      const document = getDocument();
958
959      for (let k = 0; k < arguments.length; k += 1) {
960        newChild = k < 0 || arguments.length <= k ? undefined : arguments[k];
961
962        for (let i = 0; i < this.length; i += 1) {
963          if (typeof newChild === 'string') {
964            const tempDiv = document.createElement('div');
965            tempDiv.innerHTML = newChild;
966
967            while (tempDiv.firstChild) {
968              this[i].appendChild(tempDiv.firstChild);
969            }
970          } else if (newChild instanceof Dom7) {
971            for (let j = 0; j < newChild.length; j += 1) {
972              this[i].appendChild(newChild[j]);
973            }
974          } else {
975            this[i].appendChild(newChild);
976          }
977        }
978      }
979
980      return this;
981    }
982
983    function prepend(newChild) {
984      const document = getDocument();
985      let i;
986      let j;
987
988      for (i = 0; i < this.length; i += 1) {
989        if (typeof newChild === 'string') {
990          const tempDiv = document.createElement('div');
991          tempDiv.innerHTML = newChild;
992
993          for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
994            this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
995          }
996        } else if (newChild instanceof Dom7) {
997          for (j = 0; j < newChild.length; j += 1) {
998            this[i].insertBefore(newChild[j], this[i].childNodes[0]);
999          }
1000        } else {
1001          this[i].insertBefore(newChild, this[i].childNodes[0]);
1002        }
1003      }
1004
1005      return this;
1006    }
1007
1008    function next(selector) {
1009      if (this.length > 0) {
1010        if (selector) {
1011          if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {
1012            return $([this[0].nextElementSibling]);
1013          }
1014
1015          return $([]);
1016        }
1017
1018        if (this[0].nextElementSibling) return $([this[0].nextElementSibling]);
1019        return $([]);
1020      }
1021
1022      return $([]);
1023    }
1024
1025    function nextAll(selector) {
1026      const nextEls = [];
1027      let el = this[0];
1028      if (!el) return $([]);
1029
1030      while (el.nextElementSibling) {
1031        const next = el.nextElementSibling; // eslint-disable-line
1032
1033        if (selector) {
1034          if ($(next).is(selector)) nextEls.push(next);
1035        } else nextEls.push(next);
1036
1037        el = next;
1038      }
1039
1040      return $(nextEls);
1041    }
1042
1043    function prev(selector) {
1044      if (this.length > 0) {
1045        const el = this[0];
1046
1047        if (selector) {
1048          if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {
1049            return $([el.previousElementSibling]);
1050          }
1051
1052          return $([]);
1053        }
1054
1055        if (el.previousElementSibling) return $([el.previousElementSibling]);
1056        return $([]);
1057      }
1058
1059      return $([]);
1060    }
1061
1062    function prevAll(selector) {
1063      const prevEls = [];
1064      let el = this[0];
1065      if (!el) return $([]);
1066
1067      while (el.previousElementSibling) {
1068        const prev = el.previousElementSibling; // eslint-disable-line
1069
1070        if (selector) {
1071          if ($(prev).is(selector)) prevEls.push(prev);
1072        } else prevEls.push(prev);
1073
1074        el = prev;
1075      }
1076
1077      return $(prevEls);
1078    }
1079
1080    function parent(selector) {
1081      const parents = []; // eslint-disable-line
1082
1083      for (let i = 0; i < this.length; i += 1) {
1084        if (this[i].parentNode !== null) {
1085          if (selector) {
1086            if ($(this[i].parentNode).is(selector)) parents.push(this[i].parentNode);
1087          } else {
1088            parents.push(this[i].parentNode);
1089          }
1090        }
1091      }
1092
1093      return $(parents);
1094    }
1095
1096    function parents(selector) {
1097      const parents = []; // eslint-disable-line
1098
1099      for (let i = 0; i < this.length; i += 1) {
1100        let parent = this[i].parentNode; // eslint-disable-line
1101
1102        while (parent) {
1103          if (selector) {
1104            if ($(parent).is(selector)) parents.push(parent);
1105          } else {
1106            parents.push(parent);
1107          }
1108
1109          parent = parent.parentNode;
1110        }
1111      }
1112
1113      return $(parents);
1114    }
1115
1116    function closest(selector) {
1117      let closest = this; // eslint-disable-line
1118
1119      if (typeof selector === 'undefined') {
1120        return $([]);
1121      }
1122

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

1303ject.prototype.toString.call(o).slice(8, -1) === 'Object';
1304    }
1305
1306    function isNode(node) {
1307      // eslint-disable-next-line
1308      if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
1309        return node instanceof HTMLElement;
1310      }
1311
1312      return node && (node.nodeType === 1 || node.nodeType === 11);
1313    }
1314
1315    function extend() {
1316      const to = Object(arguments.length <= 0 ? undefined : arguments[0]);
1317      const noExtend = ['__proto__', 'constructor', 'prototype'];
1318
1319      for (let i = 1; i < arguments.length; i += 1) {
1320        const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
1321
1322        if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
1323          const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);
1324
1325          for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
1326            const nextKey = keysArray[nextIndex];
1327            const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
1328
1329            if (desc !== undefined && desc.enumerable) {
1330              if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1331                if (nextSource[nextKey].__swiper__) {
1332                  to[nextKey] = nextSource[nextKey];
1333                } else {
1334                  extend(to[nextKey], nextSource[nextKey]);
1335                }
1336              } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1337                to[nextKey] = {};
1338
1339                if (nextSource[nextKey].__swiper__) {
1340                  to[nextKey] = nextSource[nextKey];
1341                } else {
1342                  extend(to[nextKey], nextSource[nextKey]);
1343                }
1344              } else {
1345                to[nextKey] = nextSource[nextKey];
1346              }
1347            }
1348          }
1349        }
1350      }
1351
1352      return to;
1353    }
1354
1355    function setCSSProperty(el, varName, varValue) {
1356      el.style.setProperty(varName, varValue);
1357    }
1358
1359    function animateCSSModeScroll(_ref) {
1360      let {
1361        swiper,
1362        targetPosition,
1363        side
1364      } = _ref;
1365      const window = getWindow();
1366      const startPosition = -swiper.translate;
1367      let startTime = null;
1368      let time;
1369      const duration = swiper.params.speed;
1370      swiper.wrapperEl.style.scrollSnapType = 'none';
1371      window.cancelAnimationFrame(swiper.cssModeFrameID);
1372      const dir = targetPosition > startPosition ? 'next' : 'prev';
1373
1374      const isOutOfBound = (current, target) => {
1375        return dir === 'next' && current >= target || dir === 'prev' && current <= target;
1376      };
1377
1378      const animate = () => {
1379        time = new Date().getTime();
1380
1381        if (startTime === null) {
1382          startTime = time;
1383        }
1384
1385        const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
1386        const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;
1387        let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
1388
1389        if (isOutOfBound(currentPosition, targetPosition)) {
1390          currentPosition = targetPosition;
1391        }
1392
1393        swiper.wrapperEl.scrollTo({
1394          [side]: currentPosition
1395        });
1396
1397        if (isOutOfBound(currentPosition, targetPosition)) {
1398          swiper.wrapperEl.style.overflow = 'hidden';
1399          swiper.wrapperEl.style.scrollSnapType = '';
1400          setTimeout(() => {
1401            swiper.wrapperEl.style.overflow = '';
1402            swiper.wrapperEl.scrollTo({
1403              [side]: currentPosition
1404            });
1405          });
1406          window.cancelAnimationFrame(swiper.cssModeFrameID);
1407          return;
1408        }
1409
1410        swiper.cssModeFrameID = window.requestAnimationFrame(animate);
1411      };
1412
1413      animate();
1414    }
1415
1416    let support;
1417
1418    function calcSupport() {
1419      const window = getWindow();
1420      const document = getDocument();
1421      return {
1422        smoothScroll: document.documentElement && 'scrollBehavior' in document.documentElement.style,
1423        touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch),
1424        passiveListener: function checkPassiveListener() {
1425          let supportsPassive = false;

1426
1427          try {
1428            const opts = Object.defineProperty({}, 'passive', {
1429              // eslint-disable-next-line
1430              get() {
1431                supportsPassive = true;
1432              }
1433
1434            });
1435            window.addEventListener('testPassiveListener', null, opts);
1436          } catch (e) {// No support
1437          }
1438
1439          return supportsPassive;
1440        }(),
1441        gestures: function checkGestures() {
1442          return 'ongesturestart' in window;
1443        }()
1444      };
1445    }
1446
1447    function getSupport() {
1448      if (!support) {
1449        support = calcSupport();
1450      }
1451
1452      return support;
1453    }
1454
1455    let deviceCached;
1456
1457    function calcDevice(_temp) {
1458      let {
1459        userAgent
1460      } = _temp === void 0 ? {} : _temp;
1461      const support = getSupport();
1462      const window = getWindow();
1463      const platform = window.navigator.platform;
1464      const ua = userAgent || window.navigator.userAgent;
1465      const device = {
1466        ios: false,
1467        android: false
1468      };
1469      const screenWidth = window.screen.width;
1470      const screenHeight = window.screen.height;
1471      const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
1472
1473      let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
1474      const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
1475      const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
1476      const windows = platform === 'Win32';
1477      let macos = platform === 'MacIntel'; // iPadOs 13 fix
1478
1479      const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
1480
1481      if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
1482        ipad = ua.match(/(Version)\/([\d.]+)/);
1483        if (!ipad) ipad = [0, 1, '13_0_0'];
1484        macos = false;
1485      } // Android
1486
1487
1488      if (android && !windows) {
1489        device.os = 'android';
1490        device.android = true;
1491      }
1492
1493      if (ipad || iphone || ipod) {
1494        device.os = 'ios';
1495        device.ios = true;
1496      } // Export object
1497
1498
1499      return device;
1500    }
1501
1502    function getDevice(overrides) {
1503      if (overrides === void 0) {
1504        overrides = {};
1505      }
1506
1507      if (!deviceCached) {
1508        deviceCached = calcDevice(overrides);
1509      }
1510
1511      return deviceCached;
1512    }
1513
1514    let browser;
1515
1516    function calcBrowser() {
1517      const window = getWindow();
1518
1519      function isSafari() {
1520        const ua = window.navigator.userAgent.toLowerCase();
1521        return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
1522      }
1523
1524      return {
1525        isSafari: isSafari(),
1526        isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)
1527      };
1528    }
1529
1530    function getBrowser() {
1531      if (!browser) {
1532        browser = calcBrowser();
1533      }
1534
1535      return browser;
1536    }
1537
1538    function Resize(_ref) {
1539      let {
1540        swiper,
1541        on,
1542        emit
1543      } = _ref;
1544      const window = getWindow();
1545      let observer = null;
1546      let animationFrame = null;
1547
1548      const resizeHandler = () => {
1549        if (!swiper || swiper.destroyed || !swiper.initialized) return;
1550        emit('beforeResize');
1551        emit('resize');
1552      };
1553
1554      const createObserver = () => {
1555        if (!swiper || swiper.destroyed || !swiper.initialized) return;
1556        observer = new ResizeObserver(entries => {
1557          animationFrame = window.requestAnimationFrame(() => {
1558            const {
1559              width,
1560              height
1561            } = swiper;
1562            let newWidth = width;
1563            let newHeight = height;
1564            entries.forEach(_ref2 => {
1565              let {
1566                contentBoxSize,
1567                contentRect,
1568                target
1569              } = _ref2;
1570              if (target && target !== swiper.el) return;
1571              newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
1572              newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
1573            });
1574
1575            if (newWidth !== width || newHeight !== height) {
1576              resizeHandler();
1577            }
1578          });
1579        });
1580        observer.observe(swiper.el);
1581      };
1582
1583      const removeObserver = () => {
1584        if (animationFrame) {
1585          window.cancelAnimationFrame(animationFrame);
1586        }
1587
1588        if (observer && observer.unobserve && swiper.el) {
1589          observer.unobserve(swiper.el);
1590          observer = null;
1591        }
1592      };
1593
1594      const orientationChangeHandler = () => {
1595        if (!swiper || swiper.destroyed || !swiper.initialized) return;
1596        emit('orientationchange');
1597      };
1598
1599      on('init', () => {
1600        if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
1601          createObserver();
1602          return;
1603        }
1604
1605        window.addEventListener('resize', resizeHandler);
1606        window.addEventListener('orientationchange', orientationChangeHandler);
1607      });
1608      on('destroy', () => {
1609        removeObserver();
1610        window.removeEventListener('resize', resizeHandler);
1611        window.removeEventListener('orientationchange', orientationChangeHandler);
1612      });
1613    }
1614
1615    function Observer(_ref) {
1616      let {
1617        swiper,
1618        extendParams,
1619        on,
1620        emit
1621      } = _ref;
1622      const observers = [];
1623      const window = getWindow();
1624
1625      const attach = function (target, options) {
1626        if (options === void 0) {
1627          options = {};
1628        }
1629
1630        const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
1631        const observer = new ObserverFunc(mutations => {
1632          // The observerUpdate event should only be triggered
1633          // once despite the number of mutations.  Additional
1634          // triggers are redundant and are very costly
1635          if (mutations.length === 1) {
1636            emit('observerUpdate', mutations[0]);
1637            return;
1638          }
1639
1640          const observerUpdate = function observerUpdate() {
1641            emit('observerUpdate', mutations[0]);
1642          };
1643
1644          if (window.requestAnimationFrame) {
1645            window.requestAnimationFrame(observerUpdate);
1646          } else {
1647            window.setTimeout(observerUpdate, 0);
1648          }
1649        });
1650        observer.observe(target, {
1651          attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
1652          childList: typeof options.childList === 'undefined' ? true : options.childList,
1653          characterData: typeof options.characterData === 'undefined' ? true : options.characterData
1654        });
1655        observers.push(observer);
1656      };
1657
1658      const init = () => {
1659        if (!swiper.params.observer) return;
1660
1661        if (swiper.params.observeParents) {
1662          const containerParents = swiper.$el.parents();
1663
1664          for (let i = 0; i < containerParents.length; i += 1) {
1665            attach(containerParents[i]);
1666          }
1667        } // Observe container
1668
1669
1670        attach(swiper.$el[0], {
1671          childList: swiper.params.observeSlideChildren
1672        }); // Observe wrapper
1673
1674        attach(swiper.$wrapperEl[0], {
1675          attributes: false
1676        });
1677      };
1678
1679      const destroy = () => {
1680        observers.forEach(observer => {
1681          observer.disconnect();
1682        });
1683        observers.splice(0, observers.length);
1684      };
1685
1686      extendParams({
1687        observer: false,
1688        observeParents: false,
1689        observeSlideChildren: false
1690      });
1691      on('init', init);
1692      on('destroy', destroy);
1693    }
1694
1695    /* eslint-disable no-underscore-dangle */
1696    var eventsEmitter = {
1697      on(events, handler, priority) {
1698        const self = this;
1699        if (!self.eventsListeners || self.destroyed) return self;
1700        if (typeof handler !== 'function') return self;
1701        const method = priority ? 'unshift' : 'push';
1702        events.split(' ').forEach(event => {
1703          if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
1704          self.eventsListeners[event][method](handler);
1705        });
1706        return self;
1707      },
1708
1709      once(events, handler, priority) {
1710        const self = this;
1711        if (!self.eventsListeners || self.destroyed) return self;
1712        if (typeof handler !== 'function') return self;
1713
1714        function onceHandler() {
1715          self.off(events, onceHandler);
1716
1717          if (onceHandler.__emitterProxy) {
1718            delete onceHandler.__emitterProxy;
1719          }
1720
1721          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1722            args[_key] = arguments[_key];
1723          }
1724
1725          handler.apply(self, args);
1726        }
1727
1728        onceHandler.__emitterProxy = handler;
1729        return self.on(events, onceHandler, priority);
1730      },
1731
1732      onAny(handler, priority) {
1733        const self = this;
1734        if (!self.eventsListeners || self.destroyed) return self;
1735        if (typeof handler !== 'function') return self;
1736        const method = priority ? 'unshift' : 'push';
1737
1738        if (self.eventsAnyListeners.indexOf(handler) < 0) {
1739          self.eventsAnyListeners[method](handler);
1740        }
1741
1742        return self;
1743      },
1744
1745      offAny(handler) {
1746        const self = this;
1747        if (!self.eventsListeners || self.destroyed) return self;
1748        if (!self.eventsAnyListeners) return self;
1749        const index = self.eventsAnyListeners.indexOf(handler);
1750
1751        if (index >= 0) {
1752          self.eventsAnyListeners.splice(index, 1);
1753        }
1754
1755        return self;
1756      },
1757
1758      off(events, handler) {
1759        const self = this;
1760        if (!self.eventsListeners || self.destroyed) return self;
1761        if (!self.eventsListeners) return self;
1762        events.split(' ').forEach(event => {
1763          if (typeof handler === 'undefined') {
1764            self.eventsListeners[event] = [];
1765          } else if (self.eventsListeners[event]) {
1766            self.eventsListeners[event].forEach((eventHandler, index) => {
1767              if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
1768                self.eventsListeners[event].splice(index, 1);
1769              }
1770            });
1771          }
1772        });
1773        return self;
1774      },
1775
1776      emit() {
1777        const self = this;
1778        if (!self.eventsListeners || self.destroyed) return self;
1779        if (!self.eventsListeners) return self;
1780        let events;
1781        let data;
1782        let context;
1783
1784        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
1785          args[_key2] = arguments[_key2];
1786        }
1787
1788        if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1789          events = args[0];
1790          data = args.slice(1, args.length);
1791          context = self;
1792        } else {
1793          events = args[0].events;
1794          data = args[0].data;
1795          context = args[0].context || self;
1796        }
1797
1798        data.unshift(context);
1799        const eventsArray = Array.isArray(events) ? events : events.split(' ');
1800        eventsArray.forEach(event => {
1801          if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
1802            self.eventsAnyListeners.forEach(eventHandler => {
1803              eventHandler.apply(context, [event, ...data]);
1804            });
1805          }
1806
1807          if (self.eventsListeners && self.eventsListeners[event]) {
1808            self.eventsListeners[event].forEach(eventHandler => {
1809              eventHandler.apply(context, data);
1810            });
1811          }
1812        });
1813        return self;
1814      }
1815
1816    };
1817
1818    function updateSize() {
1819      const swiper = this;
1820      let width;
1821      let height;
1822      const $el = swiper.$el;
1823
1824      if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
1825        width = swiper.params.width;
1826      } else {
1827        width = $el[0].clientWidth;
1828      }
1829
1830      if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
1831        height = swiper.params.height;
1832      } else {
1833        height = $el[0].clientHeight;
1834      }
1835
1836      if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
1837        return;
1838      } // Subtract paddings
1839
1840
1841      width = width - parseInt($el.css('padding-left') || 0, 10) - parseInt($el.css('padding-right') || 0, 10);
1842      height = height - parseInt($el.css('padding-top') || 0, 10) - parseInt($el.css('padding-bottom') || 0, 10);
1843      if (Number.isNaN(width)) width = 0;
1844      if (Number.isNaN(height)) height = 0;
1845      Object.assign(swiper, {
1846        width,
1847        height,
1848        size: swiper.isHorizontal() ? width : height
1849      });
1850    }
1851
1852    function updateSlides() {
1853      const swiper = this;
1854
1855      function getDirectionLabel(property) {
1856        if (swiper.isHorizontal()) {
1857          return property;
1858        } // prettier-ignore
1859
1860
1861        return {
1862          'width': 'height',
1863          'margin-top': 'margin-left',
1864          'margin-bottom ': 'margin-right',
1865          'margin-left': 'margin-top',
1866          'margin-right': 'margin-bottom',
1867          'padding-left': 'padding-top',
1868          'padding-right': 'padding-bottom',
1869          'marginRight': 'marginBottom'
1870        }[property];
1871      }
1872
1873      function getDirectionPropertyValue(node, label) {
1874        return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);
1875      }
1876
1877      const params = swiper.params;
1878      const {
1879        $wrapperEl,
1880        size: swiperSize,
1881        rtlTranslate: rtl,
1882        wrongRTL
1883      } = swiper;
1884      const isVirtual = swiper.virtual && params.virtual.enabled;
1885      const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1886      const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);
1887      const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1888      let snapGrid = [];
1889      const slidesGrid = [];
1890      const slidesSizesGrid = [];
1891      let offsetBefore = params.slidesOffsetBefore;
1892
1893      if (typeof offsetBefore === 'function') {

1894        offsetBefore = params.slidesOffsetBefore.call(swiper);
1895      }
1896
1897      let offsetAfter = params.slidesOffsetAfter;
1898
1899      if (typeof offsetAfter === 'function') {
1900        offsetAfter = params.slidesOffsetAfter.call(swiper);
1901      }
1902
1903      const previousSnapGridLength = swiper.snapGrid.length;
1904      const previousSlidesGridLength = swiper.slidesGrid.length;
1905      let spaceBetween = params.spaceBetween;
1906      let slidePosition = -offsetBefore;
1907      let prevSlideSize = 0;
1908      let index = 0;
1909
1910      if (typeof swiperSize === 'undefined') {
1911        return;
1912      }
1913
1914      if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1915        spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
1916      }
1917
1918      swiper.virtualSize = -spaceBetween; // reset margins
1919
1920      if (rtl) slides.css({
1921        marginLeft: '',
1922        marginBottom: '',
1923        marginTop: ''
1924      });else slides.css({
1925        marginRight: '',
1926        marginBottom: '',
1927        marginTop: ''
1928      }); // reset cssMode offsets
1929
1930      if (params.centeredSlides && params.cssMode) {
1931        setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', '');
1932        setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', '');
1933      }
1934
1935      const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
1936
1937      if (gridEnabled) {
1938        swiper.grid.initSlides(slidesLength);
1939      } // Calc slides
1940
1941
1942      let slideSize;
1943      const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
1944        return typeof params.breakpoints[key].slidesPerView !== 'undefined';
1945      }).length > 0;
1946
1947      for (let i = 0; i < slidesLength; i += 1) {
1948        slideSize = 0;
1949        const slide = slides.eq(i);
1950
1951        if (gridEnabled) {
1952          swiper.grid.updateSlide(i, slide, slidesLength, getDirectionLabel);
1953        }
1954
1955        if (slide.css('display') === 'none') continue; // eslint-disable-line
1956
1957        if (params.slidesPerView === 'auto') {
1958          if (shouldResetSlideSize) {
1959            slides[i].style[getDirectionLabel('width')] = ``;
1960          }
1961
1962          const slideStyles = getComputedStyle(slide[0]);
1963          const currentTransform = slide[0].style.transform;
1964          const currentWebKitTransform = slide[0].style.webkitTransform;
1965
1966          if (currentTransform) {
1967            slide[0].style.transform = 'none';
1968          }
1969
1970          if (currentWebKitTransform) {
1971            slide[0].style.webkitTransform = 'none';
1972          }
1973
1974          if (params.roundLengths) {
1975            slideSize = swiper.isHorizontal() ? slide.outerWidth(true) : slide.outerHeight(true);
1976          } else {
1977            // eslint-disable-next-line
1978            const width = getDirectionPropertyValue(slideStyles, 'width');
1979            const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
1980            const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
1981            const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
1982            const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
1983            const boxSizing = slideStyles.getPropertyValue('box-sizing');
1984
1985            if (boxSizing && boxSizing === 'border-box') {
1986              slideSize = width + marginLeft + marginRight;
1987            } else {
1988              const {
1989                clientWidth,
1990                offsetWidth
1991              } = slide[0];
1992              slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1993            }
1994          }
1995
1996          if (currentTransform) {
1997            slide[0].style.transform = currentTransform;
1998          }
1999
2000          if (currentWebKitTransform) {
2001            slide[0].style.webkitTransform = currentWebKitTransform;
2002          }
2003
2004          if (params.roundLengths) slideSize = Math.floor(slideSize);
2005        } else {
2006          slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
2007          if (params.roundLengths) slideSize = Math.floor(slideSize);
2008
2009          if (slides[i]) {
2010            slides[i].style[getDirectionLabel('width')] = `${slideSize}px`;
2011          }
2012        }
2013
2014        if (slides[i]) {
2015          slides[i].swiperSlideSize = slideSize;
2016        }
2017
2018        slidesSizesGrid.push(slideSize);
2019
2020        if (params.centeredSlides) {
2021          slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
2022          if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
2023          if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
2024          if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
2025          if (params.roundLengths) slidePosition = Math.floor(slidePosition);
2026          if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
2027          slidesGrid.push(slidePosition);
2028        } else {
2029          if (params.roundLengths) slidePosition = Math.floor(slidePosition);
2030          if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
2031          slidesGrid.push(slidePosition);
2032          slidePosition = slidePosition + slideSize + spaceBetween;
2033        }
2034
2035        swiper.virtualSize += slideSize + spaceBetween;
2036        prevSlideSize = slideSize;
2037        index += 1;
2038      }
2039
2040      swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
2041
2042      if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
2043        $wrapperEl.css({
2044          width: `${swiper.virtualSize + params.spaceBetween}px`
2045        });
2046      }
2047
2048      if (params.setWrapperSize) {
2049        $wrapperEl.css({
2050          [getDirectionLabel('width')]: `${swiper.virtualSize + params.spaceBetween}px`
2051        });
2052      }
2053
2054      if (gridEnabled) {
2055        swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);
2056      } // Remove last grid elements depending on width
2057
2058
2059      if (!params.centeredSlides) {
2060        const newSlidesGrid = [];
2061
2062        for (let i = 0; i < snapGrid.length; i += 1) {
2063          let slidesGridItem = snapGrid[i];
2064          if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
2065
2066          if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
2067            newSlidesGrid.push(slidesGridItem);
2068          }
2069        }
2070
2071        snapGrid = newSlidesGrid;
2072
2073        if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
2074          snapGrid.push(swiper.virtualSize - swiperSize);
2075        }
2076      }
2077
2078      if (snapGrid.length === 0) snapGrid = [0];
2079
2080      if (params.spaceBetween !== 0) {
2081        const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');
2082        slides.filter((_, slideIndex) => {
2083          if (!params.cssMode) return true;
2084
2085          if (slideIndex === slides.length - 1) {
2086            return false;
2087          }
2088
2089          return true;
2090        }).css({
2091          [key]: `${spaceBetween}px`
2092        });
2093      }
2094
2095      if (params.centeredSlides && params.centeredSlidesBounds) {
2096        let allSlidesSize = 0;
2097        slidesSizesGrid.forEach(slideSizeValue => {
2098          allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
2099        });
2100        allSlidesSize -= params.spaceBetween;
2101        const maxSnap = allSlidesSize - swiperSize;
2102        snapGrid = snapGrid.map(snap => {
2103          if (snap < 0) return -offsetBefore;
2104          if (snap > maxSnap) return maxSnap + offsetAfter;
2105          return snap;
2106        });
2107      }
2108
2109      if (params.centerInsufficientSlides) {
2110        let allSlidesSize = 0;

2111        slidesSizesGrid.forEach(slideSizeValue => {
2112          allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
2113        });
2114        allSlidesSize -= params.spaceBetween;
2115
2116        if (allSlidesSize < swiperSize) {
2117          const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
2118          snapGrid.forEach((snap, snapIndex) => {
2119            snapGrid[snapIndex] = snap - allSlidesOffset;
2120          });
2121          slidesGrid.forEach((snap, snapIndex) => {
2122            slidesGrid[snapIndex] = snap + allSlidesOffset;
2123          });
2124        }
2125      }
2126
2127      Object.assign(swiper, {
2128        slides,
2129        snapGrid,
2130        slidesGrid,
2131        slidesSizesGrid
2132      });
2133
2134      if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
2135        setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
2136        setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
2137        const addToSnapGrid = -swiper.snapGrid[0];
2138        const addToSlidesGrid = -swiper.slidesGrid[0];
2139        swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
2140        swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
2141      }
2142
2143      if (slidesLength !== previousSlidesLength) {
2144        swiper.emit('slidesLengthChange');
2145      }
2146
2147      if (snapGrid.length !== previousSnapGridLength) {
2148        if (swiper.params.watchOverflow) swiper.checkOverflow();
2149        swiper.emit('snapGridLengthChange');
2150      }
2151
2152      if (slidesGrid.length !== previousSlidesGridLength) {
2153        swiper.emit('slidesGridLengthChange');
2154      }
2155
2156      if (params.watchSlidesProgress) {
2157        swiper.updateSlidesOffset();
2158      }
2159
2160      if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
2161        const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
2162        const hasClassBackfaceClassAdded = swiper.$el.hasClass(backFaceHiddenClass);
2163
2164        if (slidesLength <= params.maxBackfaceHiddenSlides) {
2165          if (!hasClassBackfaceClassAdded) swiper.$el.addClass(backFaceHiddenClass);
2166        } else if (hasClassBackfaceClassAdded) {
2167          swiper.$el.removeClass(backFaceHiddenClass);
2168        }
2169      }
2170    }
2171
2172    function updateAutoHeight(speed) {
2173      const swiper = this;
2174      const activeSlides = [];
2175      const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2176      let newHeight = 0;
2177      let i;
2178
2179      if (typeof speed === 'number') {
2180        swiper.setTransition(speed);
2181      } else if (speed === true) {
2182        swiper.setTransition(swiper.params.speed);
2183      }
2184
2185      const getSlideByIndex = index => {
2186        if (isVirtual) {
2187          return swiper.slides.filter(el => parseInt(el.getAttribute('data-swiper-slide-index'), 10) === index)[0];
2188        }
2189
2190        return swiper.slides.eq(index)[0];
2191      }; // Find slides currently in view
2192
2193
2194      if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
2195        if (swiper.params.centeredSlides) {
2196          (swiper.visibleSlides || $([])).each(slide => {
2197            activeSlides.push(slide);
2198          });
2199        } else {
2200          for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
2201            const index = swiper.activeIndex + i;
2202            if (index > swiper.slides.length && !isVirtual) break;
2203            activeSlides.push(getSlideByIndex(index));
2204          }
2205        }
2206      } else {
2207        activeSlides.push(getSlideByIndex(swiper.activeIndex));
2208      } // Find new height from highest slide in view
2209
2210
2211      for (i = 0; i < activeSlides.length; i += 1) {
2212        if (typeof activeSlides[i] !== 'undefined') {
2213          const height = activeSlides[i].offsetHeight;
2214          newHeight = height > newHeight ? height : newHeight;
2215        }
2216      } // Update Height
2217
2218
2219      if (newHeight || newHeight === 0) swiper.$wrapperEl.css('height', `${newHeight}px`);
2220    }
2221
2222    function updateSlidesOffset() {
2223      const swiper = this;
2224      const slides = swiper.slides;
2225
2226      for (let i = 0; i < slides.length; i += 1) {
2227        slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;
2228      }
2229    }
2230
2231    function updateSlidesProgress(translate) {
2232      if (translate === void 0) {
2233        translate = this && this.translate || 0;
2234      }
2235
2236      const swiper = this;
2237      const params = swiper.params;
2238      const {
2239        slides,
2240        rtlTranslate: rtl,
2241        snapGrid
2242      } = swiper;
2243      if (slides.length === 0) return;
2244      if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
2245      let offsetCenter = -translate;
2246      if (rtl) offsetCenter = translate; // Visible Slides
2247
2248      slides.removeClass(params.slideVisibleClass);
2249      swiper.visibleSlidesIndexes = [];
2250      swiper.visibleSlides = [];
2251
2252      for (let i = 0; i < slides.length; i += 1) {
2253        const slide = slides[i];
2254        let slideOffset = slide.swiperSlideOffset;
2255
2256        if (params.cssMode && params.centeredSlides) {
2257          slideOffset -= slides[0].swiperSlideOffset;
2258        }
2259
2260        const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2261        const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
2262        const slideBefore = -(offsetCenter - slideOffset);
2263        const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
2264        const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
2265
2266        if (isVisible) {
2267          swiper.visibleSlides.push(slide);
2268          swiper.visibleSlidesIndexes.push(i);
2269          slides.eq(i).addClass(params.slideVisibleClass);
2270        }
2271
2272        slide.progress = rtl ? -slideProgress : slideProgress;
2273        slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
2274      }
2275
2276      swiper.visibleSlides = $(swiper.visibleSlides);
2277    }
2278
2279    function updateProgress(translate) {
2280      const swiper = this;
2281
2282      if (typeof translate === 'undefined') {
2283        const multiplier = swiper.rtlTranslate ? -1 : 1; // eslint-disable-next-line
2284
2285        translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
2286      }
2287
2288      const params = swiper.params;
2289      const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2290      let {
2291        progress,
2292        isBeginning,
2293        isEnd
2294      } = swiper;
2295      const wasBeginning = isBeginning;
2296      const wasEnd = isEnd;
2297
2298      if (translatesDiff === 0) {
2299        progress = 0;
2300        isBeginning = true;
2301        isEnd = true;
2302      } else {
2303        progress = (translate - swiper.minTranslate()) / translatesDiff;
2304        isBeginning = progress <= 0;
2305        isEnd = progress >= 1;
2306      }
2307
2308      Object.assign(swiper, {
2309        progress,
2310        isBeginning,
2311        isEnd
2312      });
2313      if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
2314
2315      if (isBeginning && !wasBeginning) {
2316        swiper.emit('reachBeginning toEdge');
2317      }
2318
2319      if (isEnd && !wasEnd) {
2320        swiper.emit('reachEnd toEdge');
2321      }
2322
2323      if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
2324        swiper.emit('fromEdge');
2325      }
2326
2327      swiper.emit('progress', progress);
2328    }
2329
2330    function updateSlidesClasses() {
2331      const swiper = this;
2332      const {
2333        slides,
2334        params,
2335        $wrapperEl,
2336        activeIndex,
2337        realIndex
2338      } = swiper;
2339      const isVirtual = swiper.virtual && params.virtual.enabled;
2340      slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);
2341      let activeSlide;
2342
2343      if (isVirtual) {
2344        activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index="${activeIndex}"]`);
2345      } else {
2346        activeSlide = slides.eq(activeIndex);
2347      } // Active classes
2348
2349
2350      activeSlide.addClass(params.slideActiveClass);
2351
2352      if (params.loop) {
2353        // Duplicate to all looped slides
2354        if (activeSlide.hasClass(params.slideDuplicateClass)) {
2355          $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
2356        } else {
2357          $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
2358        }
2359      } // Next Slide
2360
2361
2362      let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);
2363
2364      if (params.loop && nextSlide.length === 0) {
2365        nextSlide = slides.eq(0);
2366        nextSlide.addClass(params.slideNextClass);
2367      } // Prev Slide
2368
2369
2370      let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);
2371
2372      if (params.loop && prevSlide.length === 0) {
2373        prevSlide = slides.eq(-1);
2374        prevSlide.addClass(params.slidePrevClass);
2375      }
2376
2377      if (params.loop) {
2378        // Duplicate to all looped slides
2379        if (nextSlide.hasClass(params.slideDuplicateClass)) {
2380          $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicateNextClass);
2381        } else {
2382          $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${nextSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicateNextClass);
2383        }
2384
2385        if (prevSlide.hasClass(params.slideDuplicateClass)) {
2386          $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicatePrevClass);
2387        } else {
2388          $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${prevSlide.attr('data-swiper-slide-index')}"]`).addClass(params.slideDuplicatePrevClass);
2389        }
2390      }
2391
2392      swiper.emitSlidesClasses();
2393    }
2394
2395    function updateActiveIndex(newActiveIndex) {
2396      const swiper = this;
2397      const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2398      const {
2399        slidesGrid,
2400        snapGrid,
2401        params,
2402        activeIndex: previousIndex,
2403        realIndex: previousRealIndex,
2404        snapIndex: previousSnapIndex
2405      } = swiper;
2406      let activeIndex = newActiveIndex;
2407      let snapIndex;
2408
2409      if (typeof activeIndex === 'undefined') {
2410        for (let i = 0; i < slidesGrid.length; i += 1) {
2411          if (typeof slidesGrid[i + 1] !== 'undefined') {
2412            if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
2413              activeIndex = i;
2414            } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
2415              activeIndex = i + 1;
2416            }
2417          } else if (translate >= slidesGrid[i]) {
2418            activeIndex = i;
2419          }
2420        } // Normalize slideIndex
2421
2422
2423        if (params.normalizeSlideIndex) {
2424          if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
2425        }
2426      }
2427
2428      if (snapGrid.indexOf(translate) >= 0) {
2429        snapIndex = snapGrid.indexOf(translate);
2430      } else {
2431        const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
2432        snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
2433      }
2434
2435      if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2436
2437      if (activeIndex === previousIndex) {
2438        if (snapIndex !== previousSnapIndex) {
2439          swiper.snapIndex = snapIndex;
2440          swiper.emit('snapIndexChange');
2441        }
2442
2443        return;
2444      } // Get real index
2445
2446
2447      const realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);
2448      Object.assign(swiper, {
2449        snapIndex,
2450        realIndex,
2451        previousIndex,
2452        activeIndex
2453      });
2454      swiper.emit('activeIndexChange');
2455      swiper.emit('snapIndexChange');
2456
2457      if (previousRealIndex !== realIndex) {
2458        swiper.emit('realIndexChange');
2459      }
2460
2461      if (swiper.initialized || swiper.params.runCallbacksOnInit) {
2462        swiper.emit('slideChange');
2463      }
2464    }
2465
2466    function updateClickedSlide(e) {
2467      const swiper = this;
2468      const params = swiper.params;
2469      const slide = $(e).closest(`.${params.slideClass}`)[0];
2470      let slideFound = false;
2471      let slideIndex;
2472
2473      if (slide) {
2474        for (let i = 0; i < swiper.slides.length; i += 1) {
2475          if (swiper.slides[i] === slide) {
2476            slideFound = true;
2477            slideIndex = i;
2478            break;
2479          }
2480        }
2481      }
2482
2483      if (slide && slideFound) {
2484        swiper.clickedSlide = slide;
2485
2486        if (swiper.virtual && swiper.params.virtual.enabled) {
2487          swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);
2488        } else {
2489          swiper.clickedIndex = slideIndex;
2490        }
2491      } else {
2492        swiper.clickedSlide = undefined;
2493        swiper.clickedIndex = undefined;
2494        return;
2495      }
2496
2497      if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
2498        swiper.slideToClickedSlide();
2499      }
2500    }
2501
2502    var update = {
2503      updateSize,
2504      updateSlides,
2505      updateAutoHeight,
2506      updateSlidesOffset,
2507      updateSlidesProgress,
2508      updateProgress,
2509      updateSlidesClasses,
2510      updateActiveIndex,
2511      updateClickedSlide
2512    };
2513
2514    function getSwiperTranslate(axis) {
2515      if (axis === void 0) {
2516        axis = this.isHorizontal() ? 'x' : 'y';
2517      }
2518
2519      const swiper = this;
2520      const {
2521        params,
2522        rtlTranslate: rtl,
2523        translate,
2524        $wrapperEl
2525      } = swiper;
2526
2527      if (params.virtualTranslate) {
2528        return rtl ? -translate : translate;
2529      }
2530
2531      if (params.cssMode) {
2532        return translate;
2533      }
2534
2535      let currentTranslate = getTranslate($wrapperEl[0], axis);
2536      if (rtl) currentTranslate = -currentTranslate;
2537      return currentTranslate || 0;
2538    }
2539
2540    function setTranslate(translate, byController) {
2541      const swiper = this;
2542      const {
2543        rtlTranslate: rtl,
2544        params,
2545        $wrapperEl,
2546        wrapperEl,
2547        progress
2548      } = swiper;
2549      let x = 0;
2550      let y = 0;
2551      const z = 0;
2552
2553      if (swiper.isHorizontal()) {
2554        x = rtl ? -translate : translate;
2555      } else {
2556        y = translate;
2557      }
2558
2559      if (params.roundLengths) {
2560        x = Math.floor(x);
2561        y = Math.floor(y);
2562      }
2563
2564      if (params.cssMode) {
2565        wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
2566      } else if (!params.virtualTranslate) {
2567        $wrapperEl.transform(`translate3d(${x}px, ${y}px, ${z}px)`);
2568      }
2569
2570      swiper.previousTranslate = swiper.translate;
2571      swiper.translate = swiper.isHorizontal() ? x : y; // Check if we need to update progress
2572
2573      let newProgress;
2574      const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2575
2576      if (translatesDiff === 0) {
2577        newProgress = 0;
2578      } else {
2579        newProgress = (translate - swiper.minTranslate()) / translatesDiff;
2580      }
2581
2582      if (newProgress !== progress) {
2583        swiper.updateProgress(translate);
2584      }
2585
2586      swiper.emit('setTranslate', swiper.translate, byController);
2587    }
2588
2589    function minTranslate() {
2590      return -this.snapGrid[0];
2591    }
2592
2593    function maxTranslate() {
2594      return -this.snapGrid[this.snapGrid.length - 1];
2595    }
2596
2597    function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
2598      if (translate === void 0) {
2599        translate = 0;
2600      }
2601
2602      if (speed === void 0) {
2603        speed = this.params.speed;
2604      }
2605
2606      if (runCallbacks === void 0) {
2607        runCallbacks = true;
2608      }
2609
2610      if (translateBounds === void 0) {
2611        translateBounds = true;
2612      }
2613
2614      const swiper = this;
2615      const {
2616        params,
2617        wrapperEl
2618      } = swiper;
2619
2620      if (swiper.animating && params.preventInteractionOnTransition) {
2621        return false;
2622      }
2623
2624      const minTranslate = swiper.minTranslate();
2625      const maxTranslate = swiper.maxTranslate();
2626      let newTranslate;
2627      if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate; // Update progress
2628
2629      swiper.updateProgress(newTranslate);
2630
2631      if (params.cssMode) {
2632        const isH = swiper.isHorizontal();
2633
2634        if (speed === 0) {
2635          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
2636        } else {
2637          if (!swiper.support.smoothScroll) {
2638            animateCSSModeScroll({
2639              swiper,
2640              targetPosition: -newTranslate,
2641              side: isH ? 'left' : 'top'
2642            });
2643            return true;
2644          }
2645
2646          wrapperEl.scrollTo({
2647            [isH ? 'left' : 'top']: -newTranslate,
2648            behavior: 'smooth'
2649          });
2650        }
2651
2652        return true;
2653      }
2654
2655      if (speed === 0) {
2656        swiper.setTransition(0);
2657        swiper.setTranslate(newTranslate);
2658
2659        if (runCallbacks) {
2660          swiper.emit('beforeTransitionStart', speed, internal);
2661          swiper.emit('transitionEnd');
2662        }
2663      } else {
2664        swiper.setTransition(speed);
2665        swiper.setTranslate(newTranslate);
2666
2667        if (runCallbacks) {
2668          swiper.emit('beforeTransitionStart', speed, internal);
2669          swiper.emit('transitionStart');
2670        }
2671
2672        if (!swiper.animating) {
2673          swiper.animating = true;
2674
2675          if (!swiper.onTranslateToWrapperTransitionEnd) {
2676            swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
2677              if (!swiper || swiper.destroyed) return;
2678              if (e.target !== this) return;
2679              swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2680              swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2681              swiper.onTranslateToWrapperTransitionEnd = null;
2682              delete swiper.onTranslateToWrapperTransitionEnd;
2683
2684              if (runCallbacks) {
2685                swiper.emit('transitionEnd');
2686              }
2687            };
2688          }
2689
2690          swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
2691          swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);
2692        }
2693      }
2694
2695      return true;
2696    }
2697
2698    var translate = {
2699      getTranslate: getSwiperTranslate,
2700      setTranslate,
2701      minTranslate,
2702      maxTranslate,
2703      translateTo
2704    };
2705
2706    function setTransition(duration, byController) {
2707      const swiper = this;
2708
2709      if (!swiper.params.cssMode) {
2710        swiper.$wrapperEl.transition(duration);
2711      }
2712
2713      swiper.emit('setTransition', duration, byController);
2714    }
2715
2716    function transitionEmit(_ref) {
2717      let {
2718        swiper,
2719        runCallbacks,
2720        direction,
2721        step
2722      } = _ref;
2723      const {
2724        activeIndex,
2725        previousIndex
2726      } = swiper;
2727      let dir = direction;
2728
2729      if (!dir) {
2730        if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
2731      }
2732
2733      swiper.emit(`transition${step}`);
2734
2735      if (runCallbacks && activeIndex !== previousIndex) {
2736        if (dir === 'reset') {
2737          swiper.emit(`slideResetTransition${step}`);
2738          return;
2739        }
2740
2741        swiper.emit(`slideChangeTransition${step}`);
2742
2743        if (dir === 'next') {
2744          swiper.emit(`slideNextTransition${step}`);
2745        } else {
2746          swiper.emit(`slidePrevTransition${step}`);
2747        }
2748      }
2749    }
2750
2751    function transitionStart(runCallbacks, direction) {
2752      if (runCallbacks === void 0) {
2753        runCallbacks = true;
2754      }
2755
2756      const swiper = this;
2757      const {
2758        params
2759      } = swiper;
2760      if (params.cssMode) return;
2761
2762      if (params.autoHeight) {
2763        swiper.updateAutoHeight();
2764      }
2765
2766      transitionEmit({
2767        swiper,
2768        runCallbacks,
2769        direction,
2770        step: 'Start'
2771      });
2772    }
2773
2774    function transitionEnd(runCallbacks, direction) {
2775      if (runCallbacks === void 0) {
2776        runCallbacks = true;
2777      }
2778
2779      const swiper = this;
2780      const {
2781        params
2782      } = swiper;
2783      swiper.animating = false;
2784      if (params.cssMode) return;
2785      swiper.setTransition(0);
2786      transitionEmit({
2787        swiper,
2788        runCallbacks,
2789        direction,
2790        step: 'End'
2791      });
2792    }
2793
2794    var transition = {
2795      setTransition,
2796      transitionStart,
2797      transitionEnd
2798    };
2799
2800    function slideTo(index, speed, runCallbacks, internal, initial) {
2801      if (index === void 0) {
2802        index = 0;
2803      }
2804
2805      if (speed === void 0) {
2806        speed = this.params.speed;
2807      }
2808
2809      if (runCallbacks === void 0) {
2810        runCallbacks = true;
2811      }
2812
2813      if (typeof index !== 'number' && typeof index !== 'string') {
2814        throw new Error(`The 'index' argument cannot have type other than 'number' or 'string'. [${typeof index}] given.`);
2815      }
2816
2817      if (typeof index === 'string') {
2818        /**
2819         * The `index` argument converted from `string` to `number`.
2820         * @type {number}
2821         */
2822        const indexAsNumber = parseInt(index, 10);
2823        /**
2824         * Determines whether the `index` argument is a valid `number`
2825         * after being converted from the `string` type.
2826         * @type {boolean}
2827         */
2828
2829        const isValidNumber = isFinite(indexAsNumber);
2830
2831        if (!isValidNumber) {
2832          throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);
2833        } // Knowing that the converted `index` is a valid number,
2834        // we can update the original argument's value.
2835
2836
2837        index = indexAsNumber;
2838      }
2839
2840      const swiper = this;
2841      let slideIndex = index;
2842      if (slideIndex < 0) slideIndex = 0;
2843      const {
2844        params,
2845        snapGrid,
2846        slidesGrid,
2847        previousIndex,
2848        activeIndex,
2849        rtlTranslate: rtl,
2850        wrapperEl,
2851        enabled
2852      } = swiper;
2853
2854      if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
2855        return false;
2856      }
2857
2858      const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
2859      let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
2860      if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2861      const translate = -snapGrid[snapIndex]; // Normalize slideIndex
2862
2863      if (params.normalizeSlideIndex) {
2864        for (let i = 0; i < slidesGrid.length; i += 1) {
2865          const normalizedTranslate = -Math.floor(translate * 100);
2866          const normalizedGrid = Math.floor(slidesGrid[i] * 100);
2867          const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
2868
2869          if (typeof slidesGrid[i + 1] !== 'undefined') {
2870            if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
2871              slideIndex = i;
2872            } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
2873              slideIndex = i + 1;
2874            }
2875          } else if (normalizedTranslate >= normalizedGrid) {
2876            slideIndex = i;
2877          }
2878        }
2879      } // Directions locks
2880
2881
2882      if (swiper.initialized && slideIndex !== activeIndex) {
2883        if (!swiper.allowSlideNext && translate < swiper.translate && translate < swiper.minTranslate()) {
2884          return false;
2885        }
2886
2887        if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
2888          if ((activeIndex || 0) !== slideIndex) return false;
2889        }
2890      }
2891
2892      if (slideIndex !== (previousIndex || 0) && runCallbacks) {
2893        swiper.emit('beforeSlideChangeStart');
2894      } // Update progress
2895
2896
2897      swiper.updateProgress(translate);
2898      let direction;
2899      if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset'; // Update Index
2900
2901      if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {
2902        swiper.updateActiveIndex(slideIndex); // Update Height
2903
2904        if (params.autoHeight) {
2905          swiper.updateAutoHeight();
2906        }
2907
2908        swiper.updateSlidesClasses();
2909
2910        if (params.effect !== 'slide') {
2911          swiper.setTranslate(translate);
2912        }
2913
2914        if (direction !== 'reset') {
2915          swiper.transitionStart(runCallbacks, direction);
2916          swiper.transitionEnd(runCallbacks, direction);
2917        }
2918
2919        return false;
2920      }
2921
2922      if (params.cssMode) {
2923        const isH = swiper.isHorizontal();
2924        const t = rtl ? translate : -translate;
2925
2926        if (speed === 0) {
2927          const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2928
2929          if (isVirtual) {
2930            swiper.wrapperEl.style.scrollSnapType = 'none';
2931            swiper._immediateVirtual = true;
2932          }
2933
2934          wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
2935
2936          if (isVirtual) {
2937            requestAnimationFrame(() => {
2938              swiper.wrapperEl.style.scrollSnapType = '';
2939              swiper._swiperImmediateVirtual = false;
2940            });
2941          }
2942        } else {
2943          if (!swiper.support.smoothScroll) {
2944            animateCSSModeScroll({
2945              swiper,
2946              targetPosition: t,
2947              side: isH ? 'left' : 'top'
2948            });
2949            return true;
2950          }
2951
2952          wrapperEl.scrollTo({
2953            [isH ? 'left' : 'top']: t,
2954            behavior: 'smooth'
2955          });
2956        }
2957
2958        return true;
2959      }
2960
2961      swiper.setTransition(speed);
2962      swiper.setTranslate(translate);
2963      swiper.updateActiveIndex(slideIndex);
2964      swiper.updateSlidesClasses();
2965      swiper.emit('beforeTransitionStart', speed, internal);
2966      swiper.transitionStart(runCallbacks, direction);
2967
2968      if (speed === 0) {
2969        swiper.transitionEnd(runCallbacks, direction);
2970      } else if (!swiper.animating) {
2971        swiper.animating = true;
2972
2973        if (!swiper.onSlideToWrapperTransitionEnd) {
2974          swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2975            if (!swiper || swiper.destroyed) return;
2976            if (e.target !== this) return;
2977            swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2978            swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2979            swiper.onSlideToWrapperTransitionEnd = null;
2980            delete swiper.onSlideToWrapperTransitionEnd;
2981            swiper.transitionEnd(runCallbacks, direction);
2982          };
2983        }
2984
2985        swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
2986        swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);
2987      }
2988
2989      return true;
2990    }
2991
2992    function slideToLoop(index, speed, runCallbacks, internal) {
2993      if (index === void 0) {
2994        index = 0;
2995      }
2996
2997      if (speed === void 0) {
2998        speed = this.params.speed;
2999      }
3000
3001      if (runCallbacks === void 0) {
3002        runCallbacks = true;
3003      }
3004
3005      if (typeof index === 'string') {
3006        /**
3007         * The `index` argument converted from `string` to `number`.
3008         * @type {number}
3009         */
3010        const indexAsNumber = parseInt(index, 10);
3011        /**
3012         * Determines whether the `index` argument is a valid `number`
3013         * after being converted from the `string` type.
3014         * @type {boolean}
3015         */
3016
3017        const isValidNumber = isFinite(indexAsNumber);
3018
3019        if (!isValidNumber) {
3020          throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);
3021        } // Knowing that the converted `index` is a valid number,
3022        // we can update the original argument's value.
3023
3024
3025        index = indexAsNumber;
3026      }
3027
3028      const swiper = this;
3029      let newIndex = index;
3030
3031      if (swiper.params.loop) {
3032        newIndex += swiper.loopedSlides;
3033      }
3034
3035      return swiper.slideTo(newIndex, speed, runCallbacks, internal);
3036    }
3037
3038    /* eslint no-unused-vars: "off" */
3039    function slideNext(speed, runCallbacks, internal) {
3040      if (speed === void 0) {
3041        speed = this.params.speed;
3042      }
3043
3044      if (runCallbacks === void 0) {
3045        runCallbacks = true;
3046      }
3047
3048      const swiper = this;
3049      const {
3050        animating,
3051        enabled,
3052        params
3053      } = swiper;
3054      if (!enabled) return swiper;
3055      let perGroup = params.slidesPerGroup;
3056
3057      if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
3058        perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
3059      }
3060
3061      const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
3062
3063      if (params.loop) {
3064        if (animating && params.loopPreventsSlide) return false;
3065        swiper.loopFix(); // eslint-disable-next-line
3066
3067        swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
3068      }
3069
3070      if (params.rewind && swiper.isEnd) {
3071        return swiper.slideTo(0, speed, runCallbacks, internal);
3072      }
3073
3074      return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
3075    }
3076
3077    /* eslint no-unused-vars: "off" */
3078    function slidePrev(speed, runCallbacks, internal) {
3079      if (speed === void 0) {
3080        speed = this.params.speed;
3081      }
3082
3083      if (runCallbacks === void 0) {
3084        runCallbacks = true;
3085      }
3086
3087      const swiper = this;
3088      const {
3089        params,
3090        animating,
3091        snapGrid,
3092        slidesGrid,
3093        rtlTranslate,
3094        enabled
3095      } = swiper;
3096      if (!enabled) return swiper;
3097
3098      if (params.loop) {
3099        if (animating && params.loopPreventsSlide) return false;
3100        swiper.loopFix(); // eslint-disable-next-line
3101
3102        swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
3103      }
3104
3105      const translate = rtlTranslate ? swiper.translate : -swiper.translate;
3106
3107      function normalize(val) {
3108        if (val < 0) return -Math.floor(Math.abs(val));
3109        return Math.floor(val);
3110      }
3111
3112      const normalizedTranslate = normalize(translate);
3113      const normalizedSnapGrid = snapGrid.map(val => normalize(val));
3114      let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
3115
3116      if (typeof prevSnap === 'undefined' && params.cssMode) {
3117        let prevSnapIndex;
3118        snapGrid.forEach((snap, snapIndex) => {
3119          if (normalizedTranslate >= snap) {
3120            // prevSnap = snap;
3121            prevSnapIndex = snapIndex;
3122          }
3123        });
3124
3125        if (typeof prevSnapIndex !== 'undefined') {
3126          prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
3127        }
3128      }
3129
3130      let prevIndex = 0;
3131
3132      if (typeof prevSnap !== 'undefined') {
3133        prevIndex = slidesGrid.indexOf(prevSnap);
3134        if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
3135
3136        if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
3137          prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
3138          prevIndex = Math.max(prevIndex, 0);
3139        }
3140      }
3141
3142      if (params.rewind && swiper.isBeginning) {
3143        const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
3144        return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
3145      }
3146
3147      return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
3148    }
3149
3150    /* eslint no-unused-vars: "off" */
3151    function slideReset(speed, runCallbacks, internal) {
3152      if (speed === void 0) {
3153        speed = this.params.speed;
3154      }
3155
3156      if (runCallbacks === void 0) {
3157        runCallbacks = true;
3158      }
3159
3160      const swiper = this;
3161      return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
3162    }
3163
3164    /* eslint no-unused-vars: "off" */
3165    function slideToClosest(speed, runCallbacks, internal, threshold) {
3166      if (speed === void 0) {
3167        speed = this.params.speed;
3168      }
3169
3170      if (runCallbacks === void 0) {
3171        runCallbacks = true;
3172      }
3173
3174      if (threshold === void 0) {
3175        threshold = 0.5;
3176      }
3177
3178      const swiper = this;
3179      let index = swiper.activeIndex;
3180      const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
3181      const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
3182      const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
3183
3184      if (translate >= swiper.snapGrid[snapIndex]) {
3185        // The current translate is on or after the current snap index, so the choice
3186        // is between the current index and the one after it.
3187        const currentSnap = swiper.snapGrid[snapIndex];
3188        const nextSnap = swiper.snapGrid[snapIndex + 1];
3189
3190        if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
3191          index += swiper.params.slidesPerGroup;
3192        }
3193      } else {
3194        // The current translate is before the current snap index, so the choice
3195        // is between the current index and the one before it.
3196        const prevSnap = swiper.snapGrid[snapIndex - 1];
3197        const currentSnap = swiper.snapGrid[snapIndex];
3198
3199        if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
3200          index -= swiper.params.slidesPerGroup;
3201        }
3202      }
3203
3204      index = Math.max(index, 0);
3205      index = Math.min(index, swiper.slidesGrid.length - 1);
3206      return swiper.slideTo(index, speed, runCallbacks, internal);
3207    }
3208
3209    function slideToClickedSlide() {
3210      const swiper = this;
3211      const {
3212        params,
3213        $wrapperEl
3214      } = swiper;
3215      const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
3216      let slideToIndex = swiper.clickedIndex;
3217      let realIndex;
3218
3219      if (params.loop) {
3220        if (swiper.animating) return;
3221        realIndex = parseInt($(swiper.clickedSlide).attr('data-swiper-slide-index'), 10);
3222
3223        if (params.centeredSlides) {
3224          if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
3225            swiper.loopFix();
3226            slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
3227            nextTick(() => {
3228              swiper.slideTo(slideToIndex);
3229            });
3230          } else {
3231            swiper.slideTo(slideToIndex);
3232          }
3233        } else if (slideToIndex > swiper.slides.length - slidesPerView) {
3234          swiper.loopFix();
3235          slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
3236          nextTick(() => {
3237            swiper.slideTo(slideToIndex);
3238          });
3239        } else {
3240          swiper.slideTo(slideToIndex);
3241        }
3242      } else {
3243        swiper.slideTo(slideToIndex);
3244      }
3245    }
3246
3247    var slide = {
3248      slideTo,
3249      slideToLoop,
3250      slideNext,
3251      slidePrev,
3252      slideReset,
3253      slideToClosest,
3254      slideToClickedSlide
3255    };
3256
3257    function loopCreate() {
3258      const swiper = this;
3259      const document = getDocument();
3260      const {
3261        params,
3262        $wrapperEl
3263      } = swiper; // Remove duplicated slides
3264
3265      const $selector = $wrapperEl.children().length > 0 ? $($wrapperEl.children()[0].parentNode) : $wrapperEl;
3266      $selector.children(`.${params.slideClass}.${params.slideDuplicateClass}`).remove();
3267      let slides = $selector.children(`.${params.slideClass}`);
3268
3269      if (params.loopFillGroupWithBlank) {
3270        const blankSlidesNum = params.slidesPerGroup - slides.length % params.slidesPerGroup;
3271
3272        if (blankSlidesNum !== params.slidesPerGroup) {
3273          for (let i = 0; i < blankSlidesNum; i += 1) {
3274            const blankNode = $(document.createElement('div')).addClass(`${params.slideClass} ${params.slideBlankClass}`);
3275            $selector.append(blankNode);
3276          }
3277
3278          slides = $selector.children(`.${params.slideClass}`);
3279        }
3280      }
3281
3282      if (params.slidesPerView === 'auto' && !params.loopedSlides) params.loopedSlides = slides.length;
3283      swiper.loopedSlides = Math.ceil(parseFloat(params.loopedSlides || params.slidesPerView, 10));
3284      swiper.loopedSlides += params.loopAdditionalSlides;
3285
3286      if (swiper.loopedSlides > slides.length && swiper.params.loopedSlidesLimit) {
3287        swiper.loopedSlides = slides.length;
3288      }
3289
3290      const prependSlides = [];
3291      const appendSlides = [];
3292      slides.each((el, index) => {
3293        const slide = $(el);
3294        slide.attr('data-swiper-slide-index', index);
3295      });
3296
3297      for (let i = 0; i < swiper.loopedSlides; i += 1) {
3298        const index = i - Math.floor(i / slides.length) * slides.length;
3299        appendSlides.push(slides.eq(index)[0]);
3300        prependSlides.unshift(slides.eq(slides.length - index - 1)[0]);
3301      }
3302
3303      for (let i = 0; i < appendSlides.length; i += 1) {
3304        $selector.append($(appendSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
3305      }
3306
3307      for (let i = prependSlides.length - 1; i >= 0; i -= 1) {
3308        $selector.prepend($(prependSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
3309      }
3310    }
3311
3312    function loopFix() {
3313      const swiper = this;
3314      swiper.emit('beforeLoopFix');
3315      const {
3316        activeIndex,
3317        slides,
3318        loopedSlides,
3319        allowSlidePrev,
3320        allowSlideNext,
3321        snapGrid,
3322        rtlTranslate: rtl
3323      } = swiper;
3324      let newIndex;
3325      swiper.allowSlidePrev = true;
3326      swiper.allowSlideNext = true;
3327      const snapTranslate = -snapGrid[activeIndex];
3328      const diff = snapTranslate - swiper.getTranslate(); // Fix For Negative Oversliding
3329
3330      if (activeIndex < loopedSlides) {
3331        newIndex = slides.length - loopedSlides * 3 + activeIndex;
3332        newIndex += loopedSlides;
3333        const slideChanged = swiper.slideTo(newIndex, 0, false, true);
3334
3335        if (slideChanged && diff !== 0) {
3336          swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
3337        }
3338      } else if (activeIndex >= slides.length - loopedSlides) {
3339        // Fix For Positive Oversliding
3340        newIndex = -slides.length + activeIndex + loopedSlides;
3341        newIndex += loopedSlides;
3342        const slideChanged = swiper.slideTo(newIndex, 0, false, true);
3343
3344        if (slideChanged && diff !== 0) {
3345          swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
3346        }
3347      }
3348
3349      swiper.allowSlidePrev = allowSlidePrev;
3350      swiper.allowSlideNext = allowSlideNext;
3351      swiper.emit('loopFix');
3352    }
3353
3354    function loopDestroy() {
3355      const swiper = this;
3356      const {
3357        $wrapperEl,
3358        params,
3359        slides
3360      } = swiper;
3361      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass},.${params.slideClass}.${params.slideBlankClass}`).remove();
3362      slides.removeAttr('data-swiper-slide-index');
3363    }
3364
3365    var loop = {
3366      loopCreate,
3367      loopFix,
3368      loopDestroy
3369    };
3370
3371    function setGrabCursor(moving) {
3372      const swiper = this;
3373      if (swiper.support.touch || !swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
3374      const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
3375      el.style.cursor = 'move';
3376      el.style.cursor = moving ? 'grabbing' : 'grab';
3377    }
3378
3379    function unsetGrabCursor() {
3380      const swiper = this;
3381
3382      if (swiper.support.touch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
3383        return;
3384      }
3385
3386      swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
3387    }
3388
3389    var grabCursor = {
3390      setGrabCursor,
3391      unsetGrabCursor
3392    };
3393
3394    function closestElement(selector, base) {
3395      if (base === void 0) {
3396        base = this;
3397      }
3398
3399      function __closestFrom(el) {
3400        if (!el || el === getDocument() || el === getWindow()) return null;
3401        if (el.assignedSlot) el = el.assignedSlot;
3402        const found = el.closest(selector);
3403
3404        if (!found && !el.getRootNode) {
3405          return null;
3406        }
3407
3408        return found || __closestFrom(el.getRootNode().host);
3409      }
3410
3411      return __closestFrom(base);
3412    }
3413
3414    function onTouchStart(event) {
3415      const swiper = this;
3416      const document = getDocument();
3417      const window = getWindow();
3418      const data = swiper.touchEventsData;
3419      const {
3420        params,
3421        touches,
3422        enabled
3423      } = swiper;
3424      if (!enabled) return;
3425
3426      if (swiper.animating && params.preventInteractionOnTransition) {
3427        return;
3428      }
3429
3430      if (!swiper.animating && params.cssMode && params.loop) {
3431        swiper.loopFix();
3432      }
3433
3434      let e = event;
3435      if (e.originalEvent) e = e.originalEvent;
3436      let $targetEl = $(e.target);
3437
3438      if (params.touchEventsTarget === 'wrapper') {
3439        if (!$targetEl.closest(swiper.wrapperEl).length) return;
3440      }
3441
3442      data.isTouchEvent = e.type === 'touchstart';
3443      if (!data.isTouchEvent && 'which' in e && e.which === 3) return;
3444      if (!data.isTouchEvent && 'button' in e && e.button > 0) return;
3445      if (data.isTouched && data.isMoved) return; // change target el for shadow root component
3446
3447      const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== ''; // eslint-disable-next-line
3448
3449      const eventPath = event.composedPath ? event.composedPath() : event.path;
3450
3451      if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
3452        $targetEl = $(eventPath[0]);
3453      }
3454
3455      const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
3456      const isTargetShadow = !!(e.target && e.target.shadowRoot); // use closestElement for shadow root element to get the actual closest for nested shadow root element
3457
3458      if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, $targetEl[0]) : $targetEl.closest(noSwipingSelector)[0])) {
3459        swiper.allowClick = true;
3460        return;
3461      }
3462
3463      if (params.swipeHandler) {
3464        if (!$targetEl.closest(params.swipeHandler)[0]) return;
3465      }
3466
3467      touches.currentX = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
3468      touches.currentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
3469      const startX = touches.currentX;
3470      const startY = touches.currentY; // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
3471
3472      const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
3473      const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
3474
3475      if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
3476        if (edgeSwipeDetection === 'prevent') {
3477          event.preventDefault();
3478        } else {
3479          return;
3480        }
3481      }
3482
3483      Object.assign(data, {
3484        isTouched: true,
3485        isMoved: false,
3486        allowTouchCallbacks: true,
3487        isScrolling: undefined,
3488        startMoving: undefined
3489      });
3490      touches.startX = startX;
3491      touches.startY = startY;
3492      data.touchStartTime = now();
3493      swiper.allowClick = true;
3494      swiper.updateSize();
3495      swiper.swipeDirection = undefined;
3496      if (params.threshold > 0) data.allowThresholdMove = false;
3497
3498      if (e.type !== 'touchstart') {
3499        let preventDefault = true;
3500
3501        if ($targetEl.is(data.focusableElements)) {
3502          preventDefault = false;
3503
3504          if ($targetEl[0].nodeName === 'SELECT') {
3505            data.isTouched = false;
3506          }
3507        }
3508
3509        if (document.activeElement && $(document.activeElement).is(data.focusableElements) && document.activeElement !== $targetEl[0]) {
3510          document.activeElement.blur();
3511        }
3512
3513        const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
3514
3515        if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !$targetEl[0].isContentEditable) {
3516          e.preventDefault();
3517        }
3518      }
3519
3520      if (swiper.params.freeMode && swiper.params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
3521        swiper.freeMode.onTouchStart();
3522      }
3523
3524      swiper.emit('touchStart', e);
3525    }
3526
3527    function onTouchMove(event) {
3528      const document = getDocument();
3529      const swiper = this;
3530      const data = swiper.touchEventsData;
3531      const {
3532        params,
3533        touches,
3534        rtlTranslate: rtl,
3535        enabled
3536      } = swiper;
3537      if (!enabled) return;
3538      let e = event;
3539      if (e.originalEvent) e = e.originalEvent;
3540
3541      if (!data.isTouched) {
3542        if (data.startMoving && data.isScrolling) {
3543          swiper.emit('touchMoveOpposite', e);
3544        }
3545
3546        return;
3547      }
3548
3549      if (data.isTouchEvent && e.type !== 'touchmove') return;
3550      const targetTouch = e.type === 'touchmove' && e.targetTouches && (e.targetTouches[0] || e.changedTouches[0]);
3551      const pageX = e.type === 'touchmove' ? targetTouch.pageX : e.pageX;
3552      const pageY = e.type === 'touchmove' ? targetTouch.pageY : e.pageY;
3553
3554      if (e.preventedByNestedSwiper) {
3555        touches.startX = pageX;
3556        touches.startY = pageY;
3557        return;
3558      }
3559
3560      if (!swiper.allowTouchMove) {
3561        if (!$(e.target).is(data.focusableElements)) {
3562          swiper.allowClick = false;
3563        }
3564
3565        if (data.isTouched) {
3566          Object.assign(touches, {
3567            startX: pageX,
3568            startY: pageY,
3569            currentX: pageX,
3570            currentY: pageY
3571          });
3572          data.touchStartTime = now();
3573        }
3574
3575        return;
3576      }
3577
3578      if (data.isTouchEvent && params.touchReleaseOnEdges && !params.loop) {
3579        if (swiper.isVertical()) {
3580          // Vertical
3581          if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {
3582            data.isTouched = false;
3583            data.isMoved = false;
3584            return;
3585          }
3586        } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) {
3587          return;
3588        }
3589      }
3590
3591      if (data.isTouchEvent && document.activeElement) {
3592        if (e.target === document.activeElement && $(e.target).is(data.focusableElements)) {
3593          data.isMoved = true;
3594          swiper.allowClick = false;
3595          return;
3596        }
3597      }
3598
3599      if (data.allowTouchCallbacks) {
3600        swiper.emit('touchMove', e);
3601      }
3602
3603      if (e.targetTouches && e.targetTouches.length > 1) return;
3604      touches.currentX = pageX;
3605      touches.currentY = pageY;
3606      const diffX = touches.currentX - touches.startX;
3607      const diffY = touches.currentY - touches.startY;
3608      if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;
3609
3610      if (typeof data.isScrolling === 'undefined') {
3611        let touchAngle;
3612
3613        if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {
3614          data.isScrolling = false;
3615        } else {
3616          // eslint-disable-next-line
3617          if (diffX * diffX + diffY * diffY >= 25) {
3618            touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
3619            data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
3620          }
3621        }
3622      }
3623
3624      if (data.isScrolling) {
3625        swiper.emit('touchMoveOpposite', e);
3626      }
3627
3628      if (typeof data.startMoving === 'undefined') {
3629        if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
3630          data.startMoving = true;
3631        }
3632      }
3633
3634      if (data.isScrolling) {
3635        data.isTouched = false;