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

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

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

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

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

1269ject.prototype.toString.call(o).slice(8, -1) === 'Object';
1270    }
1271
1272    function isNode(node) {
1273      // eslint-disable-next-line
1274      if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
1275        return node instanceof HTMLElement;
1276      }
1277
1278      return node && (node.nodeType === 1 || node.nodeType === 11);
1279    }
1280
1281    function extend() {
1282      const to = Object(arguments.length <= 0 ? undefined : arguments[0]);
1283      const noExtend = ['__proto__', 'constructor', 'prototype'];
1284
1285      for (let i = 1; i < arguments.length; i += 1) {
1286        const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
1287
1288        if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
1289          const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);
1290
1291          for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
1292            const nextKey = keysArray[nextIndex];
1293            const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
1294
1295            if (desc !== undefined && desc.enumerable) {
1296              if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1297                if (nextSource[nextKey].__swiper__) {
1298                  to[nextKey] = nextSource[nextKey];
1299                } else {
1300                  extend(to[nextKey], nextSource[nextKey]);
1301                }
1302              } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
1303                to[nextKey] = {};
1304
1305                if (nextSource[nextKey].__swiper__) {
1306                  to[nextKey] = nextSource[nextKey];
1307                } else {
1308                  extend(to[nextKey], nextSource[nextKey]);
1309                }
1310              } else {
1311                to[nextKey] = nextSource[nextKey];
1312              }
1313            }
1314          }
1315        }
1316      }
1317
1318      return to;
1319    }
1320
1321    function setCSSProperty(el, varName, varValue) {
1322      el.style.setProperty(varName, varValue);
1323    }
1324
1325    function animateCSSModeScroll(_ref) {
1326      let {
1327        swiper,
1328        targetPosition,
1329        side
1330      } = _ref;
1331      const window = getWindow();
1332      const startPosition = -swiper.translate;
1333      let startTime = null;
1334      let time;
1335      const duration = swiper.params.speed;
1336      swiper.wrapperEl.style.scrollSnapType = 'none';
1337      window.cancelAnimationFrame(swiper.cssModeFrameID);
1338      const dir = targetPosition > startPosition ? 'next' : 'prev';
1339
1340      const isOutOfBound = (current, target) => {
1341        return dir === 'next' && current >= target || dir === 'prev' && current <= target;
1342      };
1343
1344      const animate = () => {
1345        time = new Date().getTime();
1346
1347        if (startTime === null) {
1348          startTime = time;
1349        }
1350
1351        const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
1352        const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;
1353        let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
1354
1355        if (isOutOfBound(currentPosition, targetPosition)) {
1356          currentPosition = targetPosition;
1357        }
1358
1359        swiper.wrapperEl.scrollTo({
1360          [side]: currentPosition
1361        });
1362
1363        if (isOutOfBound(currentPosition, targetPosition)) {
1364          swiper.wrapperEl.style.overflow = 'hidden';
1365          swiper.wrapperEl.style.scrollSnapType = '';
1366          setTimeout(() => {
1367            swiper.wrapperEl.style.overflow = '';
1368            swiper.wrapperEl.scrollTo({
1369              [side]: currentPosition
1370            });
1371          });
1372          window.cancelAnimationFrame(swiper.cssModeFrameID);
1373          return;
1374        }
1375
1376        swiper.cssModeFrameID = window.requestAnimationFrame(animate);
1377      };
1378
1379      animate();
1380    }
1381
1382    let support;
1383
1384    function calcSupport() {
1385      const window = getWindow();
1386      const document = getDocument();
1387      return {
1388        smoothScroll: document.documentElement && 'scrollBehavior' in document.documentElement.style,
1389        touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch),
1390        passiveListener: function checkPassiveListener() {
1391          let supportsPassive = false;

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

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

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