https://appris.ac.uk/wp-content/plugins/kubio-pro/static/swiper/js/swiper.js?ver=690ab2e27b0b381b549a

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

457		}
458
459		var events = eventType.split(' ');
460		for (var i = 0; i < events.length; i += 1) {
461			var event = events[i];
462			for (var j = 0; j < this.length; j += 1) {
463				var el = this$1[j];
464				var handlers = void 0;
465				if (!targetSelector && el.dom7Listeners) {
466					handlers = el.dom7Listeners[event];
467				} else if (targetSelector && el.dom7LiveListeners) {
468					handlers = el.dom7LiveListeners[event];
469				}
470				if (handlers && handlers.length) {
471					for (var k = handlers.length - 1; k >= 0; k -= 1) {
472						var handler = handlers[k];
473						if (listener && handler.listener === listener) {
474							el.removeEventListener(
475								event,
476								handler.proxyListener,
477								capture
478							);
479							handlers.splice(k, 1);
480						} else if (!listener) {
481							el.removeEventListener(
482								event,
483								handler.proxyListener,
484								capture
485							);
486							handlers.splice(k, 1);
487						}
488					}
489				}
490			}
491		}
492		return this;
493	}
494	function trigger() {
495		var this$1 = this;
496		var args = [],
497			len = arguments.length;
498		while (len--) args[len] = arguments[len];
499
500		var events = args[0].split(' ');
501		var eventData = args[1];
502		for (var i = 0; i < events.length; i += 1) {
503			var event = events[i];
504			for (var j = 0; j < this.length; j += 1) {
505				var el = this$1[j];
506				var evt = void 0;
507				try {
508					evt = new win.CustomEvent(event, {
509						detail: eventData,
510						bubbles: true,
511						cancelable: true,
512					});
513				} catch (e) {
514					evt = doc.createEvent('Event');
515					evt.initEvent(event, true, true);
516					evt.detail = eventData;
517				}
518				// eslint-disable-next-line
519				el.dom7EventData = args.filter(function (data, dataIndex) {
520					return dataIndex > 0;
521				});
522				el.dispatchEvent(evt);
523				el.dom7EventData = [];
524				delete el.dom7EventData;
525			}
526		}
527		return this;
528	}
529	function transitionEnd(callback) {
530		var events = ['webkitTransitionEnd', 'transitionend'];
531		var dom = this;
532		var i;
533		function fireCallBack(e) {
534			/* jshint validthis:true */
535			if (e.target !== this) {
536				return;
537			}
538			callback.call(this, e);
539			for (i = 0; i < events.length; i += 1) {
540				dom.off(events[i], fireCallBack);
541			}
542		}
543		if (callback) {
544			for (i = 0; i < events.length; i += 1) {
545				dom.on(events[i], fireCallBack);
546			}
547		}
548		return this;
549	}
550	function outerWidth(includeMargins) {
551		if (this.length > 0) {
552			if (includeMargins) {
553				// eslint-disable-next-line
554				var styles = this.styles();
555				return (
556					this[0].offsetWidth +
557					parseFloat(styles.getPropertyValue('margin-right')) +
558					parseFloat(styles.getPropertyValue('margin-left'))
559				);
560			}
561			return this[0].offsetWidth;
562		}
563		return null;
564	}
565	function outerHeight(includeMargins) {
566		if (this.length > 0) {
567			if (includeMargins) {
568				// eslint-disable-next-line
569				var styles = this.styles();
570				return (
571					this[0].offsetHeight +
572					parseFloat(styles.getPropertyValue('margin-top')) +
573					parseFloat(styles.getPropertyValue('margin-bottom'))
574				);
575			}
576			return this[0].offsetHeight;
577		}
578		return null;
579	}
580	function offset() {
581		if (this.length > 0) {
582			var el = this[0];
583			var box = el.getBoundingClientRect();
584			var body = doc.body;
585			var clientTop = el.clientTop || body.clientTop || 0;
586			var clientLeft = el.clientLeft || body.clientLeft || 0;
587			var scrollTop = el === win ? win.scrollY : el.scrollTop;
588			var scrollLeft = el === win ? win.scrollX : el.scrollLeft;
589			return {
590				top: box.top + scrollTop - clientTop,
591				left: box.left + scrollLeft - clientLeft,
592			};
593		}
594
595		return null;
596	}
597	function styles() {
598		if (this[0]) {
599			return win.getComputedStyle(this[0], null);
600		}
601		return {};
602	}
603	function css(props, value) {
604		var this$1 = this;
605
606		var i;
607		if (arguments.length === 1) {
608			if (typeof props === 'string') {
609				if (this[0]) {
610					return win
611						.getComputedStyle(this[0], null)
612						.getPropertyValue(props);
613				}
614			} else {
615				for (i = 0; i < this.length; i += 1) {
616					// eslint-disable-next-line
617					for (var prop in props) {
618						this$1[i].style[prop] = props[prop];
619					}
620				}
621				return this;
622			}
623		}
624		if (arguments.length === 2 && typeof props === 'string') {
625			for (i = 0; i < this.length; i += 1) {
626				this$1[i].style[props] = value;
627			}
628			return this;
629		}
630		return this;
631	}
632	// Iterate over the collection passing elements to `callback`
633	function each(callback) {
634		var this$1 = this;
635
636		// Don't bother continuing without a callback
637		if (!callback) {
638			return this;
639		}
640		// Iterate over the current collection
641		for (var i = 0; i < this.length; i += 1) {
642			// If the callback returns false
643			if (callback.call(this$1[i], i, this$1[i]) === false) {
644				// End the loop early
645				return this$1;
646			}
647		}
648		// Return `this` to allow chained DOM operations
649		return this;
650	}
651	// eslint-disable-next-line
652	function html(html) {
653		var this$1 = this;
654
655		if (typeof html === 'undefined') {
656			return this[0] ? this[0].innerHTML : undefined;
657		}
658
659		for (var i = 0; i < this.length; i += 1) {
660			this$1[i].innerHTML = html;
661		}
662		return this;
663	}
664	// eslint-disable-next-line
665	function text(text) {
666		var this$1 = this;
667
668		if (typeof text === 'undefined') {
669			if (this[0]) {
670				return this[0].textContent.trim();
671			}
672			return null;
673		}
674
675		for (var i = 0; i < this.length; i += 1) {
676			this$1[i].textContent = text;
677		}
678		return this;
679	}
680	function is(selector) {
681		var el = this[0];
682		var compareWith;
683		var i;
684		if (!el || typeof selector === 'undefined') {
685			return false;
686		}
687		if (typeof selector === 'string') {
688			if (el.matches) {
689				return el.matches(selector);
690			} else if (el.webkitMatchesSelector) {
691				return el.webkitMatchesSelector(selector);
692			} else if (el.msMatchesSelector) {
693				return el.msMatchesSelector(selector);
694			}
695
696			compareWith = $(selector);
697			for (i = 0; i < compareWith.length; i += 1) {
698				if (compareWith[i] === el) {
699					return true;
700				}
701			}
702			return false;
703		} else if (selector === doc) {
704			return el === doc;
705		} else if (selector === win) {
706			return el === win;
707		}
708
709		if (selector.nodeType || selector instanceof Dom7) {
710			compareWith = selector.nodeType ? [selector] : selector;
711			for (i = 0; i < compareWith.length; i += 1) {
712				if (compareWith[i] === el) {
713					return true;
714				}
715			}
716			return false;
717		}
718		return false;
719	}
720	function index() {
721		var child = this[0];
722		var i;
723		if (child) {
724			i = 0;
725			// eslint-disable-next-line
726			while ((child = child.previousSibling) !== null) {
727				if (child.nodeType === 1) {
728					i += 1;
729				}
730			}
731			return i;
732		}
733		return undefined;
734	}
735	// eslint-disable-next-line
736	function eq(index) {
737		if (typeof index === 'undefined') {
738			return this;
739		}
740		var length = this.length;
741		var returnIndex;
742		if (index > length - 1) {
743			return new Dom7([]);
744		}
745		if (index < 0) {
746			returnIndex = length + index;
747			if (returnIndex < 0) {
748				return new Dom7([]);
749			}
750			return new Dom7([this[returnIndex]]);
751		}
752		return new Dom7([this[index]]);
753	}
754	function append() {
755		var this$1 = this;
756		var args = [],
757			len = arguments.length;
758		while (len--) args[len] = arguments[len];
759
760		var newChild;
761
762		for (var k = 0; k < args.length; k += 1) {
763			newChild = args[k];
764			for (var i = 0; i < this.length; i += 1) {
765				if (typeof newChild === 'string') {
766					var tempDiv = doc.createElement('div');
767					tempDiv.innerHTML = newChild;
768					while (tempDiv.firstChild) {
769						this$1[i].appendChild(tempDiv.firstChild);
770					}
771				} else if (newChild instanceof Dom7) {
772					for (var j = 0; j < newChild.length; j += 1) {
773						this$1[i].appendChild(newChild[j]);
774					}
775				} else {
776					this$1[i].appendChild(newChild);
777				}
778			}
779		}
780
781		return this;
782	}
783	function prepend(newChild) {
784		var this$1 = this;
785
786		var i;
787		var j;
788		for (i = 0; i < this.length; i += 1) {
789			if (typeof newChild === 'string') {
790				var tempDiv = doc.createElement('div');
791				tempDiv.innerHTML = newChild;
792				for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
793					this$1[i].insertBefore(
794						tempDiv.childNodes[j],
795						this$1[i].childNodes[0]
796					);
797				}
798			} else if (newChild instanceof Dom7) {
799				for (j = 0; j < newChild.length; j += 1) {
800					this$1[i].insertBefore(
801						newChild[j],
802						this$1[i].childNodes[0]
803					);
804				}
805			} else {
806				this$1[i].insertBefore(newChild, this$1[i].childNodes[0]);
807			}
808		}
809		return this;
810	}
811	function next(selector) {
812		if (this.length > 0) {
813			if (selector) {
814				if (
815					this[0].nextElementSibling &&
816					$(this[0].nextElementSibling).is(selector)
817				) {
818					return new Dom7([this[0].nextElementSibling]);
819				}
820				return new Dom7([]);
821			}
822
823			if (this[0].nextElementSibling) {
824				return new Dom7([this[0].nextElementSibling]);
825			}
826			return new Dom7([]);
827		}
828		return new Dom7([]);
829	}
830	function nextAll(selector) {
831		var nextEls = [];
832		var el = this[0];
833		if (!el) {
834			return new Dom7([]);
835		}
836		while (el.nextElementSibling) {
837			var next = el.nextElementSibling; // eslint-disable-line
838			if (selector) {
839				if ($(next).is(selector)) {
840					nextEls.push(next);
841				}
842			} else {
843				nextEls.push(next);
844			}
845			el = next;
846		}
847		return new Dom7(nextEls);
848	}
849	function prev(selector) {
850		if (this.length > 0) {
851			var el = this[0];
852			if (selector) {
853				if (
854					el.previousElementSibling &&
855					$(el.previousElementSibling).is(selector)
856				) {
857					return new Dom7([el.previousElementSibling]);
858				}
859				return new Dom7([]);
860			}
861
862			if (el.previousElementSibling) {
863				return new Dom7([el.previousElementSibling]);
864			}
865			return new Dom7([]);
866		}
867		return new Dom7([]);
868	}
869	function prevAll(selector) {
870		var prevEls = [];
871		var el = this[0];
872		if (!el) {
873			return new Dom7([]);
874		}
875		while (el.previousElementSibling) {
876			var prev = el.previousElementSibling; // eslint-disable-line
877			if (selector) {
878				if ($(prev).is(selector)) {
879					prevEls.push(prev);
880				}
881			} else {
882				prevEls.push(prev);
883			}
884			el = prev;
885		}
886		return new Dom7(prevEls);
887	}
888	function parent(selector) {
889		var this$1 = this;
890
891		var parents = []; // eslint-disable-line
892		for (var i = 0; i < this.length; i += 1) {
893			if (this$1[i].parentNode !== null) {
894				if (selector) {
895					if ($(this$1[i].parentNode).is(selector)) {
896						parents.push(this$1[i].parentNode);
897					}
898				} else {
899					parents.push(this$1[i].parentNode);
900				}
901			}
902		}
903		return $(unique(parents));
904	}
905	function parents(selector) {
906		var this$1 = this;
907
908		var parents = []; // eslint-disable-line
909		for (var i = 0; i < this.length; i += 1) {
910			var parent = this$1[i].parentNode; // eslint-disable-line
911			while (parent) {
912				if (selector) {
913					if ($(parent).is(selector)) {
914						parents.push(parent);
915					}
916				} else {
917					parents.push(parent);
918				}
919				parent = parent.parentNode;
920			}
921		}
922		return $(unique(parents));
923	}
924	function closest(selector) {
925		var closest = this; // eslint-disable-line
926		if (typeof selector === 'undefined') {
927			return new Dom7([]);
928		}
929		if (!closest.is(selector)) {
930			closest = closest.parents(selector).eq(0);
931		}
932		return closest;
933	}
934	function find(selector) {
935		var this$1 = this;
936
937		var foundElements = [];
938		for (var i = 0; i < this.length; i += 1) {
939			var found = this$1[i].querySelectorAll(selector);
940			for (var j = 0; j < found.length; j += 1) {
941				foundElements.push(found[j]);
942			}
943		}
944		return new Dom7(foundElements);
945	}
946	function children(selector) {
947		var this$1 = this;
948
949		var children = []; // eslint-disable-line
950		for (var i = 0; i < this.length; i += 1) {
951			var childNodes = this$1[i].childNodes;
952
953			for (var j = 0; j < childNodes.length; j += 1) {
954				if (!selector) {
955					if (childNodes[j].nodeType === 1) {
956						children.push(childNodes[j]);
957					}
958				} else if (
959					childNodes[j].nodeType === 1 &&
960					$(childNodes[j]).is(selector)
961				) {
962					children.push(childNodes[j]);
963				}
964			}
965		}
966		return new Dom7(unique(children));
967	}
968	function remove() {
969		var this$1 = this;
970
971		for (var i = 0; i < this.length; i += 1) {
972			if (this$1[i].parentNode) {
973				this$1[i].parentNode.removeChild(this$1[i]);
974			}
975		}
976		return this;
977	}
978	function add() {
979		var args = [],
980			len = arguments.length;
981		while (len--) args[len] = arguments[len];
982
983		var dom = this;
984		var i;
985		var j;
986		for (i = 0; i < args.length; i += 1) {
987			var toAdd = $(args[i]);
988			for (j = 0; j < toAdd.length; j += 1) {
989				dom[dom.length] = toAdd[j];
990				dom.length += 1;
991			}
992		}
993		return dom;
994	}
995
996	var Methods = {
997		addClass: addClass,
998		removeClass: removeClass,
999		hasClass: hasClass,
1000		toggleClass: toggleClass,
1001		attr: attr,
1002		removeAttr: removeAttr,
1003		data: data,
1004		transform: transform,
1005		transition: transition,
1006		on: on,
1007		off: off,
1008		trigger: trigger,
1009		transitionEnd: transitionEnd,
1010		outerWidth: outerWidth,
1011		outerHeight: outerHeight,
1012		offset: offset,
1013		css: css,
1014		each: each,
1015		html: html,
1016		text: text,
1017		is: is,
1018		index: index,
1019		eq: eq,
1020		append: append,
1021		prepend: prepend,
1022		next: next,
1023		nextAll: nextAll,
1024		prev: prev,
1025		prevAll: prevAll,
1026		parent: parent,
1027		parents: parents,
1028		closest: closest,
1029		find: find,
1030		children: children,
1031		remove: remove,
1032		add: add,
1033		styles: styles,
1034	};
1035
1036	Object.keys(Methods).forEach(function (methodName) {
1037		$.fn[methodName] = Methods[methodName];
1038	});
1039
1040	var Utils = {
1041		deleteProps: function deleteProps(obj) {
1042			var object = obj;
1043			Object.keys(object).forEach(function (key) {
1044				try {
1045					object[key] = null;
1046				} catch (e) {
1047					// no getter for object
1048				}
1049				try {
1050					delete object[key];
1051				} catch (e) {
1052					// something got wrong
1053				}
1054			});
1055		},
1056		nextTick: function nextTick(callback, delay) {
1057			if (delay === void 0) delay = 0;
1058
1059			return setTimeout(callback, delay);
1060		},
1061		now: function now() {
1062			return Date.now();
1063		},
1064		getTranslate: function getTranslate(el, axis) {
1065			if (axis === void 0) axis = 'x';
1066
1067			var matrix;
1068			var curTransform;
1069			var transformMatrix;
1070
1071			var curStyle = win.getComputedStyle(el, null);
1072
1073			if (win.WebKitCSSMatrix) {
1074				curTransform = curStyle.transform || curStyle.webkitTransform;
1075				if (curTransform.split(',').length > 6) {
1076					curTransform = curTransform
1077						.split(', ')
1078						.map(function (a) {
1079							return a.replace(',', '.');
1080						})
1081						.join(', ');
1082				}
1083				// Some old versions of Webkit choke when 'none' is passed; pass
1084				// empty string instead in this case
1085				transformMatrix = new win.WebKitCSSMatrix(
1086					curTransform === 'none' ? '' : curTransform
1087				);
1088			} else {
1089				transformMatrix =
1090					curStyle.MozTransform ||
1091					curStyle.OTransform ||
1092					curStyle.MsTransform ||
1093					curStyle.msTransform ||
1094					curStyle.transform ||
1095					curStyle
1096						.getPropertyValue('transform')
1097						.replace('translate(', 'matrix(1, 0, 0, 1,');
1098				matrix = transformMatrix.toString().split(',');
1099			}
1100
1101			if (axis === 'x') {
1102				// Latest Chrome and webkits Fix
1103				if (win.WebKitCSSMatrix) {
1104					curTransform = transformMatrix.m41;
1105				}
1106				// Crazy IE10 Matrix
1107				else if (matrix.length === 16) {
1108					curTransform = parseFloat(matrix[12]);
1109				}
1110				// Normal Browsers
1111				else {
1112					curTransform = parseFloat(matrix[4]);
1113				}
1114			}

1266			})(),
1267
1268			observer: (function checkObserver() {
1269				return (
1270					'MutationObserver' in win || 'WebkitMutationObserver' in win
1271				);
1272			})(),
1273
1274			passiveListener: (function checkPassiveListener() {
1275				var supportsPassive = false;
1276				try {
1277					var opts = Object.defineProperty({}, 'passive', {
1278						// eslint-disable-next-line
1279						get: function get() {
1280							supportsPassive = true;
1281						},
1282					});
1283					win.addEventListener('testPassiveListener', null, opts);
1284				} catch (e) {
1285					// No support
1286				}
1287				return supportsPassive;
1288			})(),
1289
1290			gestures: (function checkGestures() {
1291				return 'ongesturestart' in win;
1292			})(),
1293		};
1294	})();
1295
1296	var SwiperClass = function SwiperClass(params) {
1297		if (params === void 0) params = {};
1298
1299		var self = this;
1300		self.params = params;
1301
1302		// Events
1303		self.eventsListeners = {};
1304
1305		if (self.params && self.params.on) {
1306			Object.keys(self.params.on).forEach(function (eventName) {
1307				self.on(eventName, self.params.on[eventName]);
1308			});
1309		}
1310	};
1311
1312	var staticAccessors = { components: { configurable: true } };
1313
1314	SwiperClass.prototype.on = function on(events, handler, priority) {
1315		var self = this;
1316		if (typeof handler !== 'function') {
1317			return self;
1318		}
1319		var method = priority ? 'unshift' : 'push';
1320		events.split(' ').forEach(function (event) {
1321			if (!self.eventsListeners[event]) {
1322				self.eventsListeners[event] = [];
1323			}
1324			self.eventsListeners[event][method](handler);
1325		});
1326		return self;
1327	};
1328
1329	SwiperClass.prototype.once = function once(events, handler, priority) {
1330		var self = this;
1331		if (typeof handler !== 'function') {
1332			return self;
1333		}
1334		function onceHandler() {
1335			var args = [],
1336				len = arguments.length;
1337			while (len--) args[len] = arguments[len];
1338
1339			handler.apply(self, args);
1340			self.off(events, onceHandler);
1341		}
1342		return self.on(events, onceHandler, priority);
1343	};
1344
1345	SwiperClass.prototype.off = function off(events, handler) {
1346		var self = this;
1347		if (!self.eventsListeners) {
1348			return self;
1349		}
1350		events.split(' ').forEach(function (event) {
1351			if (typeof handler === 'undefined') {
1352				self.eventsListeners[event] = [];
1353			} else {
1354				self.eventsListeners[event].forEach(function (
1355					eventHandler,
1356					index
1357				) {
1358					if (eventHandler === handler) {
1359						self.eventsListeners[event].splice(index, 1);
1360					}
1361				});
1362			}
1363		});
1364		return self;
1365	};
1366
1367	SwiperClass.prototype.emit = function emit() {
1368		var args = [],
1369			len = arguments.length;
1370		while (len--) args[len] = arguments[len];
1371
1372		var self = this;
1373		if (!self.eventsListeners) {
1374			return self;
1375		}
1376		var events;
1377		var data;
1378		var context;
1379		if (typeof args[0] === 'string' || Array.isArray(args[0])) {
1380			events = args[0];
1381			data = args.slice(1, args.length);
1382			context = self;
1383		} else {
1384			events = args[0].events;
1385			data = args[0].data;
1386			context = args[0].context || self;
1387		}
1388		var eventsArray = Array.isArray(events) ? events : events.split(' ');
1389		eventsArray.forEach(function (event) {
1390			if (self.eventsListeners && self.eventsListeners[event]) {
1391				var handlers = [];
1392				self.eventsListeners[event].forEach(function (eventHandler) {
1393					handlers.push(eventHandler);
1394				});
1395				handlers.forEach(function (eventHandler) {
1396					eventHandler.apply(context, data);
1397				});
1398			}
1399		});
1400		return self;
1401	};
1402
1403	SwiperClass.prototype.useModulesParams = function useModulesParams(
1404		instanceParams
1405	) {
1406		var instance = this;
1407		if (!instance.modules) {
1408			return;
1409		}
1410		Object.keys(instance.modules).forEach(function (moduleName) {
1411			var module = instance.modules[moduleName];
1412			// Extend params
1413			if (module.params) {
1414				Utils.extend(instanceParams, module.params);
1415			}
1416		});
1417	};
1418
1419	SwiperClass.prototype.useModules = function useModules(modulesParams) {
1420		if (modulesParams === void 0) modulesParams = {};
1421
1422		var instance = this;
1423		if (!instance.modules) {
1424			return;
1425		}
1426		Object.keys(instance.modules).forEach(function (moduleName) {
1427			var module = instance.modules[moduleName];
1428			var moduleParams = modulesParams[moduleName] || {};
1429			// Extend instance methods and props
1430			if (module.instance) {
1431				Object.keys(module.instance).forEach(function (modulePropName) {
1432					var moduleProp = module.instance[modulePropName];
1433					if (typeof moduleProp === 'function') {
1434						instance[modulePropName] = moduleProp.bind(instance);
1435					} else {
1436						instance[modulePropName] = moduleProp;
1437					}
1438				});
1439			}
1440			// Add event listeners
1441			if (module.on && instance.on) {
1442				Object.keys(module.on).forEach(function (moduleEventName) {
1443					instance.on(moduleEventName, module.on[moduleEventName]);
1444				});
1445			}
1446
1447			// Module create callback
1448			if (module.create) {
1449				module.create.bind(instance)(moduleParams);
1450			}
1451		});
1452	};
1453
1454	staticAccessors.components.set = function (components) {
1455		var Class = this;
1456		if (!Class.use) {
1457			return;
1458		}
1459		Class.use(components);
1460	};
1461
1462	SwiperClass.installModule = function installModule(module) {
1463		var params = [],
1464			len = arguments.length - 1;
1465		while (len-- > 0) params[len] = arguments[len + 1];
1466
1467		var Class = this;
1468		if (!Class.prototype.modules) {
1469			Class.prototype.modules = {};
1470		}
1471		var name =
1472			module.name ||
1473			Object.keys(Class.prototype.modules).length + '_' + Utils.now();
1474		Class.prototype.modules[name] = module;
1475		// Prototype
1476		if (module.proto) {
1477			Object.keys(module.proto).forEach(function (key) {
1478				Class.prototype[key] = module.proto[key];
1479			});
1480		}
1481		// Class
1482		if (module.static) {
1483			Object.keys(module.static).forEach(function (key) {
1484				Class[key] = module.static[key];
1485			});
1486		}
1487		// Callback
1488		if (module.install) {
1489			module.install.apply(Class, params);
1490		}
1491		return Class;
1492	};
1493
1494	SwiperClass.use = function use(module) {
1495		var params = [],
1496			len = arguments.length - 1;
1497		while (len-- > 0) params[len] = arguments[len + 1];
1498
1499		var Class = this;
1500		if (Array.isArray(module)) {
1501			module.forEach(function (m) {
1502				return Class.installModule(m);
1503			});
1504			return Class;
1505		}
1506		return Class.installModule.apply(Class, [module].concat(params));
1507	};
1508
1509	Object.defineProperties(SwiperClass, staticAccessors);
1510
1511	function updateSize() {
1512		var swiper = this;
1513		var width;
1514		var height;
1515		var $el = swiper.$el;
1516		if (typeof swiper.params.width !== 'undefined') {
1517			width = swiper.params.width;
1518		} else {
1519			width = $el[0].clientWidth;
1520		}
1521		if (typeof swiper.params.height !== 'undefined') {
1522			height = swiper.params.height;
1523		} else {
1524			height = $el[0].clientHeight;
1525		}
1526		if (
1527			(width === 0 && swiper.isHorizontal()) ||
1528			(height === 0 && swiper.isVertical())
1529		) {
1530			return;
1531		}
1532
1533		// Subtract paddings
1534		width =
1535			width -
1536			parseInt($el.css('padding-left'), 10) -
1537			parseInt($el.css('padding-right'), 10);
1538		height =
1539			height -
1540			parseInt($el.css('padding-top'), 10) -
1541			parseInt($el.css('padding-bottom'), 10);
1542
1543		Utils.extend(swiper, {
1544			width: width,
1545			height: height,
1546			size: swiper.isHorizontal() ? width : height,
1547		});
1548	}
1549
1550	function updateSlides() {
1551		var swiper = this;
1552		var params = swiper.params;
1553
1554		var $wrapperEl = swiper.$wrapperEl;
1555		var swiperSize = swiper.size;
1556		var rtl = swiper.rtlTranslate;
1557		var wrongRTL = swiper.wrongRTL;
1558		var isVirtual = swiper.virtual && params.virtual.enabled;
1559		var previousSlidesLength = isVirtual
1560			? swiper.virtual.slides.length
1561			: swiper.slides.length;
1562		var slides = $wrapperEl.children('.' + swiper.params.slideClass);
1563		var slidesLength = isVirtual
1564			? swiper.virtual.slides.length
1565			: slides.length;
1566		var snapGrid = [];
1567		var slidesGrid = [];
1568		var slidesSizesGrid = [];
1569
1570		var offsetBefore = params.slidesOffsetBefore;
1571		if (typeof offsetBefore === 'function') {
1572			offsetBefore = params.slidesOffsetBefore.call(swiper);
1573		}
1574
1575		var offsetAfter = params.slidesOffsetAfter;
1576		if (typeof offsetAfter === 'function') {
1577			offsetAfter = params.slidesOffsetAfter.call(swiper);
1578		}
1579
1580		var previousSnapGridLength = swiper.snapGrid.length;
1581		var previousSlidesGridLength = swiper.snapGrid.length;
1582
1583		var spaceBetween = params.spaceBetween;
1584		var slidePosition = -offsetBefore;
1585		var prevSlideSize = 0;
1586		var index = 0;
1587		if (typeof swiperSize === 'undefined') {
1588			return;
1589		}
1590		if (
1591			typeof spaceBetween === 'string' &&
1592			spaceBetween.indexOf('%') >= 0
1593		) {
1594			spaceBetween =
1595				(parseFloat(spaceBetween.replace('%', '')) / 100) * swiperSize;
1596		}
1597
1598		swiper.virtualSize = -spaceBetween;
1599
1600		// reset margins
1601		if (rtl) {
1602			slides.css({ marginLeft: '', marginTop: '' });
1603		} else {
1604			slides.css({ marginRight: '', marginBottom: '' });
1605		}
1606
1607		var slidesNumberEvenToRows;
1608		if (params.slidesPerColumn > 1) {
1609			if (
1610				Math.floor(slidesLength / params.slidesPerColumn) ===
1611				slidesLength / swiper.params.slidesPerColumn
1612			) {

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