https://busansinbo.or.kr/common/js/lib/swiper.js

1/**
2 * Swiper 5.3.8
3 * Most modern mobile touch slider and framework with hardware accelerated transitions
4 * http://swiperjs.com
5 *
6 * Copyright 2014-2020 Vladimir Kharlampidi
7 *
8 * Released under the MIT License
9 *
10 * Released on: April 24, 2020
11 */
12
13(function (global, factory) {
14  typeof exports === "object" && typeof module !== "undefined"
15    ? (module.exports = factory())
16    : typeof define === "function" && define.amd
17    ? define(factory)
18    : ((global = global || self), (global.Swiper = factory()));
19})(this, function () {
20  "use strict";
21
22  /**
23   * SSR Window 1.0.1
24   * Better handling for window object in SSR environment
25   * https://github.com/nolimits4web/ssr-window
26   *
27   * Copyright 2018, Vladimir Kharlampidi
28   *
29   * Licensed under MIT
30   *
31   * Released on: July 18, 2018
32   */
33  var doc =
34    typeof document === "undefined"
35      ? {
36          body: {},
37          addEventListener: function addEventListener() {},
38          removeEventListener: function removeEventListener() {},
39          activeElement: {
40            blur: function blur() {},
41            nodeName: "",
42          },
43          querySelector: function querySelector() {
44            return null;
45          },
46          querySelectorAll: function querySelectorAll() {
47            return [];
48          },
49          getElementById: function getElementById() {
50            return null;
51          },
52          createEvent: function createEvent() {
53            return {
54              initEvent: function initEvent() {},
55            };
56          },
57          createElement: function createElement() {
58            return {
59              children: [],
60              childNodes: [],
61              style: {},
62              setAttribute: function setAttribute() {},
63              getElementsByTagName: function getElementsByTagName() {
64                return [];
65              },
66            };
67          },
68          location: { hash: "" },
69        }
70      : document; // eslint-disable-line
71
72  var win =
73    typeof window === "undefined"
74      ? {
75          document: doc,
76          navigator: {
77            userAgent: "",
78          },
79          location: {},
80          history: {},
81          CustomEvent: function CustomEvent() {
82            return this;
83          },
84          addEventListener: function addEventListener() {},
85          removeEventListener: function removeEventListener() {},
86          getComputedStyle: function getComputedStyle() {
87            return {
88              getPropertyValue: function getPropertyValue() {
89                return "";
90              },
91            };
92          },
93          Image: function Image() {},
94          Date: function Date() {},
95          screen: {},
96          setTimeout: function setTimeout() {},
97          clearTimeout: function clearTimeout() {},
98        }
99      : window; // eslint-disable-line
100
101  /**
102   * Dom7 2.1.3
103   * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API
104   * http://framework7.io/docs/dom.html
105   *
106   * Copyright 2019, Vladimir Kharlampidi
107   * The iDangero.us
108   * http://www.idangero.us/
109   *
110   * Licensed under MIT
111   *
112   * Released on: February 11, 2019
113   */
114
115  var Dom7 = function Dom7(arr) {
116    var self = this;
117    // Create array-like object
118    for (var i = 0; i < arr.length; i += 1) {
119      self[i] = arr[i];
120    }
121    self.length = arr.length;
122    // Return collection with methods
123    return this;
124  };
125
126  function $(selector, context) {
127    var arr = [];
128    var i = 0;
129    if (selector && !context) {
130      if (selector instanceof Dom7) {
131        return selector;
132      }
133    }
134    if (selector) {
135      // String
136      if (typeof selector === "string") {
137        var els;
138        var tempParent;
139        var html = selector.trim();
140        if (html.indexOf("<") >= 0 && html.indexOf(">") >= 0) {
141          var toCreate = "div";
142          if (html.indexOf("<li") === 0) {
143            toCreate = "ul";
144          }
145          if (html.indexOf("<tr") === 0) {
146            toCreate = "tbody";
147          }
148          if (html.indexOf("<td") === 0 || html.indexOf("<th") === 0) {
149            toCreate = "tr";
150          }
151          if (html.indexOf("<tbody") === 0) {
152            toCreate = "table";
153          }
154          if (html.indexOf("<option") === 0) {
155            toCreate = "select";
156          }
157          tempParent = doc.createElement(toCreate);
158          tempParent.innerHTML = html;
159          for (i = 0; i < tempParent.childNodes.length; i += 1) {
160            arr.push(tempParent.childNodes[i]);
161          }
162        } else {
163          if (!context && selector[0] === "#" && !selector.match(/[ .<>:~]/)) {
164            // Pure ID selector
165            els = [doc.getElementById(selector.trim().split("#")[1])];
166          } else {
167            // Other selectors
168            els = (context || doc).querySelectorAll(selector.trim());
169          }
170          for (i = 0; i < els.length; i += 1) {
171            if (els[i]) {
172              arr.push(els[i]);
173            }
174          }
175        }
176      } else if (selector.nodeType || selector === win || selector === doc) {
177        // Node/element
178        arr.push(selector);
179      } else if (selector.length > 0 && selector[0].nodeType) {
180        // Array of elements or instance of Dom
181        for (i = 0; i < selector.length; i += 1) {
182          arr.push(selector[i]);
183        }
184      }
185    }
186    return new Dom7(arr);
187  }
188
189  $.fn = Dom7.prototype;
190  $.Class = Dom7;
191  $.Dom7 = Dom7;
192
193  function unique(arr) {
194    var uniqueArray = [];
195    for (var i = 0; i < arr.length; i += 1) {
196      if (uniqueArray.indexOf(arr[i]) === -1) {
197        uniqueArray.push(arr[i]);
198      }
199    }
200    return uniqueArray;
201  }
202
203  // Classes and attributes
204  function addClass(className) {
205    if (typeof className === "undefined") {
206      return this;
207    }
208    var classes = className.split(" ");
209    for (var i = 0; i < classes.length; i += 1) {
210      for (var j = 0; j < this.length; j += 1) {
211        if (
212          typeof this[j] !== "undefined" &&
213          typeof this[j].classList !== "undefined"
214        ) {
215          this[j].classList.add(classes[i]);
216        }
217      }
218    }
219    return this;
220  }
221  function removeClass(className) {
222    var classes = className.split(" ");
223    for (var i = 0; i < classes.length; i += 1) {
224      for (var j = 0; j < this.length; j += 1) {
225        if (
226          typeof this[j] !== "undefined" &&
227          typeof this[j].classList !== "undefined"
228        ) {
229          this[j].classList.remove(classes[i]);
230        }
231      }
232    }
233    return this;
234  }
235  function hasClass(className) {
236    if (!this[0]) {
237      return false;
238    }
239    return this[0].classList.contains(className);
240  }
241  function toggleClass(className) {
242    var classes = className.split(" ");
243    for (var i = 0; i < classes.length; i += 1) {
244      for (var j = 0; j < this.length; j += 1) {
245        if (
246          typeof this[j] !== "undefined" &&
247          typeof this[j].classList !== "undefined"
248        ) {
249          this[j].classList.toggle(classes[i]);
250        }
251      }
252    }
253    return this;
254  }
255  function attr(attrs, value) {
256    var arguments$1 = arguments;
257
258    if (arguments.length === 1 && typeof attrs === "string") {
259      // Get attr
260      if (this[0]) {
261        return this[0].getAttribute(attrs);
262      }
263      return undefined;
264    }
265
266    // Set attrs
267    for (var i = 0; i < this.length; i += 1) {
268      if (arguments$1.length === 2) {
269        // String
270        this[i].setAttribute(attrs, value);
271      } else {
272        // Object
273        // eslint-disable-next-line
274        for (var attrName in attrs) {
275          this[i][attrName] = attrs[attrName];
276          this[i].setAttribute(attrName, attrs[attrName]);
277        }
278      }
279    }
280    return this;
281  }
282  // eslint-disable-next-line
283  function removeAttr(attr) {
284    for (var i = 0; i < this.length; i += 1) {
285      this[i].removeAttribute(attr);
286    }
287    return this;
288  }
289  function data(key, value) {
290    var el;
291    if (typeof value === "undefined") {
292      el = this[0];
293      // Get value
294      if (el) {
295        if (el.dom7ElementDataStorage && key in el.dom7ElementDataStorage) {
296          return el.dom7ElementDataStorage[key];
297        }
298
299        var dataKey = el.getAttribute("data-" + key);
300        if (dataKey) {
301          return dataKey;
302        }
303        return undefined;
304      }
305      return undefined;
306    }
307
308    // Set value
309    for (var i = 0; i < this.length; i += 1) {
310      el = this[i];
311      if (!el.dom7ElementDataStorage) {
312        el.dom7ElementDataStorage = {};
313      }
314      el.dom7ElementDataStorage[key] = value;
315    }
316    return this;
317  }
318  // Transforms
319  // eslint-disable-next-line
320  function transform(transform) {
321    for (var i = 0; i < this.length; i += 1) {
322      var elStyle = this[i].style;
323      elStyle.webkitTransform = transform;
324      elStyle.transform = transform;
325    }
326    return this;
327  }
328  function transition(duration) {
329    if (typeof duration !== "string") {
330      duration = duration + "ms"; // eslint-disable-line
331    }
332    for (var i = 0; i < this.length; i += 1) {
333      var elStyle = this[i].style;
334      elStyle.webkitTransitionDuration = duration;
335      elStyle.transitionDuration = duration;
336    }
337    return this;
338  }
339  // Events
340  function on() {
341    var assign;
342
343    var args = [],
344      len = arguments.length;
345    while (len--) args[len] = arguments[len];
346    var eventType = args[0];
347    var targetSelector = args[1];
348    var listener = args[2];
349    var capture = args[3];
350    if (typeof args[1] === "function") {
351      (assign = args),
352        (eventType = assign[0]),
353        (listener = assign[1]),
354        (capture = assign[2]);
355      targetSelector = undefined;
356    }
357    if (!capture) {
358      capture = false;
359    }
360
361    function handleLiveEvent(e) {
362      var target = e.target;
363      if (!target) {
364        return;
365      }
366      var eventData = e.target.dom7EventData || [];
367      if (eventData.indexOf(e) < 0) {
368        eventData.unshift(e);
369      }
370      if ($(target).is(targetSelector)) {
371        listener.apply(target, eventData);
372      } else {
373        var parents = $(target).parents(); // eslint-disable-line
374        for (var k = 0; k < parents.length; k += 1) {
375          if ($(parents[k]).is(targetSelector)) {
376            listener.apply(parents[k], eventData);
377          }
378        }
379      }
380    }
381    function handleEvent(e) {
382      var eventData = e && e.target ? e.target.dom7EventData || [] : [];
383      if (eventData.indexOf(e) < 0) {
384        eventData.unshift(e);
385      }
386      listener.apply(this, eventData);
387    }
388    var events = eventType.split(" ");
389    var j;
390    for (var i = 0; i < this.length; i += 1) {
391      var el = this[i];
392      if (!targetSelector) {
393        for (j = 0; j < events.length; j += 1) {
394          var event = events[j];
395          if (!el.dom7Listeners) {
396            el.dom7Listeners = {};
397          }
398          if (!el.dom7Listeners[event]) {
399            el.dom7Listeners[event] = [];
400          }
401          el.dom7Listeners[event].push({
402            listener: listener,
403            proxyListener: handleEvent,
404          });
405          el.addEventListener(event, handleEvent, capture);
406        }
407      } else {
408        // Live events
409        for (j = 0; j < events.length; j += 1) {
410          var event$1 = events[j];
411          if (!el.dom7LiveListeners) {
412            el.dom7LiveListeners = {};
413          }
414          if (!el.dom7LiveListeners[event$1]) {
415            el.dom7LiveListeners[event$1] = [];
416          }
417          el.dom7LiveListeners[event$1].push({
418            listener: listener,
419            proxyListener: handleLiveEvent,
420          });
421          el.addEventListener(event$1, handleLiveEvent, capture);
422        }
423      }
424    }
425    return this;
426  }
427  function off() {
428    var assign;
429
430    var args = [],
431      len = arguments.length;
432    while (len--) args[len] = arguments[len];
433    var eventType = args[0];
434    var targetSelector = args[1];
435    var listener = args[2];
436    var capture = args[3];
437    if (typeof args[1] === "function") {
438      (assign = args),
439        (eventType = assign[0]),
440        (listener = assign[1]),
441        (capture = assign[2]);
442      targetSelector = undefined;
443    }
444    if (!capture) {
445      capture = false;
446    }
447
448    var events = eventType.split(" ");
449    for (var i = 0; i < events.length; i += 1) {
450      var event = events[i];
451      for (var j = 0; j < this.length; j += 1) {
452        var el = this[j];
453        var handlers = void 0;
454        if (!targetSelector && el.dom7Listeners) {
455          handlers = el.dom7Listeners[event];
456        } else if (targetSelector && el.dom7LiveListeners) {
457          handlers = el.dom7LiveListeners[event];
458        }
459        if (handlers && handlers.length) {
460          for (var k = handlers.length - 1; k >= 0; k -= 1) {
461            var handler = handlers[k];
462            if (listener && handler.listener === listener) {
463              el.removeEventListener(event, handler.proxyListener, capture);
464              handlers.splice(k, 1);
465            } else if (
466              listener &&
467              handler.listener &&
468              handler.listener.dom7proxy &&
469              handler.listener.dom7proxy === listener
470            ) {
471              el.removeEventListener(event, handler.proxyListener, capture);
472              handlers.splice(k, 1);
473            } else if (!listener) {
474              el.removeEventListener(event, handler.proxyListener, capture);
475              handlers.splice(k, 1);
476            }
477          }
478        }
479      }
480    }
481    return this;
482  }
483  function trigger() {
484    var args = [],
485      len = arguments.length;
486    while (len--) args[len] = arguments[len];
487
488    var events = args[0].split(" ");
489    var eventData = args[1];
490    for (var i = 0; i < events.length; i += 1) {
491      var event = events[i];
492      for (var j = 0; j < this.length; j += 1) {
493        var el = this[j];
494        var evt = void 0;
495        try {
496          evt = new win.CustomEvent(event, {
497            detail: eventData,
498            bubbles: true,
499            cancelable: true,
500          });
501        } catch (e) {
502          evt = doc.createEvent("Event");
503          evt.initEvent(event, true, true);
504          evt.detail = eventData;
505        }
506        // eslint-disable-next-line
507        el.dom7EventData = args.filter(function (data, dataIndex) {
508          return dataIndex > 0;
509        });
510        el.dispatchEvent(evt);
511        el.dom7EventData = [];
512        delete el.dom7EventData;
513      }
514    }
515    return this;
516  }
517  function transitionEnd(callback) {
518    var events = ["webkitTransitionEnd", "transitionend"];
519    var dom = this;
520    var i;
521    function fireCallBack(e) {
522      /* jshint validthis:true */
523      if (e.target !== this) {
524        return;
525      }
526      callback.call(this, e);
527      for (i = 0; i < events.length; i += 1) {
528        dom.off(events[i], fireCallBack);
529      }
530    }
531    if (callback) {
532      for (i = 0; i < events.length; i += 1) {
533        dom.on(events[i], fireCallBack);
534      }
535    }
536    return this;
537  }
538  function outerWidth(includeMargins) {
539    if (this.length > 0) {
540      if (includeMargins) {
541        // eslint-disable-next-line
542        var styles = this.styles();
543        return (
544          this[0].offsetWidth +
545          parseFloat(styles.getPropertyValue("margin-right")) +
546          parseFloat(styles.getPropertyValue("margin-left"))
547        );
548      }
549      return this[0].offsetWidth;
550    }
551    return null;
552  }
553  function outerHeight(includeMargins) {
554    if (this.length > 0) {
555      if (includeMargins) {
556        // eslint-disable-next-line
557        var styles = this.styles();
558        return (
559          this[0].offsetHeight +
560          parseFloat(styles.getPropertyValue("margin-top")) +
561          parseFloat(styles.getPropertyValue("margin-bottom"))
562        );
563      }
564      return this[0].offsetHeight;
565    }
566    return null;
567  }
568  function offset() {
569    if (this.length > 0) {
570      var el = this[0];
571      var box = el.getBoundingClientRect();
572      var body = doc.body;
573      var clientTop = el.clientTop || body.clientTop || 0;
574      var clientLeft = el.clientLeft || body.clientLeft || 0;
575      var scrollTop = el === win ? win.scrollY : el.scrollTop;
576      var scrollLeft = el === win ? win.scrollX : el.scrollLeft;
577      return {
578        top: box.top + scrollTop - clientTop,
579        left: box.left + scrollLeft - clientLeft,
580      };
581    }
582
583    return null;
584  }
585  function styles() {
586    if (this[0]) {
587      return win.getComputedStyle(this[0], null);
588    }
589    return {};
590  }
591  function css(props, value) {
592    var i;
593    if (arguments.length === 1) {
594      if (typeof props === "string") {
595        if (this[0]) {
596          return win.getComputedStyle(this[0], null).getPropertyValue(props);
597        }
598      } else {
599        for (i = 0; i < this.length; i += 1) {
600          // eslint-disable-next-line
601          for (var prop in props) {
602            this[i].style[prop] = props[prop];
603          }
604        }
605        return this;
606      }
607    }
608    if (arguments.length === 2 && typeof props === "string") {
609      for (i = 0; i < this.length; i += 1) {
610        this[i].style[props] = value;
611      }
612      return this;
613    }
614    return this;
615  }
616  // Iterate over the collection passing elements to `callback`
617  function each(callback) {
618    // Don't bother continuing without a callback
619    if (!callback) {
620      return this;
621    }
622    // Iterate over the current collection
623    for (var i = 0; i < this.length; i += 1) {
624      // If the callback returns false
625      if (callback.call(this[i], i, this[i]) === false) {
626        // End the loop early
627        return this;
628      }
629    }
630    // Return `this` to allow chained DOM operations
631    return this;
632  }
633  function filter(callback) {
634    var matchedItems = [];
635    var dom = this;
636    for (var i = 0; i < dom.length; i += 1) {
637      if (callback.call(dom[i], i, dom[i])) {
638        matchedItems.push(dom[i]);
639      }
640    }
641    return new Dom7(matchedItems);
642  }
643  // eslint-disable-next-line
644  function html(html) {
645    if (typeof html === "undefined") {
646      return this[0] ? this[0].innerHTML : undefined;
647    }
648
649    for (var i = 0; i < this.length; i += 1) {
650      this[i].innerHTML = html;
651    }
652    return this;
653  }
654  // eslint-disable-next-line
655  function text(text) {
656    if (typeof text === "undefined") {
657      if (this[0]) {
658        return this[0].textContent.trim();
659      }
660      return null;
661    }
662
663    for (var i = 0; i < this.length; i += 1) {
664      this[i].textContent = text;
665    }
666    return this;
667  }
668  function is(selector) {
669    var el = this[0];
670    var compareWith;
671    var i;
672    if (!el || typeof selector === "undefined") {
673      return false;
674    }
675    if (typeof selector === "string") {
676      if (el.matches) {
677        return el.matches(selector);
678      } else if (el.webkitMatchesSelector) {
679        return el.webkitMatchesSelector(selector);
680      } else if (el.msMatchesSelector) {
681        return el.msMatchesSelector(selector);
682      }
683
684      compareWith = $(selector);
685      for (i = 0; i < compareWith.length; i += 1) {
686        if (compareWith[i] === el) {
687          return true;
688        }
689      }
690      return false;
691    } else if (selector === doc) {
692      return el === doc;
693    } else if (selector === win) {
694      return el === win;
695    }
696
697    if (selector.nodeType || selector instanceof Dom7) {
698      compareWith = selector.nodeType ? [selector] : selector;
699      for (i = 0; i < compareWith.length; i += 1) {
700        if (compareWith[i] === el) {
701          return true;
702        }
703      }
704      return false;
705    }
706    return false;
707  }
708  function index() {
709    var child = this[0];
710    var i;
711    if (child) {
712      i = 0;
713      // eslint-disable-next-line
714      while ((child = child.previousSibling) !== null) {
715        if (child.nodeType === 1) {
716          i += 1;
717        }
718      }
719      return i;
720    }
721    return undefined;
722  }
723  // eslint-disable-next-line
724  function eq(index) {
725    if (typeof index === "undefined") {
726      return this;
727    }
728    var length = this.length;
729    var returnIndex;
730    if (index > length - 1) {
731      return new Dom7([]);
732    }
733    if (index < 0) {
734      returnIndex = length + index;
735      if (returnIndex < 0) {
736        return new Dom7([]);
737      }
738      return new Dom7([this[returnIndex]]);
739    }
740    return new Dom7([this[index]]);
741  }
742  function append() {
743    var args = [],
744      len = arguments.length;
745    while (len--) args[len] = arguments[len];
746
747    var newChild;
748
749    for (var k = 0; k < args.length; k += 1) {
750      newChild = args[k];
751      for (var i = 0; i < this.length; i += 1) {
752        if (typeof newChild === "string") {
753          var tempDiv = doc.createElement("div");
754          tempDiv.innerHTML = newChild;
755          while (tempDiv.firstChild) {
756            this[i].appendChild(tempDiv.firstChild);
757          }
758        } else if (newChild instanceof Dom7) {
759          for (var j = 0; j < newChild.length; j += 1) {
760            this[i].appendChild(newChild[j]);
761          }
762        } else {
763          this[i].appendChild(newChild);
764        }
765      }
766    }
767
768    return this;
769  }
770  function prepend(newChild) {
771    var i;
772    var j;
773    for (i = 0; i < this.length; i += 1) {
774      if (typeof newChild === "string") {
775        var tempDiv = doc.createElement("div");
776        tempDiv.innerHTML = newChild;
777        for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
778          this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
779        }
780      } else if (newChild instanceof Dom7) {
781        for (j = 0; j < newChild.length; j += 1) {
782          this[i].insertBefore(newChild[j], this[i].childNodes[0]);
783        }
784      } else {
785        this[i].insertBefore(newChild, this[i].childNodes[0]);
786      }
787    }
788    return this;
789  }
790  function next(selector) {
791    if (this.length > 0) {
792      if (selector) {
793        if (
794          this[0].nextElementSibling &&
795          $(this[0].nextElementSibling).is(selector)
796        ) {
797          return new Dom7([this[0].nextElementSibling]);
798        }
799        return new Dom7([]);
800      }
801
802      if (this[0].nextElementSibling) {
803        return new Dom7([this[0].nextElementSibling]);
804      }
805      return new Dom7([]);
806    }
807    return new Dom7([]);
808  }
809  function nextAll(selector) {
810    var nextEls = [];
811    var el = this[0];
812    if (!el) {
813      return new Dom7([]);
814    }
815    while (el.nextElementSibling) {
816      var next = el.nextElementSibling; // eslint-disable-line
817      if (selector) {
818        if ($(next).is(selector)) {
819          nextEls.push(next);
820        }
821      } else {
822        nextEls.push(next);
823      }
824      el = next;
825    }
826    return new Dom7(nextEls);
827  }
828  function prev(selector) {
829    if (this.length > 0) {
830      var el = this[0];
831      if (selector) {
832        if (
833          el.previousElementSibling &&
834          $(el.previousElementSibling).is(selector)
835        ) {
836          return new Dom7([el.previousElementSibling]);
837        }
838        return new Dom7([]);
839      }
840
841      if (el.previousElementSibling) {
842        return new Dom7([el.previousElementSibling]);
843      }
844      return new Dom7([]);
845    }
846    return new Dom7([]);
847  }
848  function prevAll(selector) {
849    var prevEls = [];
850    var el = this[0];
851    if (!el) {
852      return new Dom7([]);
853    }
854    while (el.previousElementSibling) {
855      var prev = el.previousElementSibling; // eslint-disable-line
856      if (selector) {
857        if ($(prev).is(selector)) {
858          prevEls.push(prev);
859        }
860      } else {
861        prevEls.push(prev);
862      }
863      el = prev;
864    }
865    return new Dom7(prevEls);
866  }
867  function parent(selector) {
868    var parents = []; // eslint-disable-line
869    for (var i = 0; i < this.length; i += 1) {
870      if (this[i].parentNode !== null) {
871        if (selector) {
872          if ($(this[i].parentNode).is(selector)) {
873            parents.push(this[i].parentNode);
874          }
875        } else {
876          parents.push(this[i].parentNode);
877        }
878      }
879    }
880    return $(unique(parents));
881  }
882  function parents(selector) {
883    var parents = []; // eslint-disable-line
884    for (var i = 0; i < this.length; i += 1) {
885      var parent = this[i].parentNode; // eslint-disable-line
886      while (parent) {
887        if (selector) {
888          if ($(parent).is(selector)) {
889            parents.push(parent);
890          }
891        } else {
892          parents.push(parent);
893        }
894        parent = parent.parentNode;
895      }
896    }
897    return $(unique(parents));
898  }
899  function closest(selector) {
900    var closest = this; // eslint-disable-line
901    if (typeof selector === "undefined") {
902      return new Dom7([]);
903    }
904    if (!closest.is(selector)) {
905      closest = closest.parents(selector).eq(0);
906    }
907    return closest;
908  }
909  function find(selector) {
910    var foundElements = [];
911    for (var i = 0; i < this.length; i += 1) {
912      var found = this[i].querySelectorAll(selector);
913      for (var j = 0; j < found.length; j += 1) {
914        foundElements.push(found[j]);
915      }
916    }
917    return new Dom7(foundElements);
918  }
919  function children(selector) {
920    var children = []; // eslint-disable-line
921    for (var i = 0; i < this.length; i += 1) {
922      var childNodes = this[i].childNodes;
923
924      for (var j = 0; j < childNodes.length; j += 1) {
925        if (!selector) {
926          if (childNodes[j].nodeType === 1) {
927            children.push(childNodes[j]);
928          }
929        } else if (
930          childNodes[j].nodeType === 1 &&
931          $(childNodes[j]).is(selector)
932        ) {
933          children.push(childNodes[j]);
934        }
935      }
936    }
937    return new Dom7(unique(children));
938  }
939  function remove() {
940    for (var i = 0; i < this.length; i += 1) {
941      if (this[i].parentNode) {
942        this[i].parentNode.removeChild(this[i]);
943      }
944    }
945    return this;
946  }
947  function add() {
948    var args = [],
949      len = arguments.length;
950    while (len--) args[len] = arguments[len];
951
952    var dom = this;
953    var i;
954    var j;
955    for (i = 0; i < args.length; i += 1) {
956      var toAdd = $(args[i]);
957      for (j = 0; j < toAdd.length; j += 1) {
958        dom[dom.length] = toAdd[j];
959        dom.length += 1;
960      }
961    }
962    return dom;
963  }
964
965  var Methods = {
966    addClass: addClass,
967    removeClass: removeClass,
968    hasClass: hasClass,
969    toggleClass: toggleClass,
970    attr: attr,
971    removeAttr: removeAttr,
972    data: data,
973    transform: transform,
974    transition: transition,
975    on: on,
976    off: off,
977    trigger: trigger,
978    transitionEnd: transitionEnd,
979    outerWidth: outerWidth,
980    outerHeight: outerHeight,
981    offset: offset,
982    css: css,
983    each: each,
984    html: html,
985    text: text,
986    is: is,
987    index: index,
988    eq: eq,
989    append: append,
990    prepend: prepend,
991    next: next,
992    nextAll: nextAll,
993    prev: prev,
994    prevAll: prevAll,
995    parent: parent,
996    parents: parents,
997    closest: closest,
998    find: find,
999    children: children,
1000    filter: filter,
1001    remove: remove,
1002    add: add,
1003    styles: styles,
1004  };
1005
1006  Object.keys(Methods).forEach(function (methodName) {
1007    $.fn[methodName] = $.fn[methodName] || Methods[methodName];
1008  });
1009
1010  var Utils = {
1011    deleteProps: function deleteProps(obj) {
1012      var object = obj;
1013      Object.keys(object).forEach(function (key) {
1014        try {
1015          object[key] = null;
1016        } catch (e) {
1017          // no getter for object
1018        }
1019        try {
1020          delete object[key];
1021        } catch (e) {
1022          // something got wrong
1023        }
1024      });
1025    },
1026    nextTick: function nextTick(callback, delay) {
1027      if (delay === void 0) delay = 0;
1028
1029      return setTimeout(callback, delay);
1030    },
1031    now: function now() {
1032      return Date.now();
1033    },
1034    getTranslate: function getTranslate(el, axis) {
1035      if (axis === void 0) axis = "x";
1036
1037      var matrix;
1038      var curTransform;
1039      var transformMatrix;
1040
1041      var curStyle = win.getComputedStyle(el, null);
1042
1043      if (win.WebKitCSSMatrix) {
1044        curTransform = curStyle.transform || curStyle.webkitTransform;
1045        if (curTransform.split(",").length > 6) {
1046          curTransform = curTransform
1047            .split(", ")
1048            .map(function (a) {
1049              return a.replace(",", ".");
1050            })
1051            .join(", ");
1052        }
1053        // Some old versions of Webkit choke when 'none' is passed; pass
1054        // empty string instead in this case
1055        transformMatrix = new win.WebKitCSSMatrix(
1056          curTransform === "none" ? "" : curTransform,
1057        );
1058      } else {
1059        transformMatrix =
1060          curStyle.MozTransform ||
1061          curStyle.OTransform ||
1062          curStyle.MsTransform ||
1063          curStyle.msTransform ||
1064          curStyle.transform ||
1065          curStyle
1066            .getPropertyValue("transform")
1067            .replace("translate(", "matrix(1, 0, 0, 1,");
1068        matrix = transformMatrix.toString().split(",");
1069      }
1070
1071      if (axis === "x") {
1072        // Latest Chrome and webkits Fix
1073        if (win.WebKitCSSMatrix) {
1074          curTransform = transformMatrix.m41;
1075        }
1076        // Crazy IE10 Matrix
1077        else if (matrix.length === 16) {
1078          curTransform = parseFloat(matrix[12]);
1079        }
1080        // Normal Browsers
1081        else {
1082          curTransform = parseFloat(matrix[4]);
1083        }
1084      }
1085      if (axis === "y") {
1086        // Latest Chrome and webkits Fix
1087        if (win.WebKitCSSMatrix) {
1088          curTransform = transformMatrix.m42;
1089        }
1090        // Crazy IE10 Matrix
1091        else if (matrix.length === 16) {
1092          curTransform = parseFloat(matrix[13]);
1093        }
1094        // Normal Browsers
1095        else {
1096          curTransform = parseFloat(matrix[5]);
1097        }
1098      }
1099      return curTransform || 0;
1100    },
1101    parseUrlQuery: function parseUrlQuery(url) {
1102      var query = {};
1103      var urlToParse = url || win.location.href;
1104      var i;
1105      var params;
1106      var param;
1107      var length;
1108      if (typeof urlToParse === "string" && urlToParse.length) {
1109        urlToParse =
1110          urlToParse.indexOf("?") > -1 ? urlToParse.replace(/\S*\?/, "") : "";
1111        params = urlToParse.split("&").filter(function (paramsPart) {
1112          return paramsPart !== "";
1113        });
1114        length = params.length;
1115
1116        for (i = 0; i < length; i += 1) {
1117          param = params[i].replace(/#\S+/g, "").split("=");
1118          query[decodeURIComponent(param[0])] =
1119            typeof param[1] === "undefined"
1120              ? undefined
1121              : decodeURIComponent(param[1]) || "";
1122        }
1123      }
1124      return query;
1125    },
1126    isObject: function isObject(o) {
1127      return (
1128        typeof o === "object" &&
1129        o !== null &&
1130        o.constructor &&
1131        o.constructor === Object
1132      );
1133    },
1134    extend: function extend() {
1135      var args = [],
1136        len$1 = arguments.length;
1137      while (len$1--) args[len$1] = arguments[len$1];
1138
1139      var to = Object(args[0]);
1140      for (var i = 1; i < args.length; i += 1) {
1141        var nextSource = args[i];

1227      Object.keys(self.params.on).forEach(function (eventName) {
1228        self.on(eventName, self.params.on[eventName]);
1229      });
1230    }
1231  };
1232
1233  var staticAccessors = { components: { configurable: true } };
1234
1235  SwiperClass.prototype.on = function on(events, handler, priority) {
1236    var self = this;
1237    if (typeof handler !== "function") {
1238      return self;
1239    }
1240    var method = priority ? "unshift" : "push";
1241    events.split(" ").forEach(function (event) {
1242      if (!self.eventsListeners[event]) {
1243        self.eventsListeners[event] = [];
1244      }
1245      self.eventsListeners[event][method](handler);
1246    });
1247    return self;
1248  };
1249
1250  SwiperClass.prototype.once = function once(events, handler, priority) {
1251    var self = this;
1252    if (typeof handler !== "function") {
1253      return self;
1254    }
1255    function onceHandler() {
1256      var args = [],
1257        len = arguments.length;
1258      while (len--) args[len] = arguments[len];
1259
1260      self.off(events, onceHandler);
1261      if (onceHandler.f7proxy) {
1262        delete onceHandler.f7proxy;
1263      }
1264      handler.apply(self, args);
1265    }
1266    onceHandler.f7proxy = handler;
1267    return self.on(events, onceHandler, priority);
1268  };
1269
1270  SwiperClass.prototype.off = function off(events, handler) {
1271    var self = this;
1272    if (!self.eventsListeners) {
1273      return self;
1274    }
1275    events.split(" ").forEach(function (event) {
1276      if (typeof handler === "undefined") {
1277        self.eventsListeners[event] = [];
1278      } else if (
1279        self.eventsListeners[event] &&
1280        self.eventsListeners[event].length
1281      ) {
1282        self.eventsListeners[event].forEach(function (eventHandler, index) {
1283          if (
1284            eventHandler === handler ||
1285            (eventHandler.f7proxy && eventHandler.f7proxy === handler)
1286          ) {
1287            self.eventsListeners[event].splice(index, 1);
1288          }
1289        });
1290      }
1291    });
1292    return self;
1293  };
1294
1295  SwiperClass.prototype.emit = function emit() {
1296    var args = [],
1297      len = arguments.length;
1298    while (len--) args[len] = arguments[len];
1299
1300    var self = this;
1301    if (!self.eventsListeners) {
1302      return self;
1303    }
1304    var events;
1305    var data;
1306    var context;
1307    if (typeof args[0] === "string" || Array.isArray(args[0])) {
1308      events = args[0];
1309      data = args.slice(1, args.length);
1310      context = self;
1311    } else {
1312      events = args[0].events;
1313      data = args[0].data;
1314      context = args[0].context || self;
1315    }
1316    var eventsArray = Array.isArray(events) ? events : events.split(" ");
1317    eventsArray.forEach(function (event) {
1318      if (self.eventsListeners && self.eventsListeners[event]) {
1319        var handlers = [];
1320        self.eventsListeners[event].forEach(function (eventHandler) {
1321          handlers.push(eventHandler);
1322        });
1323        handlers.forEach(function (eventHandler) {
1324          eventHandler.apply(context, data);
1325        });
1326      }
1327    });
1328    return self;
1329  };
1330
1331  SwiperClass.prototype.useModulesParams = function useModulesParams(
1332    instanceParams,
1333  ) {
1334    var instance = this;
1335    if (!instance.modules) {
1336      return;
1337    }
1338    Object.keys(instance.modules).forEach(function (moduleName) {
1339      var module = instance.modules[moduleName];
1340      // Extend params
1341      if (module.params) {
1342        Utils.extend(instanceParams, module.params);
1343      }
1344    });
1345  };
1346
1347  SwiperClass.prototype.useModules = function useModules(modulesParams) {
1348    if (modulesParams === void 0) modulesParams = {};
1349
1350    var instance = this;
1351    if (!instance.modules) {
1352      return;
1353    }
1354    Object.keys(instance.modules).forEach(function (moduleName) {
1355      var module = instance.modules[moduleName];
1356      var moduleParams = modulesParams[moduleName] || {};
1357      // Extend instance methods and props
1358      if (module.instance) {
1359        Object.keys(module.instance).forEach(function (modulePropName) {
1360          var moduleProp = module.instance[modulePropName];
1361          if (typeof moduleProp === "function") {
1362            instance[modulePropName] = moduleProp.bind(instance);
1363          } else {
1364            instance[modulePropName] = moduleProp;
1365          }
1366        });
1367      }
1368      // Add event listeners
1369      if (module.on && instance.on) {
1370        Object.keys(module.on).forEach(function (moduleEventName) {
1371          instance.on(moduleEventName, module.on[moduleEventName]);
1372        });
1373      }
1374
1375      // Module create callback
1376      if (module.create) {
1377        module.create.bind(instance)(moduleParams);
1378      }
1379    });
1380  };
1381
1382  staticAccessors.components.set = function (components) {
1383    var Class = this;
1384    if (!Class.use) {
1385      return;
1386    }
1387    Class.use(components);
1388  };
1389
1390  SwiperClass.installModule = function installModule(module) {
1391    var params = [],
1392      len = arguments.length - 1;
1393    while (len-- > 0) params[len] = arguments[len + 1];
1394
1395    var Class = this;
1396    if (!Class.prototype.modules) {
1397      Class.prototype.modules = {};
1398    }
1399    var name =
1400      module.name ||
1401      Object.keys(Class.prototype.modules).length + "_" + Utils.now();
1402    Class.prototype.modules[name] = module;
1403    // Prototype
1404    if (module.proto) {
1405      Object.keys(module.proto).forEach(function (key) {
1406        Class.prototype[key] = module.proto[key];
1407      });
1408    }
1409    // Class
1410    if (module.static) {
1411      Object.keys(module.static).forEach(function (key) {
1412        Class[key] = module.static[key];
1413      });
1414    }
1415    // Callback
1416    if (module.install) {
1417      module.install.apply(Class, params);
1418    }
1419    return Class;
1420  };
1421
1422  SwiperClass.use = function use(module) {
1423    var params = [],
1424      len = arguments.length - 1;
1425    while (len-- > 0) params[len] = arguments[len + 1];
1426
1427    var Class = this;
1428    if (Array.isArray(module)) {
1429      module.forEach(function (m) {
1430        return Class.installModule(m);
1431      });
1432      return Class;
1433    }
1434    return Class.installModule.apply(Class, [module].concat(params));
1435  };
1436
1437  Object.defineProperties(SwiperClass, staticAccessors);
1438
1439  function updateSize() {
1440    var swiper = this;
1441    var width;
1442    var height;
1443    var $el = swiper.$el;
1444    if (typeof swiper.params.width !== "undefined") {
1445      width = swiper.params.width;
1446    } else {
1447      width = $el[0].clientWidth;
1448    }
1449    if (typeof swiper.params.height !== "undefined") {
1450      height = swiper.params.height;
1451    } else {
1452      height = $el[0].clientHeight;
1453    }
1454    if (
1455      (width === 0 && swiper.isHorizontal()) ||
1456      (height === 0 && swiper.isVertical())
1457    ) {
1458      return;
1459    }
1460
1461    // Subtract paddings
1462    width =
1463      width -
1464      parseInt($el.css("padding-left"), 10) -
1465      parseInt($el.css("padding-right"), 10);
1466    height =
1467      height -
1468      parseInt($el.css("padding-top"), 10) -
1469      parseInt($el.css("padding-bottom"), 10);
1470
1471    Utils.extend(swiper, {
1472      width: width,
1473      height: height,
1474      size: swiper.isHorizontal() ? width : height,
1475    });
1476  }
1477
1478  function updateSlides() {
1479    var swiper = this;
1480    var params = swiper.params;
1481
1482    var $wrapperEl = swiper.$wrapperEl;
1483    var swiperSize = swiper.size;
1484    var rtl = swiper.rtlTranslate;
1485    var wrongRTL = swiper.wrongRTL;
1486    var isVirtual = swiper.virtual && params.virtual.enabled;
1487    var previousSlidesLength = isVirtual
1488      ? swiper.virtual.slides.length
1489      : swiper.slides.length;
1490    var slides = $wrapperEl.children("." + swiper.params.slideClass);
1491    var slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1492    var snapGrid = [];
1493    var slidesGrid = [];
1494    var slidesSizesGrid = [];
1495
1496    function slidesForMargin(slideIndex) {
1497      if (!params.cssMode) {
1498        return true;
1499      }
1500      if (slideIndex === slides.length - 1) {
1501        return false;
1502      }
1503      return true;
1504    }
1505
1506    var offsetBefore = params.slidesOffsetBefore;
1507    if (typeof offsetBefore === "function") {
1508      offsetBefore = params.slidesOffsetBefore.call(swiper);
1509    }
1510
1511    var offsetAfter = params.slidesOffsetAfter;
1512    if (typeof offsetAfter === "function") {
1513      offsetAfter = params.slidesOffsetAfter.call(swiper);
1514    }
1515
1516    var previousSnapGridLength = swiper.snapGrid.length;
1517    var previousSlidesGridLength = swiper.snapGrid.length;
1518
1519    var spaceBetween = params.spaceBetween;
1520    var slidePosition = -offsetBefore;
1521    var prevSlideSize = 0;
1522    var index = 0;
1523    if (typeof swiperSize === "undefined") {
1524      return;
1525    }
1526    if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) {
1527      spaceBetween =
1528        (parseFloat(spaceBetween.replace("%", "")) / 100) * swiperSize;
1529    }
1530
1531    swiper.virtualSize = -spaceBetween;
1532
1533    // reset margins
1534    if (rtl) {
1535      slides.css({ marginLeft: "", marginTop: "" });
1536    } else {
1537      slides.css({ marginRight: "", marginBottom: "" });
1538    }
1539

1892        slidesGrid.forEach(function (snap, snapIndex) {
1893          slidesGrid[snapIndex] = snap + allSlidesOffset;
1894        });
1895      }
1896    }
1897
1898    Utils.extend(swiper, {
1899      slides: slides,
1900      snapGrid: snapGrid,
1901      slidesGrid: slidesGrid,
1902      slidesSizesGrid: slidesSizesGrid,
1903    });
1904
1905    if (slidesLength !== previousSlidesLength) {
1906      swiper.emit("slidesLengthChange");
1907    }
1908    if (snapGrid.length !== previousSnapGridLength) {
1909      if (swiper.params.watchOverflow) {
1910        swiper.checkOverflow();
1911      }
1912      swiper.emit("snapGridLengthChange");
1913    }
1914    if (slidesGrid.length !== previousSlidesGridLength) {
1915      swiper.emit("slidesGridLengthChange");
1916    }
1917
1918    if (params.watchSlidesProgress || params.watchSlidesVisibility) {
1919      swiper.updateSlidesOffset();
1920    }
1921  }
1922
1923  function updateAutoHeight(speed) {
1924    var swiper = this;
1925    var activeSlides = [];
1926    var newHeight = 0;
1927    var i;
1928    if (typeof speed === "number") {
1929      swiper.setTransition(speed);
1930    } else if (speed === true) {
1931      swiper.setTransition(swiper.params.speed);
1932    }
1933    // Find slides currently in view
1934    if (
1935      swiper.params.slidesPerView !== "auto" &&
1936      swiper.params.slidesPerView > 1
1937    ) {
1938      if (swiper.params.centeredSlides) {
1939        swiper.visibleSlides.each(function (index, slide) {
1940          activeSlides.push(slide);
1941        });
1942      } else {
1943        for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1944          var index = swiper.activeIndex + i;
1945          if (index > swiper.slides.length) {
1946            break;
1947          }
1948          activeSlides.push(swiper.slides.eq(index)[0]);
1949        }
1950      }
1951    } else {
1952      activeSlides.push(swiper.slides.eq(swiper.activeIndex)[0]);
1953    }
1954
1955    // Find new height from highest slide in view
1956    for (i = 0; i < activeSlides.length; i += 1) {
1957      if (typeof activeSlides[i] !== "undefined") {
1958        var height = activeSlides[i].offsetHeight;
1959        newHeight = height > newHeight ? height : newHeight;
1960      }
1961    }
1962
1963    // Update Height
1964    if (newHeight) {
1965      swiper.$wrapperEl.css("height", newHeight + "px");
1966    }
1967  }
1968
1969  function updateSlidesOffset() {
1970    var swiper = this;
1971    var slides = swiper.slides;
1972    for (var i = 0; i < slides.length; i += 1) {
1973      slides[i].swiperSlideOffset = swiper.isHorizontal()
1974        ? slides[i].offsetLeft
1975        : slides[i].offsetTop;
1976    }
1977  }
1978
1979  function updateSlidesProgress(translate) {
1980    if (translate === void 0) translate = (this && this.translate) || 0;
1981
1982    var swiper = this;
1983    var params = swiper.params;
1984
1985    var slides = swiper.slides;
1986    var rtl = swiper.rtlTranslate;
1987
1988    if (slides.length === 0) {
1989      return;
1990    }
1991    if (typeof slides[0].swiperSlideOffset === "undefined") {
1992      swiper.updateSlidesOffset();
1993    }
1994
1995    var offsetCenter = -translate;
1996    if (rtl) {
1997      offsetCenter = translate;
1998    }
1999
2000    // Visible Slides
2001    slides.removeClass(params.slideVisibleClass);
2002
2003    swiper.visibleSlidesIndexes = [];
2004    swiper.visibleSlides = [];
2005
2006    for (var i = 0; i < slides.length; i += 1) {
2007      var slide = slides[i];
2008      var slideProgress =
2009        (offsetCenter +
2010          (params.centeredSlides ? swiper.minTranslate() : 0) -
2011          slide.swiperSlideOffset) /
2012        (slide.swiperSlideSize + params.spaceBetween);
2013      if (
2014        params.watchSlidesVisibility ||
2015        (params.centeredSlides && params.autoHeight)
2016      ) {
2017        var slideBefore = -(offsetCenter - slide.swiperSlideOffset);
2018        var slideAfter = slideBefore + swiper.slidesSizesGrid[i];
2019        var isVisible =
2020          (slideBefore >= 0 && slideBefore < swiper.size - 1) ||
2021          (slideAfter > 1 && slideAfter <= swiper.size) ||
2022          (slideBefore <= 0 && slideAfter >= swiper.size);
2023        if (isVisible) {
2024          swiper.visibleSlides.push(slide);
2025          swiper.visibleSlidesIndexes.push(i);
2026          slides.eq(i).addClass(params.slideVisibleClass);
2027        }
2028      }
2029      slide.progress = rtl ? -slideProgress : slideProgress;
2030    }
2031    swiper.visibleSlides = $(swiper.visibleSlides);
2032  }
2033
2034  function updateProgress(translate) {
2035    var swiper = this;
2036    if (typeof translate === "undefined") {
2037      var multiplier = swiper.rtlTranslate ? -1 : 1;
2038      // eslint-disable-next-line
2039      translate =
2040        (swiper && swiper.translate && swiper.translate * multiplier) || 0;
2041    }
2042    var params = swiper.params;
2043    var translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2044    var progress = swiper.progress;
2045    var isBeginning = swiper.isBeginning;
2046    var isEnd = swiper.isEnd;
2047    var wasBeginning = isBeginning;
2048    var wasEnd = isEnd;
2049    if (translatesDiff === 0) {
2050      progress = 0;
2051      isBeginning = true;
2052      isEnd = true;
2053    } else {
2054      progress = (translate - swiper.minTranslate()) / translatesDiff;
2055      isBeginning = progress <= 0;
2056      isEnd = progress >= 1;
2057    }
2058    Utils.extend(swiper, {
2059      progress: progress,
2060      isBeginning: isBeginning,
2061      isEnd: isEnd,
2062    });

2228per.translate;
2229    var slidesGrid = swiper.slidesGrid;
2230    var snapGrid = swiper.snapGrid;
2231    var params = swiper.params;
2232    var previousIndex = swiper.activeIndex;
2233    var previousRealIndex = swiper.realIndex;
2234    var previousSnapIndex = swiper.snapIndex;
2235    var activeIndex = newActiveIndex;
2236    var snapIndex;
2237    if (typeof activeIndex === "undefined") {
2238      for (var i = 0; i < slidesGrid.length; i += 1) {
2239        if (typeof slidesGrid[i + 1] !== "undefined") {
2240          if (
2241            translate >= slidesGrid[i] &&
2242            translate <
2243              slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2
2244          ) {
2245            activeIndex = i;
2246          } else if (
2247            translate >= slidesGrid[i] &&
2248            translate < slidesGrid[i + 1]
2249          ) {
2250            activeIndex = i + 1;
2251          }
2252        } else if (translate >= slidesGrid[i]) {
2253          activeIndex = i;
2254        }
2255      }
2256      // Normalize slideIndex
2257      if (params.normalizeSlideIndex) {
2258        if (activeIndex < 0 || typeof activeIndex === "undefined") {
2259          activeIndex = 0;
2260        }
2261      }
2262    }
2263    if (snapGrid.indexOf(translate) >= 0) {
2264      snapIndex = snapGrid.indexOf(translate);
2265    } else {
2266      var skip = Math.min(params.slidesPerGroupSkip, activeIndex);
2267      snapIndex =
2268        skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
2269    }
2270    if (snapIndex >= snapGrid.length) {
2271      snapIndex = snapGrid.length - 1;
2272    }
2273    if (activeIndex === previousIndex) {
2274      if (snapIndex !== previousSnapIndex) {
2275        swiper.snapIndex = snapIndex;
2276        swiper.emit("snapIndexChange");
2277      }
2278      return;
2279    }
2280
2281    // Get real index
2282    var realIndex = parseInt(
2283      swiper.slides.eq(activeIndex).attr("data-swiper-slide-index") ||
2284        activeIndex,
2285      10,
2286    );
2287
2288    Utils.extend(swiper, {
2289      snapIndex: snapIndex,
2290      realIndex: realIndex,
2291      previousIndex: previousIndex,
2292      activeIndex: activeIndex,
2293    });
2294    swiper.emit("activeIndexChange");
2295    swiper.emit("snapIndexChange");
2296    if (previousRealIndex !== realIndex) {
2297      swiper.emit("realIndexChange");
2298    }
2299    if (swiper.initialized || swiper.params.runCallbacksOnInit) {
2300      swiper.emit("slideChange");
2301    }
2302  }
2303
2304  function updateClickedSlide(e) {
2305    var swiper = this;
2306    var params = swiper.params;
2307    var slide = $(e.target).closest("." + params.slideClass)[0];
2308    var slideFound = false;
2309    if (slide) {
2310      for (var i = 0; i < swiper.slides.length; i += 1) {
2311        if (swiper.slides[i] === slide) {
2312          slideFound = true;
2313        }
2314      }
2315    }
2316
2317    if (slide && slideFound) {
2318      swiper.clickedSlide = slide;
2319      if (swiper.virtual && swiper.params.virtual.enabled) {
2320        swiper.clickedIndex = parseInt(
2321          $(slide).attr("data-swiper-slide-index"),
2322          10,
2323        );
2324      } else {
2325        swiper.clickedIndex = $(slide).index();
2326      }
2327    } else {
2328      swiper.clickedSlide = undefined;
2329      swiper.clickedIndex = undefined;
2330      return;
2331    }
2332    if (
2333      params.slideToClickedSlide &&
2334      swiper.clickedIndex !== undefined &&
2335      swiper.clickedIndex !== swiper.activeIndex
2336    ) {
2337      swiper.slideToClickedSlide();
2338    }
2339  }
2340
2341  var update = {
2342    updateSize: updateSize,
2343    updateSlides: updateSlides,
2344    updateAutoHeight: updateAutoHeight,
2345    updateSlidesOffset: updateSlidesOffset,
2346    updateSlidesProgress: updateSlidesProgress,
2347    updateProgress: updateProgress,
2348    updateSlidesClasses: updateSlidesClasses,
2349    updateActiveIndex: updateActiveIndex,
2350    updateClickedSlide: updateClickedSlide,
2351  };
2352
2353  function getTranslate(axis) {
2354    if (axis === void 0) axis = this.isHorizontal() ? "x" : "y";
2355
2356    var swiper = this;
2357
2358    var params = swiper.params;
2359    var rtl = swiper.rtlTranslate;
2360    var translate = swiper.translate;
2361    var $wrapperEl = swiper.$wrapperEl;
2362
2363    if (params.virtualTranslate) {
2364      return rtl ? -translate : translate;
2365    }
2366    if (params.cssMode) {
2367      return translate;
2368    }
2369
2370    var currentTranslate = Utils.getTranslate($wrapperEl[0], axis);