https://bewellfinder.com/wp-content/plugins/woocommerce-tm-extra-p…/assets/js/owl.carousel.js?ver=6.2

1/**
2 * Owl Carousel v2.3.4
3 * Copyright 2013-2018 David Deutsch
4 * Licensed under: SEE LICENSE IN https://github.com/OwlCarousel2/OwlCarousel2/blob/master/LICENSE
5 */
6/**
7 * Owl carousel
8 *
9 * @version 2.3.4
10 * @author Bartosz Wojciechowski
11 * @author David Deutsch
12 * @license The MIT License (MIT)
13 * @todo Lazy Load Icon
14 * @todo prevent animationend bubling
15 * @todo itemsScaleUp
16 * @todo Test Zepto
17 * @todo stagePadding calculate wrong active classes
18 * reformatted code by themeComplete
19 */
20( function( $, window, document ) {
21	'use strict';
22
23	/**
24	 * Creates a carousel.
25	 *
26	 * @class The Owl Carousel.
27	 * @public
28	 * @param {HTMLElement|jQuery} element - The element to create the carousel for.
29	 * @param {Object} [options] - The options
30	 */
31	function Owl( element, options ) {
32		/**
33		 * Current settings for the carousel.
34		 *
35		 * @public
36		 */
37		this.settings = null;
38
39		/**
40		 * Current options set by the caller including defaults.
41		 *
42		 * @public
43		 */
44		this.options = $.extend( {}, Owl.Defaults, options );
45
46		/**
47		 * Plugin element.
48		 *
49		 * @public
50		 */
51		this.$element = $( element );
52
53		/**
54		 * Proxied event handlers.
55		 *
56		 * @protected
57		 */
58		this._handlers = {};
59
60		/**
61		 * References to the running plugins of this carousel.
62		 *
63		 * @protected
64		 */
65		this._plugins = {};
66
67		/**
68		 * Currently suppressed events to prevent them from being retriggered.
69		 *
70		 * @protected
71		 */
72		this._supress = {};
73
74		/**
75		 * Absolute current position.
76		 *
77		 * @protected
78		 */
79		this._current = null;
80
81		/**
82		 * Animation speed in milliseconds.
83		 *
84		 * @protected
85		 */
86		this._speed = null;
87
88		/**
89		 * Coordinates of all items in pixel.
90		 *
91		 * @todo The name of this member is missleading.
92		 * @protected
93		 */
94		this._coordinates = [];
95
96		/**
97		 * Current breakpoint.
98		 *
99		 * @todo Real media queries would be nice.
100		 * @protected
101		 */
102		this._breakpoint = null;
103
104		/**
105		 * Current width of the plugin element.
106		 */
107		this._width = null;
108
109		/**
110		 * All real items.
111		 *
112		 * @protected
113		 */
114		this._items = [];
115
116		/**
117		 * All cloned items.
118		 *
119		 * @protected
120		 */
121		this._clones = [];
122
123		/**
124		 * Merge values of all items.
125		 *
126		 * @todo Maybe this could be part of a plugin.
127		 * @protected
128		 */
129		this._mergers = [];
130
131		/**
132		 * Widths of all items.
133		 */
134		this._widths = [];
135
136		/**
137		 * Invalidated parts within the update process.
138		 *
139		 * @protected
140		 */
141		this._invalidated = {};
142
143		/**
144		 * Ordered list of workers for the update process.
145		 *
146		 * @protected
147		 */
148		this._pipe = [];
149
150		/**
151		 * Current state information for the drag operation.
152		 *
153		 * @todo #261
154		 * @protected
155		 */
156		this._drag = {
157			time: null,
158			target: null,
159			pointer: null,
160			stage: {
161				start: null,
162				current: null
163			},
164			direction: null
165		};
166
167		/**
168		 * Current state information and their tags.
169		 *
170		 * @type {Object}
171		 * @protected
172		 */
173		this._states = {
174			current: {},
175			tags: {
176				initializing: [ 'busy' ],
177				animating: [ 'busy' ],
178				dragging: [ 'interacting' ]
179			}
180		};
181
182		$.each(
183			[ 'onResize', 'onThrottledResize' ],
184			$.proxy( function( i, handler ) {
185				this._handlers[ handler ] = $.proxy( this[ handler ], this );
186			}, this )
187		);
188
189		$.each(
190			Owl.Plugins,
191			$.proxy( function( key, Plugin ) {
192				this._plugins[ key.charAt( 0 ).toLowerCase() + key.slice( 1 ) ] = new Plugin( this );
193			}, this )
194		);
195
196		$.each(
197			Owl.Workers,
198			$.proxy( function( priority, worker ) {
199				this._pipe.push( {
200					filter: worker.filter,
201					run: $.proxy( worker.run, this )
202				} );
203			}, this )
204		);
205
206		this.setup();
207		this.initialize();
208	}
209
210	/**
211	 * Default options for the carousel.
212	 *
213	 * @public
214	 */
215	Owl.Defaults = {
216		items: 3,
217		loop: false,
218		center: false,
219		rewind: false,
220		checkVisibility: true,
221
222		mouseDrag: true,
223		touchDrag: true,
224		pullDrag: true,
225		freeDrag: false,
226
227		margin: 0,
228		stagePadding: 0,
229
230		merge: false,
231		mergeFit: true,
232		autoWidth: false,
233
234		startPosition: 0,
235		rtl: false,
236
237		smartSpeed: 250,
238		fluidSpeed: false,
239		dragEndSpeed: false,
240
241		responsive: {},
242		responsiveRefreshRate: 200,
243		responsiveBaseElement: window,
244
245		fallbackEasing: 'linear',
246		slideTransition: '',
247
248		info: false,
249
250		nestedItemSelector: false,
251		itemElement: 'div',
252		stageElement: 'div',
253
254		refreshClass: 'owl-refresh',
255		loadedClass: 'owl-loaded',
256		loadingClass: 'owl-loading',
257		rtlClass: 'owl-rtl',
258		responsiveClass: 'owl-responsive',
259		dragClass: 'owl-drag',
260		itemClass: 'owl-item',
261		stageClass: 'owl-stage',
262		stageOuterClass: 'owl-stage-outer',
263		grabClass: 'owl-grab'
264	};
265
266	/**
267	 * Enumeration for width.
268	 *
269	 * @public
270	 * @readonly
271	 * @enum {string}
272	 */
273	Owl.Width = {
274		Default: 'default',
275		Inner: 'inner',
276		Outer: 'outer'
277	};
278
279	/**
280	 * Enumeration for types.
281	 *
282	 * @public
283	 * @readonly
284	 * @enum {string}
285	 */
286	Owl.Type = {
287		Event: 'event',
288		State: 'state'
289	};
290
291	/**
292	 * Contains all registered plugins.
293	 *
294	 * @public
295	 */
296	Owl.Plugins = {};
297
298	/**
299	 * List of workers involved in the update process.
300	 */
301	Owl.Workers = [
302		{
303			filter: [ 'width', 'settings' ],
304			run: function() {
305				this._width = this.$element.width();
306			}
307		},
308		{
309			filter: [ 'width', 'items', 'settings' ],
310			run: function( cache ) {
311				cache.current = this._items && this._items[ this.relative( this._current ) ];
312			}
313		},
314		{
315			filter: [ 'items', 'settings' ],
316			run: function() {
317				this.$stage.children( '.cloned' ).remove();
318			}
319		},
320		{
321			filter: [ 'width', 'items', 'settings' ],
322			run: function( cache ) {
323				var margin = this.settings.margin || '',
324					grid = ! this.settings.autoWidth,
325					rtl = this.settings.rtl,
326					css = {
327						width: 'auto',
328						'margin-left': rtl ? margin : '',
329						'margin-right': rtl ? '' : margin
330					};
331
332				if ( ! grid ) {
333					this.$stage.children().css( css );
334				}
335
336				cache.css = css;
337			}
338		},
339		{
340			filter: [ 'width', 'items', 'settings' ],
341			run: function( cache ) {
342				var width = ( this.width() / this.settings.items ).toFixed( 3 ) - this.settings.margin,
343					merge = null,
344					iterator = this._items.length,
345					grid = ! this.settings.autoWidth,
346					widths = [];
347

579			imgs = this.$element.find( 'img' );
580			nestedSelector = this.settings.nestedItemSelector ? '.' + this.settings.nestedItemSelector : undefined;
581			width = this.$element.children( nestedSelector ).width();
582
583			if ( imgs.length && width <= 0 ) {
584				this.preloadAutoWidthImages( imgs );
585			}
586		}
587
588		this.initializeStage();
589		this.initializeItems();
590
591		// register event handlers
592		this.registerEventHandlers();
593
594		this.leave( 'initializing' );
595		this.trigger( 'initialized' );
596	};
597
598	/**
599	 * @returns {boolean} visibility of $element
600	 *                    if you know the carousel will always be visible you can set `checkVisibility` to `false` to
601	 *                    prevent the expensive browser layout forced reflow the $element.is(':visible') does
602	 */
603	Owl.prototype.isVisible = function() {
604		return this.settings.checkVisibility ? this.$element.is( ':visible' ) : true;
605	};
606
607	/**
608	 * Setups the current settings.
609	 *
610	 * @todo Remove responsive classes. Why should adaptive designs be brought into IE8?
611	 * @todo Support for media queries by using `matchMedia` would be nice.
612	 * @public
613	 */
614	Owl.prototype.setup = function() {
615		var viewport = this.viewport(),
616			overwrites = this.options.responsive,
617			match = -1,
618			settings = null;
619
620		if ( ! overwrites ) {
621			settings = $.extend( {}, this.options );
622		} else {
623			$.each( overwrites, function( breakpoint ) {
624				if ( breakpoint <= viewport && breakpoint > match ) {
625					match = Number( breakpoint );
626				}
627			} );
628
629			settings = $.extend( {}, this.options, overwrites[ match ] );
630			if ( typeof settings.stagePadding === 'function' ) {
631				settings.stagePadding = settings.stagePadding();
632			}
633			delete settings.responsive;
634
635			// responsive class
636			if ( settings.responsiveClass ) {
637				this.$element.attr( 'class', this.$element.attr( 'class' ).replace( new RegExp( '(' + this.options.responsiveClass + '-)\\S+\\s', 'g' ), '$1' + match ) );
638			}
639		}
640
641		this.trigger( 'change', { property: { name: 'settings', value: settings } } );
642		this._breakpoint = match;
643		this.settings = settings;
644		this.invalidate( 'settings' );
645		this.trigger( 'changed', { property: { name: 'settings', value: this.settings } } );
646	};
647
648	/**
649	 * Updates option logic if necessery.
650	 *
651	 * @protected
652	 */
653	Owl.prototype.optionsLogic = function() {
654		if ( this.settings.autoWidth ) {
655			this.settings.stagePadding = false;
656			this.settings.merge = false;
657		}
658	};
659
660	/**
661		* Prepares an item before add.
662	 *
663		* @param item
664		* @todo Rename event parameter `content` to `item`.
665		* @protected
666		* @returns {jQuery|HTMLElement} - The item container.
667		*/
668	Owl.prototype.prepare = function( item ) {
669		var event = this.trigger( 'prepare', { content: item } );
670
671		if ( ! event.data ) {
672			event.data = $( '<' + this.settings.itemElement + '/>' )
673				.addClass( this.options.itemClass )
674				.append( item );
675		}
676
677		this.trigger( 'prepared', { content: event.data } );
678
679		return event.data;
680	};
681
682	/**
683	 * Updates the view.
684	 *
685	 * @public
686	 */
687	Owl.prototype.update = function() {
688		var i = 0,
689			n = this._pipe.length,
690			filter = $.proxy( function( p ) {
691				return this[ p ];
692			}, this._invalidated ),
693			cache = {};
694
695		while ( i < n ) {
696			if ( this._invalidated.all || $.grep( this._pipe[ i ].filter, filter ).length > 0 ) {
697				this._pipe[ i ].run( cache );
698			}
699			i += 1;
700		}
701
702		this._invalidated = {};
703
704		if ( ! this.is( 'valid' ) ) {
705			this.enter( 'valid' );
706		}
707	};
708
709	/**
710	 * Gets the width of the view.
711	 *
712	 * @public
713	 * @param {Owl.Width} [dimension=Owl.Width.Default] - The dimension to return.
714	 * @returns {number} - The width of the view in pixel.
715	 */
716	Owl.prototype.width = function( dimension ) {
717		dimension = dimension || Owl.Width.Default;
718		switch ( dimension ) {
719			case Owl.Width.Inner:
720			case Owl.Width.Outer:
721				return this._width;
722			default:
723				return this._width - ( this.settings.stagePadding * 2 ) + this.settings.margin;
724		}
725	};
726
727	/**
728	 * Refreshes the carousel primarily for adaptive purposes.
729	 *
730	 * @public
731	 */
732	Owl.prototype.refresh = function() {
733		this.enter( 'refreshing' );
734		this.trigger( 'refresh' );
735
736		this.setup();
737
738		this.optionsLogic();
739
740		this.$element.addClass( this.options.refreshClass );
741
742		this.update();
743
744		this.$element.removeClass( this.options.refreshClass );
745
746		this.leave( 'refreshing' );
747		this.trigger( 'refreshed' );
748	};
749
750	/**
751	 * Checks window `resize` event.
752	 *
753	 * @protected
754	 */
755	Owl.prototype.onThrottledResize = function() {
756		window.clearTimeout( this.resizeTimer );
757		this.resizeTimer = window.setTimeout( this._handlers.onResize, this.settings.responsiveRefreshRate );
758	};
759
760	/**
761	 * Checks window `resize` event.
762	 *
763	 * @protected
764	 */
765	Owl.prototype.onResize = function() {
766		if ( ! this._items.length ) {
767			return false;

768		}
769
770		if ( this._width === this.$element.width() ) {
771			return false;
772		}
773
774		if ( ! this.isVisible() ) {
775			return false;
776		}
777
778		this.enter( 'resizing' );
779
780		if ( this.trigger( 'resize' ).isDefaultPrevented() ) {
781			this.leave( 'resizing' );
782			return false;
783		}
784
785		this.invalidate( 'width' );
786
787		this.refresh();
788
789		this.leave( 'resizing' );
790		this.trigger( 'resized' );
791	};
792
793	/**
794	 * Registers event handlers.
795	 *
796	 * @todo Check `msPointerEnabled`
797	 * @todo #261
798	 * @protected
799	 */
800	Owl.prototype.registerEventHandlers = function() {
801		if ( $.support.transition ) {
802			this.$stage.on( $.support.transition.end + '.owl.core', $.proxy( this.onTransitionEnd, this ) );
803		}
804
805		if ( this.settings.responsive !== false ) {
806			this.on( window, 'resize', this._handlers.onThrottledResize );
807		}
808
809		if ( this.settings.mouseDrag ) {
810			this.$element.addClass( this.options.dragClass );
811			this.$stage.on( 'mousedown.owl.core', $.proxy( this.onDragStart, this ) );
812			this.$stage.on( 'dragstart.owl.core selectstart.owl.core', function() {
813				return false;
814			} );
815		}
816
817		if ( this.settings.touchDrag ) {
818			this.$stage.on( 'touchstart.owl.core', $.proxy( this.onDragStart, this ) );
819			this.$stage.on( 'touchcancel.owl.core', $.proxy( this.onDragEnd, this ) );
820		}
821	};
822
823	/**
824	 * Handles `touchstart` and `mousedown` events.
825	 *
826	 * @todo Horizontal swipe threshold as option
827	 * @todo #261
828	 * @protected
829	 * @param {Event} event - The event arguments.
830	 */
831	Owl.prototype.onDragStart = function( event ) {
832		var stage = null;
833
834		if ( event.which === 3 ) {
835			return;
836		}
837
838		if ( $.support.transform ) {
839			stage = this.$stage
840				.css( 'transform' )
841				.replace( /.*\(|\)| /g, '' )
842				.split( ',' );
843			stage = {
844				x: stage[ stage.length === 16 ? 12 : 4 ],
845				y: stage[ stage.length === 16 ? 13 : 5 ]
846			};
847		} else {
848			stage = this.$stage.position();
849			stage = {
850				x: this.settings.rtl ? stage.left + this.$stage.width() - this.width() + this.settings.margin : stage.left,
851				y: stage.top
852			};
853		}
854
855		if ( this.is( 'animating' ) ) {
856			if ( $.support.transform ) {
857				this.animate( stage.x );
858			} else {
859				this.$stage.stop();
860			}
861
862			this.invalidate( 'position' );
863		}
864
865		this.$element.toggleClass( this.options.grabClass, event.type === 'mousedown' );
866
867		this.speed( 0 );
868
869		this._drag.time = new Date().getTime();
870		this._drag.target = $( event.target );
871		this._drag.stage.start = stage;
872		this._drag.stage.current = stage;
873		this._drag.pointer = this.pointer( event );
874
875		$( document ).on( 'mouseup.owl.core touchend.owl.core', $.proxy( this.onDragEnd, this ) );
876
877		$( document ).one(
878			'mousemove.owl.core touchmove.owl.core',
879			$.proxy( function( e ) {
880				var delta = this.difference( this._drag.pointer, this.pointer( e ) );
881
882				$( document ).on( 'mousemove.owl.core touchmove.owl.core', $.proxy( this.onDragMove, this ) );
883
884				if ( Math.abs( delta.x ) < Math.abs( delta.y ) && this.is( 'valid' ) ) {
885					return;
886				}
887
888				e.preventDefault();
889
890				this.enter( 'dragging' );
891				this.trigger( 'drag' );
892			}, this )
893		);
894	};
895
896	/**
897	 * Handles the `touchmove` and `mousemove` events.
898	 *
899	 * @todo #261
900	 * @protected
901	 * @param {Event} event - The event arguments.
902	 */
903	Owl.prototype.onDragMove = function( event ) {
904		var minimum = null,
905			maximum = null,
906			pull = null,
907			delta = this.difference( this._drag.pointer, this.pointer( event ) ),
908			stage = this.difference( this._drag.stage.start, delta );
909
910		if ( ! this.is( 'dragging' ) ) {
911			return;
912		}
913
914		event.preventDefault();
915
916		if ( this.settings.loop ) {
917			minimum = this.coordinates( this.minimum() );
918			maximum = this.coordinates( this.maximum() + 1 ) - minimum;
919			stage.x = ( ( ( ( stage.x - minimum ) % maximum ) + maximum ) % maximum ) + minimum;
920		} else {
921			minimum = this.settings.rtl ? this.coordinates( this.maximum() ) : this.coordinates( this.minimum() );
922			maximum = this.settings.rtl ? this.coordinates( this.minimum() ) : this.coordinates( this.maximum() );
923			pull = this.settings.pullDrag ? ( -1 * delta.x ) / 5 : 0;
924			stage.x = Math.max( Math.min( stage.x, minimum + pull ), maximum + pull );
925		}
926
927		this._drag.stage.current = stage;
928
929		this.animate( stage.x );
930	};
931
932	/**
933	 * Handles the `touchend` and `mouseup` events.
934	 *
935	 * @todo #261
936	 * @todo Threshold for click event
937	 * @protected
938	 * @param {Event} event - The event arguments.
939	 */
940	Owl.prototype.onDragEnd = function( event ) {
941		var delta = this.difference( this._drag.pointer, this.pointer( event ) ),
942			stage = this._drag.stage.current,
943			direction,
944			isdeltax = delta.x > 0;
945		if ( ( isdeltax && ! this.settings.rtl ) || ( this.settings.rtl && ! isdeltax ) ) {
946			direction = 'left';
947		} else {
948			direction = 'right';
949		}
950		$( document ).off( '.owl.core' );
951
952		this.$element.removeClass( this.options.grabClass );
953
954		if ( ( delta.x !== 0 && this.is( 'dragging' ) ) || ! this.is( 'valid' ) ) {
955			this.speed( this.settings.dragEndSpeed || this.settings.smartSpeed );
956			this.current( this.closest( stage.x, delta.x !== 0 ? direction : this._drag.direction ) );
957			this.invalidate( 'position' );
958			this.update();
959
960			this._drag.direction = direction;
961
962			if ( Math.abs( delta.x ) > 3 || new Date().getTime() - this._drag.time > 300 ) {
963				this._drag.target.one( 'click.owl.core', function() {
964					return false;
965				} );
966			}
967		}
968
969		if ( ! this.is( 'dragging' ) ) {
970			return;
971		}
972
973		this.leave( 'dragging' );
974		this.trigger( 'dragged' );
975	};
976
977	/**
978	 * Gets absolute position of the closest item for a coordinate.
979	 *
980	 * @todo Setting `freeDrag` makes `closest` not reusable. See #165.
981	 * @protected
982	 * @param {number} coordinate - The coordinate in pixel.
983	 * @param {string} direction - The direction to check for the closest item. Ether `left` or `right`.
984	 * @return {number} - The absolute position of the closest item.
985	 */
986	Owl.prototype.closest = function( coordinate, direction ) {
987		var position = -1,
988			pull = 30,
989			width = this.width(),
990			coordinates = this.coordinates();
991
992		if ( ! this.settings.freeDrag ) {
993			// check closest item
994			$.each(
995				coordinates,
996				$.proxy( function( index, value ) {
997					// on a left pull, check on current index
998					if ( direction === 'left' && coordinate > value - pull && coordinate < value + pull ) {
999						position = index;
1000						// on a right pull, check on previous index
1001						// to do so, subtract width from value and set position = index + 1
1002					} else if ( direction === 'right' && coordinate > value - width - pull && coordinate < value - width + pull ) {
1003						position = index + 1;
1004					} else if ( this.op( coordinate, '<', value ) && this.op( coordinate, '>', coordinates[ index + 1 ] !== undefined ? coordinates[ index + 1 ] : value - width ) ) {
1005						position = direction === 'left' ? index + 1 : index;
1006					}
1007					return position === -1;
1008				}, this )
1009			);
1010		}
1011
1012		if ( ! this.settings.loop ) {
1013			// non loop boundries
1014			if ( this.op( coordinate, '>', coordinates[ this.minimum() ] ) ) {
1015				coordinate = this.minimum();
1016				position = coordinate;
1017			} else if ( this.op( coordinate, '<', coordinates[ this.maximum() ] ) ) {
1018				coordinate = this.maximum();
1019				position = coordinate;
1020			}
1021		}
1022
1023		return position;
1024	};
1025
1026	/**
1027	 * Animates the stage.
1028	 *
1029	 * @todo #270
1030	 * @public
1031	 * @param {number} coordinate - The coordinate in pixels.
1032	 */
1033	Owl.prototype.animate = function( coordinate ) {
1034		var animate = this.speed() > 0;
1035
1036		if ( this.is( 'animating' ) ) {
1037			this.onTransitionEnd();
1038		}
1039
1040		if ( animate ) {
1041			this.enter( 'animating' );
1042			this.trigger( 'translate' );
1043		}
1044
1045		if ( $.support.transform3d && $.support.transition ) {
1046			this.$stage.css( {
1047				transform: 'translate3d(' + coordinate + 'px,0px,0px)',
1048				transition: ( this.speed() / 1000 ) + 's' + ( this.settings.slideTransition ? ' ' + this.settings.slideTransition : '' )
1049			} );
1050		} else if ( animate ) {
1051			this.$stage.animate(
1052				{
1053					left: coordinate + 'px'
1054				},
1055				this.speed(),
1056				this.settings.fallbackEasing,
1057				$.proxy( this.onTransitionEnd, this )
1058			);
1059		} else {
1060			this.$stage.css( {
1061				left: coordinate + 'px'
1062			} );
1063		}
1064	};
1065
1066	/**
1067	 * Checks whether the carousel is in a specific state or not.
1068	 *
1069	 * @param {string} state - The state to check.
1070	 * @returns {boolean} - The flag which indicates if the carousel is busy.
1071	 */
1072	Owl.prototype.is = function( state ) {
1073		return this._states.current[ state ] && this._states.current[ state ] > 0;
1074	};
1075
1076	/**
1077	 * Sets the absolute position of the current item.
1078	 *
1079	 * @public
1080	 * @param {number} [position] - The new absolute position or nothing to leave it unchanged.
1081	 * @returns {number} - The absolute position of the current item.
1082	 */
1083	Owl.prototype.current = function( position ) {
1084		var event;
1085		if ( position === undefined ) {
1086			return this._current;
1087		}
1088
1089		if ( this._items.length === 0 ) {
1090			return undefined;
1091		}
1092
1093		position = this.normalize( position );
1094
1095		if ( this._current !== position ) {
1096			event = this.trigger( 'change', { property: { name: 'position', value: position } } );
1097
1098			if ( event.data !== undefined ) {
1099				position = this.normalize( event.data );
1100			}
1101
1102			this._current = position;
1103
1104			this.invalidate( 'position' );
1105
1106			this.trigger( 'changed', { property: { name: 'position', value: this._current } } );
1107		}
1108
1109		return this._current;
1110	};
1111
1112	/**
1113	 * Invalidates the given part of the update routine.
1114	 *
1115	 * @param {string} [part] - The part to invalidate.
1116	 * @returns {Array.<string>} - The invalidated parts.
1117	 */
1118	Owl.prototype.invalidate = function( part ) {
1119		if ( typeof part === 'string' ) {
1120			this._invalidated[ part ] = true;
1121			if ( this.is( 'valid' ) ) {
1122				this.leave( 'valid' );
1123			}
1124		}
1125		return $.map( this._invalidated, function( v, i ) {
1126			return i;
1127		} );
1128	};
1129
1130	/**
1131	 * Resets the absolute position of the current item.
1132	 *
1133	 * @public
1134	 * @param {number} position - The absolute position of the new item.
1135	 */
1136	Owl.prototype.reset = function( position ) {
1137		position = this.normalize( position );
1138
1139		if ( position === undefined ) {
1140			return;
1141		}
1142
1143		this._speed = 0;
1144		this._current = position;
1145
1146		this.suppress( [ 'translate', 'translated' ] );
1147
1148		this.animate( this.coordinates( position ) );
1149
1150		this.release( [ 'translate', 'translated' ] );
1151	};
1152
1153	/**
1154	 * Normalizes an absolute or a relative position of an item.
1155	 *
1156	 * @public
1157	 * @param {number} position - The absolute or relative position to normalize.
1158	 * @param {boolean} [relative=false] - Whether the given position is relative or not.
1159	 * @returns {number} - The normalized position.
1160	 */
1161	Owl.prototype.normalize = function( position, relative ) {
1162		var n = this._items.length,
1163			m = relative ? 0 : this._clones.length;
1164
1165		if ( ! this.isNumeric( position ) || n < 1 ) {
1166			position = undefined;
1167		} else if ( position < 0 || position >= n + m ) {
1168			position = ( ( ( ( position - ( m / 2 ) ) % n ) + n ) % n ) + ( m / 2 );
1169		}
1170
1171		return position;
1172	};
1173
1174	/**
1175	 * Converts an absolute position of an item into a relative one.
1176	 *
1177	 * @public
1178	 * @param {number} position - The absolute position to convert.
1179	 * @returns {number} - The converted position.
1180	 */
1181	Owl.prototype.relative = function( position ) {
1182		position -= this._clones.length / 2;
1183		return this.normalize( position, true );
1184	};
1185
1186	/**
1187	 * Gets the maximum position for the current item.
1188	 *
1189	 * @public
1190	 * @param {boolean} [relative=false] - Whether to return an absolute position or a relative position.
1191	 * @returns {number}
1192	 */
1193	Owl.prototype.maximum = function( relative ) {
1194		var settings = this.settings,
1195			maximum = this._coordinates.length,
1196			iterator,
1197			reciprocalItemsWidth,
1198			elementWidth;
1199
1200		if ( settings.loop ) {
1201			maximum = ( this._clones.length / 2 ) + this._items.length - 1;
1202		} else if ( settings.autoWidth || settings.merge ) {
1203			iterator = this._items.length;
1204			if ( iterator ) {
1205				iterator = iterator - 1;
1206				reciprocalItemsWidth = this._items[ iterator ].width();
1207				elementWidth = this.$element.width();
1208				while ( iterator > 0 ) {
1209					reciprocalItemsWidth += this._items[ iterator ].width() + this.settings.margin;
1210					if ( reciprocalItemsWidth > elementWidth ) {
1211						break;
1212					}
1213					iterator = iterator - 1;
1214				}
1215			}
1216			maximum = iterator + 1;
1217		} else if ( settings.center ) {
1218			maximum = this._items.length - 1;
1219		} else {
1220			maximum = this._items.length - settings.items;
1221		}
1222
1223		if ( relative ) {
1224			maximum -= this._clones.length / 2;
1225		}
1226
1227		return Math.max( maximum, 0 );
1228	};
1229
1230	/**
1231	 * Gets the minimum position for the current item.
1232	 *
1233	 * @public
1234	 * @param {boolean} [relative=false] - Whether to return an absolute position or a relative position.
1235	 * @returns {number}
1236	 */
1237	Owl.prototype.minimum = function( relative ) {
1238		return relative ? 0 : this._clones.length / 2;
1239	};
1240
1241	/**
1242	 * Gets an item at the specified relative position.
1243	 *
1244	 * @public
1245	 * @param {number} [position] - The relative position of the item.
1246	 * @return {jQuery|Array.<jQuery>} - The item at the given position or all items if no position was given.
1247	 */
1248	Owl.prototype.items = function( position ) {
1249		if ( position === undefined ) {
1250			return this._items.slice();
1251		}
1252
1253		position = this.normalize( position, true );
1254		return this._items[ position ];
1255	};
1256
1257	/**
1258	 * Gets an item at the specified relative position.
1259	 *
1260	 * @public
1261	 * @param {number} [position] - The relative position of the item.
1262	 * @return {jQuery|Array.<jQuery>} - The item at the given position or all items if no position was given.
1263	 */
1264	Owl.prototype.mergers = function( position ) {
1265		if ( position === undefined ) {
1266			return this._mergers.slice();
1267		}
1268
1269		position = this.normalize( position, true );
1270		return this._mergers[ position ];
1271	};
1272
1273	/**
1274	 * Gets the absolute positions of clones for an item.
1275	 *
1276	 * @public
1277	 * @param {number} [position] - The relative position of the item.
1278	 * @returns {Array.<number>} - The absolute positions of clones for the item or all if no position was given.
1279	 */
1280	Owl.prototype.clones = function( position ) {
1281		var odd = this._clones.length / 2,
1282			even = odd + this._items.length,
1283			map = function( index ) {
1284				return index % 2 === 0 ? even + ( index / 2 ) : odd - ( ( index + 1 ) / 2 );
1285			};
1286
1287		if ( position === undefined ) {
1288			return $.map( this._clones, function( v, i ) {
1289				return map( i );
1290			} );
1291		}
1292
1293		return $.map( this._clones, function( v, i ) {
1294			return v === position ? map( i ) : null;
1295		} );
1296	};
1297
1298	/**
1299	 * Sets the current animation speed.
1300	 *
1301	 * @public
1302	 * @param {number}

1449			}
1450		}
1451
1452		this.leave( 'animating' );
1453		this.trigger( 'translated' );
1454	};
1455
1456	/**
1457	 * Gets viewport width.
1458	 *
1459	 * @protected
1460	 * @return {number} - The width in pixel.
1461	 */
1462	Owl.prototype.viewport = function() {
1463		var width;
1464		if ( this.options.responsiveBaseElement !== window ) {
1465			width = $( this.options.responsiveBaseElement ).width();
1466		} else if ( window.innerWidth ) {
1467			width = window.innerWidth;
1468		} else if ( document.documentElement && document.documentElement.clientWidth ) {
1469			width = document.documentElement.clientWidth;
1470		} else {
1471			//Cannot detect viewport width
1472			return width;
1473		}
1474		return width;
1475	};
1476
1477	/**
1478	 * Replaces the current content.
1479	 *
1480	 * @public
1481	 * @param {HTMLElement|jQuery|string} content - The new content.
1482	 */
1483	Owl.prototype.replace = function( content ) {
1484		this.$stage.empty();
1485		this._items = [];
1486
1487		if ( content ) {
1488			content = content instanceof window.jQuery ? content : $( content );
1489		}
1490
1491		if ( this.settings.nestedItemSelector ) {
1492			content = content.find( '.' + this.settings.nestedItemSelector );
1493		}
1494
1495		content
1496			.filter( function() {
1497				return this.nodeType === 1;
1498			} )
1499			.each(
1500				$.proxy( function( index, item ) {
1501					item = this.prepare( item );
1502					this.$stage.append( item );
1503					this._items.push( item );
1504					this._mergers.push( item.find( '[data-merge]' ).addBack( '[data-merge]' ).attr( 'data-merge' ) * 1 || 1 );
1505				}, this )
1506			);
1507
1508		this.reset( this.isNumeric( this.settings.startPosition ) ? this.settings.startPosition : 0 );
1509
1510		this.invalidate( 'items' );
1511	};
1512
1513	/**
1514	 * Adds an item.
1515	 *
1516	 * @todo Use `item` instead of `content` for the event arguments.
1517	 * @public
1518	 * @param {HTMLElement|jQuery|string} content - The item content to add.
1519	 * @param {number} [position] - The relative position at which to insert the item otherwise the item will be added to the end.
1520	 */
1521	Owl.prototype.add = function( content, position ) {
1522		var current = this.relative( this._current );
1523
1524		position = position === undefined ? this._items.length : this.normalize( position, true );
1525		content = content instanceof window.jQuery ? content : $( content );
1526
1527		this.trigger( 'add', { content: content, position: position } );
1528
1529		content = this.prepare( content );
1530
1531		if ( this._items.length === 0 || position === this._items.length ) {
1532			if ( this._items.length === 0 ) {
1533				this.$stage.append( content );
1534			}
1535			if ( this._items.length !== 0 ) {
1536				this._items[ position - 1 ].after( content );
1537			}
1538			this._items.push( content );
1539			this._mergers.push( content.find( '[data-merge]' ).addBack( '[data-merge]' ).attr( 'data-merge' ) * 1 || 1 );
1540		} else {
1541			this._items[ position ].before( content );
1542			this._items.splice( position, 0, content );
1543			this._mergers.splice( position, 0, content.find( '[data-merge]' ).addBack( '[data-merge]' ).attr( 'data-merge' ) * 1 || 1 );
1544		}
1545
1546		if ( this._items[ current ] ) {
1547			this.reset( this._items[ current ].index() );
1548		}
1549
1550		this.invalidate( 'items' );
1551
1552		this.trigger( 'added', { content: content, position: position } );
1553	};
1554
1555	/**
1556	 * Removes an item by its position.
1557	 *
1558	 * @todo Use `item` instead of `content` for the event arguments.
1559	 * @public
1560	 * @param {number} position - The relative position of the item to remove.
1561	 */
1562	Owl.prototype.remove = function( position ) {
1563		position = this.normalize( position, true );
1564
1565		if ( position === undefined ) {
1566			return;
1567		}
1568
1569		this.trigger( 'remove', { content: this._items[ position ], position: position } );
1570
1571		this._items[ position ].remove();
1572		this._items.splice( position, 1 );
1573		this._mergers.splice( position, 1 );
1574
1575		this.invalidate( 'items' );
1576
1577		this.trigger( 'removed', { content: null, position: position } );
1578	};
1579
1580	/**
1581		* Preloads images with auto width.
1582	 *
1583		* @param images
1584		* @todo Replace by a more generic approach
1585		* @protected
1586		*/
1587	Owl.prototype.preloadAutoWidthImages = function( images ) {
1588		images.each(
1589			$.proxy( function( i, element ) {
1590				this.enter( 'pre-loading' );
1591				element = $( element );
1592				$( new Image() )
1593					.one(
1594						'load',
1595						$.proxy( function( e ) {
1596							element.attr( 'src', e.target.src );
1597							element.css( 'opacity', 1 );
1598							this.leave( 'pre-loading' );
1599							if ( ! this.is( 'pre-loading' ) && ! this.is( 'initializing' ) ) {
1600								this.refresh();
1601							}
1602						}, this )
1603					)
1604					.attr( 'src', element.attr( 'src' ) || element.attr( 'data-src' ) || element.attr( 'data-src-retina' ) );
1605			}, this )
1606		);
1607	};
1608
1609	/**
1610	 * Destroys the carousel.
1611	 *
1612	 * @public
1613	 */
1614	Owl.prototype.destroy = function() {
1615		this.$element.off( '.owl.core' );
1616		this.$stage.off( '.owl.core' );
1617		$( document ).off( '.owl.core' );
1618
1619		if ( this.settings.responsive !== false ) {
1620			window.clearTimeout( this.resizeTimer );
1621			this.off( window, 'resize', this._handlers.onThrottledResize );
1622		}
1623
1624		$.map( this._plugins, function( value ) {
1625			return value;
1626		} ).forEach( function( inst ) {
1627			if ( inst ) {
1628				inst.destroy();
1629			}
1630		} );
1631
1632		this.$stage.children( '.cloned' ).remove();
1633
1634		this.$stage.unwrap();
1635		this.$stage.children().contents().unwrap();
1636		this.$stage.children().unwrap();
1637		this.$stage.remove();
1638		this.$element
1639			.removeClass( this.options.refreshClass )
1640			.removeClass( this.options.loadingClass )
1641			.removeClass( this.options.loadedClass )
1642			.removeClass( this.options.rtlClass )
1643			.removeClass( this.options.dragClass )
1644			.removeClass( this.options.grabClass )
1645			.attr( 'class', this.$element.attr( 'class' ).replace( new RegExp( this.options.responsiveClass + '-\\S+\\s', 'g' ), '' ) )
1646			.removeData( 'owl.carousel' );
1647	};
1648
1649	/**
1650	 * Operators to calculate right-to-left and left-to-right.
1651	 *
1652	 * @protected
1653	 * @param {number} [a] - The left side operand.
1654	 * @param {string} [o] - The operator.
1655	 * @param {number} [b] - The right side operand.
1656	 */
1657	Owl.prototype.op = function( a, o, b ) {
1658		var rtl = this.settings.rtl;
1659		switch ( o ) {
1660			case '<':
1661				return rtl ? a > b : a < b;
1662			case '>':
1663				return rtl ? a < b : a > b;
1664			case '>=':
1665				return rtl ? a <= b : a >= b;
1666			case '<=':
1667				return rtl ? a >= b : a <= b;
1668			default:
1669				break;
1670		}
1671	};
1672
1673	/**
1674	 * Attaches to an internal event.
1675	 *
1676	 * @protected
1677	 * @param {HTMLElement} element - The event source.
1678	 * @param {string} event - The event name.
1679	 * @param {Function} listener - The event handler to attach.
1680	 * @param {boolean} capture - Wether the event should be handled at the capturing phase or not.
1681	 */
1682	Owl.prototype.on = function( element, event, listener, capture ) {
1683		if ( element.addEventListener ) {
1684			element.addEventListener( event, listener, capture );
1685		} else if ( element.attachEvent ) {
1686			element.attachEvent( 'on' + event, listener );
1687		}
1688	};
1689
1690	/**
1691	 * Detaches from an internal event.
1692	 *
1693	 * @protected
1694	 * @param {HTMLElement} element - The event source.
1695	 * @param {string} event - The event name.
1696	 * @param {Function} listener - The attached event handler to detach.
1697	 * @param {boolean} capture - Wether the attached event handler was registered as a capturing listener or not.
1698	 */
1699	Owl.prototype.off = function( element, event, listener, capture ) {
1700		if ( element.removeEventListener ) {
1701			element.removeEventListener( event, listener, capture );
1702		} else if ( element.detachEvent ) {
1703			element.detachEvent( 'on' + event, listener );
1704		}
1705	};
1706
1707	/**
1708	 * Triggers a public event.
1709	 *
1710	 * @todo Remove `status`, `relatedTarget` should be used instead.
1711	 * @protected
1712	 * @param {string} name - The event name.
1713	 * @param {*} [data=null] - The event data.
1714	 * @param {string} [namespace=carousel] - The event namespace.
1715	 * @returns {Event} - The event arguments.
1716	 */
1717	Owl.prototype.trigger = function( name, data, namespace ) {
1718		var status = {
1719				item: { count: this._items.length, index: this.current() }
1720			},
1721			handler = $.camelCase(
1722				$.grep( [ 'on', name, namespace ], function( v ) {
1723					return v;
1724				} )
1725					.join( '-' )
1726					.toLowerCase()
1727			),
1728			/*eslint new-cap: [2, {capIsNewExceptions: ["Event"]}]*/
1729			event = $.Event( [ name, 'owl', namespace || 'carousel' ].join( '.' ).toLowerCase(), $.extend( { relatedTarget: this }, status, data ) );
1730
1731		if ( ! this._supress[ name ] ) {
1732			$.each( this._plugins, function( sname, plugin ) {
1733				if ( plugin.onTrigger ) {
1734					plugin.onTrigger( event );
1735				}
1736			} );
1737
1738			this.register( { type: Owl.Type.Event, name: name } );
1739			this.$element.trigger( event );
1740
1741			if ( this.settings && typeof this.settings[ handler ] === 'function' ) {
1742				this.settings[ handler ].call( this, event );
1743			}
1744		}
1745
1746		return event;
1747	};
1748
1749	/**
1750	 * Enters a state.
1751	 *
1752	 * @param name - The state name.
1753	 */
1754	Owl.prototype.enter = function( name ) {
1755		$.each(
1756			[ name ].concat( this._states.tags[ name ] || [] ),
1757			$.proxy( function( i, sname ) {
1758				if ( this._states.current[ sname ] === undefined ) {
1759					this._states.current[ sname ] = 0;
1760				}
1761
1762				this._states.current[ sname ] += 1;
1763			}, this )
1764		);
1765	};
1766
1767	/**
1768	 * Leaves a state.
1769	 *
1770	 * @param name - The state name.
1771	 */
1772	Owl.prototype.leave = function( name ) {
1773		$.each(
1774			[ name ].concat( this._states.tags[ name ] || [] ),
1775			$.proxy( function( i, sname ) {
1776				this._states.current[ sname ] -= 1;
1777			}, this )
1778		);
1779	};
1780
1781	/**
1782	 * Registers an event or state.
1783	 *
1784	 * @public
1785	 * @param {Object} object - The event or state to register.
1786	 */
1787	Owl.prototype.register = function( object ) {
1788		var _default;
1789		if ( object.type === Owl.Type.Event ) {
1790			if ( ! $.event.special[ object.name ] ) {
1791				$.event.special[ object.name ] = {};
1792			}
1793
1794			if ( ! $.event.special[ object.name ].owl ) {
1795				_default = $.event.special[ object.name ]._default;
1796				$.event.special[ object.name ]._default = function( e ) {
1797					if ( _default && _default.apply && ( ! e.namespace || e.namespace.indexOf( 'owl' ) === -1 ) ) {
1798						return _default.apply( this, arguments );
1799					}
1800					return e.namespace && e.namespace.indexOf( 'owl' ) > -1;
1801				};
1802				$.event.special[ object.name ].owl = true;
1803			}
1804		} else if ( object.type === Owl.Type.State ) {
1805			if ( ! this._states.tags[ object.name ] ) {
1806				this._states.tags[ object.name ] = object.tags;
1807			} else {
1808				this._states.tags[ object.name ] = this._states.tags[ object.name ].concat( object.tags );
1809			}
1810
1811			this._states.tags[ object.name ] = $.grep(
1812				this._states.tags[ object.name ],
1813				$.proxy( function( tag, i ) {
1814					return $.inArray( tag, this._states.tags[ object.name ] ) === i;
1815				}, this )
1816			);
1817		}
1818	};
1819
1820	/**
1821	 * Suppresses events.
1822	 *
1823	 * @protected
1824	 * @param {Array.<string>} events - The events to suppress.
1825	 */
1826	Owl.prototype.suppress = function( events ) {
1827		$.each(
1828			events,
1829			$.proxy( function( index, event ) {
1830				this._supress[ event ] = true;
1831			}, this )
1832		);
1833	};
1834
1835	/**
1836	 * Releases suppressed events.
1837	 *
1838	 * @protected
1839	 * @param {Array.<string>} events - The events to release.
1840	 */
1841	Owl.prototype.release = function( events ) {
1842		$.each(
1843			events,
1844			$.proxy( function( index, event ) {
1845				delete this._supress[ event ];
1846			}, this )
1847		);
1848	};
1849
1850	/**
1851		* Gets unified pointer coordinates from event.
1852		*
1853		* @todo #261
1854		* @param event
1855		* @protected
1856		* @param {Event} - The `mousedown` or `touchstart` event.
1857		* @returns {Object} - Contains `x` and `y` coordinates of current pointer position.
1858		*/
1859	Owl.prototype.pointer = function( event ) {
1860		var result = { x: null, y: null };
1861
1862		event = event.originalEvent || event || window.event;
1863
1864		event = event.touches && event.touches.length ? event.touches[ 0 ] : event.changedTouches && event.changedTouches.length ? event.changedTouches[ 0 ] : event;
1865
1866		if ( event.pageX ) {
1867			result.x = event.pageX;
1868			result.y = event.pageY;
1869		} else {
1870			result.x = event.clientX;
1871			result.y = event.clientY;
1872		}
1873
1874		return result;
1875	};
1876
1877	/**
1878		* Determines if the input is a Number or something that can be coerced to a Number
1879	 *
1880		* @protected
1881		* @param number
1882		* @param {number|string|Object|Array|boolean|RegExp|Function|symbol} - The input to be tested
1883		* @returns {boolean} - An indication if the input is a Number or can be coerced to a Number
1884		*/
1885	Owl.prototype.isNumeric = function( number ) {
1886		return ! isNaN( parseFloat( number ) );
1887	};
1888
1889	/**
1890		* Gets the difference of two vectors.
1891	 *
1892		* @todo #261
1893		* @protected
1894		* @param first
1895		* @param second
1896		* @param {Object} - The first vector.
1897		* @param {Object} - The second vector.
1898		* @returns {Object} - The difference.
1899		*/
1900	Owl.prototype.difference = function( first, second ) {
1901		return {
1902			x: first.x - second.x,
1903			y: first.y - second.y
1904		};
1905	};
1906
1907	/**
1908		* The jQuery Plugin for the Owl Carousel

2260	$.fn.tmowlCarousel.Constructor.Plugins.Lazy = Lazy;
2261}( window.Zepto || window.jQuery, window ) );
2262
2263/**
2264 * AutoHeight Plugin
2265 *
2266 * @version 2.3.4
2267 * @author Bartosz Wojciechowski
2268 * @author David Deutsch
2269 * @license The MIT License (MIT)
2270 */
2271( function( $, window ) {
2272	'use strict';
2273	/**
2274	 * Creates the auto height plugin.
2275	 *
2276	 * @class The Auto Height Plugin
2277	 * @param {Owl} carousel - The Owl Carousel
2278	 */
2279	var AutoHeight = function( carousel ) {
2280		var refThis = this;
2281		/**
2282		 * Reference to the core.
2283		 *
2284		 * @protected
2285		 * @type {Owl}
2286		 */
2287		this._core = carousel;
2288
2289		this._previousHeight = null;
2290
2291		/**
2292		 * All event handlers.
2293		 *
2294		 * @protected
2295		 * @type {Object}
2296		 */
2297		this._handlers = {
2298			'initialized.owl.carousel refreshed.owl.carousel': $.proxy( function( e ) {
2299				if ( e.namespace && this._core.settings.autoHeight ) {
2300					this.update();
2301				}
2302			}, this ),
2303			'changed.owl.carousel': $.proxy( function( e ) {
2304				if ( e.namespace && this._core.settings.autoHeight && e.property.name === 'position' ) {
2305					this.update();
2306				}
2307			}, this ),
2308			'loaded.owl.lazy': $.proxy( function( e ) {
2309				if ( e.namespace && this._core.settings.autoHeight && e.element.closest( '.' + this._core.settings.itemClass ).index() === this._core.current() ) {
2310					this.update();
2311				}
2312			}, this )
2313		};
2314
2315		// set default options
2316		this._core.options = $.extend( {}, AutoHeight.Defaults, this._core.options );
2317
2318		// register event handlers
2319		this._core.$element.on( this._handlers );
2320		this._intervalId = null;
2321
2322		// These changes have been taken from a PR by gavrochelegnou proposed in #1575
2323		// and have been made compatible with the latest jQuery version
2324		$( window ).on( 'load', function() {
2325			if ( refThis._core.settings.autoHeight ) {
2326				refThis.update();
2327			}
2328		} );
2329
2330		// Autoresize the height of the carousel when window is resized
2331		// When carousel has images, the height is dependent on the width
2332		// and should also change on resize
2333		$( window ).on( 'resize', function() {
2334			if ( refThis._core.settings.autoHeight ) {
2335				if ( refThis._intervalId !== null ) {
2336					clearTimeout( refThis._intervalId );
2337				}
2338
2339				refThis._intervalId = setTimeout( function() {
2340					refThis.update();
2341				}, 250 );
2342			}
2343		} );
2344	};
2345
2346	/**
2347	 * Default options.
2348	 *
2349	 * @public
2350	 */
2351	AutoHeight.Defaults = {
2352		autoHeight: false,
2353		autoHeightClass: 'owl-height'
2354	};
2355
2356	/**
2357	 * Updates the view.
2358	 */
2359	AutoHeight.prototype.update = function() {
2360		var start = this._core._current,
2361			end = start + this._core.settings.items,
2362			lazyLoadEnabled = this._core.settings.lazyLoad,
2363			visible = this._core.$stage.children().toArray().slice( start, end ),
2364			heights = [],
2365			maxheight = 0;
2366
2367		$.each( visible, function( index, item ) {
2368			heights.push( $( item ).height() );
2369		} );
2370
2371		maxheight = Math.max.apply( null, heights );
2372
2373		if ( maxheight <= 1 && lazyLoadEnabled && this._previousHeight ) {
2374			maxheight = this._previousHeight;
2375		}
2376
2377		this._previousHeight = maxheight;
2378
2379		this._core.$stage.parent().height( maxheight ).addClass( this._core.settings.autoHeightClass );
2380	};
2381
2382	AutoHeight.prototype.destroy = function() {
2383		var handler, property;
2384
2385		for ( handler in this._handlers ) {
2386			if ( handler ) {
2387				this._core.$element.off( handler, this._handlers[ handler ] );
2388			}
2389		}
2390		for ( property in Object.getOwnPropertyNames( this ) ) {
2391			if ( typeof this[ property ] !== 'function' ) {
2392				this[ property ] = null;
2393			}
2394		}
2395	};
2396
2397	$.fn.tmowlCarousel.Constructor.Plugins.AutoHeight = AutoHeight;
2398}( window.Zepto || window.jQuery ) );
2399
2400/**
2401 * Video Plugin
2402 *
2403 * @version 2.3.4
2404 * @author Bartosz Wojciechowski
2405 * @author David Deutsch
2406 * @license The MIT License (MIT)
2407 */
2408( function( $, window, document ) {
2409	'use strict';
2410	/**
2411	 * Creates the video plugin.
2412	 *
2413	 * @class The Video Plugin
2414	 * @param {Owl} carousel - The Owl Carousel
2415	 */
2416	var Video = function( carousel ) {
2417		/**
2418		 * Reference to the core.
2419		 *
2420		 * @protected
2421		 * @type {Owl}
2422		 */
2423		this._core = carousel;
2424
2425		/**
2426		 * Cache all video URLs.
2427		 *
2428		 * @protected
2429		 * @type {Object}
2430		 */
2431		this._videos = {};
2432
2433		/**
2434		 * Current playing item.
2435		 *
2436		 * @protected
2437		 * @type {jQuery}
2438		 */
2439		this._playing = null;
2440
2441		/**
2442		 * All event handlers.
2443		 *
2444		 * @todo The cloned content removale is too late
2445		 * @protected
2446		 * @type {Object}
2447		 */
2448		this._handlers = {
2449			'initialized.owl.carousel': $.proxy( function( e ) {
2450				if ( e.namespace ) {
2451					this._core.register( { type: 'state', name: 'playing', tags: [ 'interacting' ] } );
2452				}
2453			}, this ),
2454			'resize.owl.carousel': $.proxy( function( e ) {
2455				if ( e.namespace && this._core.settings.video && this.isInFullScreen() ) {
2456					e.preventDefault();
2457				}
2458			}, this ),
2459			'refreshed.owl.carousel': $.proxy( function( e ) {
2460				if ( e.namespace && this._core.is( 'resizing' ) ) {
2461					this._core.$stage.find( '.cloned .owl-video-frame' ).remove();
2462				}
2463			}, this ),
2464			'changed.owl.carousel': $.proxy( function( e ) {
2465				if ( e.namespace && e.property.name === 'position' && this._playing ) {
2466					this.stop();
2467				}
2468			}, this ),
2469			'prepared.owl.carousel': $.proxy( function( e ) {
2470				var $element;
2471				if ( ! e.namespace ) {
2472					return;
2473				}
2474
2475				$element = $( e.content ).find( '.owl-video' );
2476
2477				if ( $element.length ) {
2478					$element.css( 'display', 'none' );
2479					this.fetch( $element, $( e.content ) );
2480				}
2481			}, this )
2482		};
2483
2484		// set default options
2485		this._core.options = $.extend( {}, Video.Defaults, this._core.options );
2486
2487		// register event handlers
2488		this._core.$element.on( this._handlers );
2489
2490		this._core.$element.on(
2491			'click.owl.video',
2492			'.owl-video-play-icon',
2493			$.proxy( function( e ) {
2494				this.play( e );
2495			}, this )
2496		);
2497	};
2498
2499	/**
2500	 * Default options.
2501	 *
2502	 * @public
2503	 */
2504	Video.Defaults = {
2505		video: false,
2506		videoHeight: false,
2507		videoWidth: false
2508	};
2509
2510	/**
2511	 * Gets the video ID and the type (YouTube/Vimeo/vzaar only).
2512	 *
2513	 * @protected
2514	 * @param {jQuery} target - The target containing the video data.
2515	 * @param {jQuery} item - The item containing the video.
2516	 */
2517	Video.prototype.fetch = function( target, item ) {
2518		var type = ( function() {
2519				if ( target.attr( 'data-vimeo-id' ) ) {
2520					return 'vimeo';
2521				} else if ( target.attr( 'data-vzaar-id' ) ) {
2522					return 'vzaar';
2523				}
2524				return 'youtube';
2525			}() ),
2526			id = target.attr( 'data-vimeo-id' ) || target.attr( 'data-youtube-id' ) || target.attr( 'data-vzaar-id' ),
2527			width = target.attr( 'data-width' ) || this._core.settings.videoWidth,
2528			height = target.attr( 'data-height' ) || this._core.settings.videoHeight,
2529			url = target.attr( 'href' );
2530
2531		if ( url ) {
2532			/*
2533             Parses the id's out of the following urls (and probably more):
2534             https://www.youtube.com/watch?v=:id
2535             https://youtu.be/:id
2536             https://vimeo.com/:id
2537             https://vimeo.com/channels/:channel/:id
2538             https://vimeo.com/groups/:group/videos/:id
2539             https://app.vzaar.com/videos/:id
2540
2541             Visual example: https://regexper.com/#(http%3A%7Chttps%3A%7C)%5C%2F%5C%2F(player.%7Cwww.%7Capp.)%3F(vimeo%5C.com%7Cyoutu(be%5C.com%7C%5C.be%7Cbe%5C.googleapis%5C.com)%7Cvzaar%5C.com)%5C%2F(video%5C%2F%7Cvideos%5C%2F%7Cembed%5C%2F%7Cchannels%5C%2F.%2B%5C%2F%7Cgroups%5C%2F.%2B%5C%2F%7Cwatch%5C%3Fv%3D%7Cv%5C%2F)%3F(%5BA-Za-z0-9._%25-%5D*)(%5C%26%5CS%2B)%3F
2542             */
2543
2544			id = url.match(
2545				// eslint-disable-next-line no-useless-escape
2546				/(http:|https:|)\/\/(player.|www.|app.)?(vimeo\.com|youtu(be\.com|\.be|be\.googleapis\.com|be\-nocookie\.com)|vzaar\.com)\/(video\/|videos\/|embed\/|channels\/.+\/|groups\/.+\/|watch\?v=|v\/)?([A-Za-z0-9._%-]*)(\&\S+)?/
2547			);
2548
2549			if ( id[ 3 ].indexOf( 'youtu' ) > -1 ) {
2550				type = 'youtube';
2551			} else if ( id[ 3 ].indexOf( 'vimeo' ) > -1 ) {
2552				type = 'vimeo';
2553			} else if ( id[ 3 ].indexOf( 'vzaar' ) > -1 ) {
2554				type = 'vzaar';
2555			} else {
2556				throw new Error( 'Video URL not supported.' );
2557			}
2558			id = id[ 6 ];
2559		} else {
2560			throw new Error( 'Missing video URL.' );
2561		}
2562
2563		this._videos[ url ] = {
2564			type: type,
2565			id: id,
2566			width: width,
2567			height: height
2568		};
2569
2570		item.attr( 'data-video', url );
2571
2572		this.thumbnail( target, this._videos[ url ] );
2573	};
2574
2575	/**
2576		* Creates video thumbnail.
2577	 *
2578		* @protected
2579		* @param {jQuery} target - The target containing the video data.
2580		* @param video
2581		* @param {Object} info - The video info object.
2582		* @see `fetch`
2583		*/
2584	Video.prototype.thumbnail = function( target, video ) {
2585		var tnLink,
2586			icon,
2587			path,
2588			dimensions = video.width && video.height ? 'width:' + video.width + 'px;height:' + video.height + 'px;' : '',
2589			customTn = target.find( 'img' ),
2590			srcType = 'src',
2591			lazyClass = '',
2592			settings = this._core.settings,
2593			create = function( thispath ) {
2594				icon = '<div class="owl-video-play-icon"></div>';
2595
2596				if ( settings.lazyLoad ) {
2597					tnLink = $( '<div/>', {
2598						class: 'owl-video-tn ' + lazyClass,
2599						srcType: thispath
2600					} );
2601				} else {
2602					tnLink = $( '<div/>', {
2603						class: 'owl-video-tn',
2604						style: 'opacity:1;background-image:url(' + thispath + ')'
2605					} );
2606				}
2607				target.after( tnLink );
2608				target.after( icon );
2609			};
2610
2611		// wrap video content into owl-video-wrapper div
2612		target.wrap(
2613			$( '<div/>', {
2614				class: 'owl-video-wrapper',
2615				style: dimensions
2616			} )
2617		);
2618
2619		if ( this._core.settings.lazyLoad ) {
2620			srcType = 'data-src';
2621			lazyClass = 'owl-lazy';
2622		}
2623
2624		// custom thumbnail
2625		if ( customTn.length ) {
2626			create( customTn.attr( srcType ) );
2627			customTn.remove();
2628			return false;
2629		}
2630
2631		if ( video.type === 'youtube' ) {
2632			path = '//img.youtube.com/vi/' + video.id + '/hqdefault.jpg';
2633			create( path );
2634		} else if ( video.type === 'vimeo' ) {
2635			$.ajax( {
2636				type: 'GET',
2637				url: '//vimeo.com/api/v2/video/' + video.id + '.json',
2638				jsonp: 'callback',
2639				dataType: 'jsonp',
2640				success: function( data ) {
2641					path = data[ 0 ].thumbnail_large;
2642					create( path );
2643				}
2644			} );
2645		} else if ( video.type === 'vzaar' ) {
2646			$.ajax( {
2647				type: 'GET',
2648				url: '//vzaar.com/api/videos/' + video.id + '.json',
2649				jsonp: 'callback',
2650				dataType: 'jsonp',
2651				success: function( data ) {
2652					path = data.framegrab_url;
2653					create( path );
2654				}
2655			} );
2656		}
2657	};
2658
2659	/**
2660	 * Stops the current video.
2661	 *
2662	 * @public
2663	 */
2664	Video.prototype.stop = function() {
2665		this._core.trigger( 'stop', null, 'video' );
2666		this._playing.find( '.owl-video-frame' ).remove();
2667		this._playing.removeClass( 'owl-video-playing' );
2668		this._playing = null;
2669		this._core.leave( 'playing' );
2670		this._core.trigger( 'stopped', null, 'video' );
2671	};
2672
2673	/**
2674	 * Starts the current video.
2675	 *
2676	 * @public
2677	 * @param {Event} event - The event arguments.
2678	 */
2679	Video.prototype.play = function( event ) {
2680		var target = $( event.target ),
2681			item = target.closest( '.' + this._core.settings.itemClass ),
2682			video = this._videos[ item.attr( 'data-video' ) ],
2683			width = video.width || '100%',
2684			height = video.height || this._core.$stage.height(),
2685			html;
2686
2687		if ( this._playing ) {
2688			return;
2689		}
2690
2691		this._core.enter( 'playing' );
2692		this._core.trigger( 'play', null, 'video' );
2693
2694		item = this._core.items( this._core.relative( item.index() ) );
2695
2696		this._core.reset( item.index() );
2697
2698		html = $( '<iframe frameborder="0" allowfullscreen mozallowfullscreen webkitAllowFullScreen ></iframe>' );
2699		html.attr( 'height', height );
2700		html.attr( 'width', width );
2701		if ( video.type === 'youtube' ) {
2702			html.attr( 'src', '//www.youtube.com/embed/' + video.id + '?autoplay=1&rel=0&v=' + video.id );
2703		} else if ( video.type === 'vimeo' ) {
2704			html.attr( 'src', '//player.vimeo.com/video/' + video.id + '?autoplay=1' );
2705		} else if ( video.type === 'vzaar' ) {
2706			html.attr( 'src', '//view.vzaar.com/' + video.id + '/player?autoplay=true' );
2707		}
2708
2709		$( html ).wrap( '<div class="owl-video-frame" />' ).insertAfter( item.find( '.owl-video' ) );
2710
2711		this._playing = item.addClass( 'owl-video-playing' );
2712	};
2713
2714	/**
2715	 * Checks whether an video is currently in full screen mode or not.
2716	 *
2717	 * @todo Bad style because looks like a readonly method but changes members.
2718	 * @protected
2719	 * @returns {boolean}
2720	 */
2721	Video.prototype.isInFullScreen = function() {
2722		var element = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement;
2723
2724		return element && $( element ).parent().hasClass( 'owl-video-frame' );
2725	};
2726
2727	/**
2728	 * Destroys the plugin.
2729	 */
2730	Video.prototype.destroy = function() {
2731		var handler, property;
2732
2733		this._core.$element.off( 'click.owl.video' );
2734
2735		for ( handler in this._handlers ) {
2736			if ( handler ) {
2737				this._core.$element.off( handler, this._handlers[ handler ] );
2738			}
2739		}
2740		for ( property in Object.getOwnPropertyNames( this ) ) {
2741			if ( typeof this[ property ] !== 'function' ) {
2742				this[ property ] = null;
2743			}
2744		}
2745	};
2746
2747	$.fn.tmowlCarousel.Constructor.Plugins.Video = Video;
2748}( window.Zepto || window.jQuery, window, document ) );
2749
2750/**
2751 * Animate Plugin
2752 *
2753 * @version 2.3.4
2754 * @author Bartosz Wojciechowski
2755 * @author David Deutsch
2756 * @license The MIT License (MIT)
2757 */
2758( function( $ ) {
2759	'use strict';
2760	/**
2761	 * Creates the animate plugin.
2762	 *
2763	 * @class The Navigation Plugin
2764	 * @param {Owl} scope - The Owl Carousel