https://www.backsplash.com/wp-content/plugins/woocommerce-tm-extra…/assets/js/owl.carousel.js?ver=7.6

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

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

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

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

2435		 *
2436		 * @protected
2437		 * @type {Object}
2438		 */
2439		this._videos = {};
2440
2441		/**
2442		 * Current playing item.
2443		 *
2444		 * @protected
2445		 * @type {jQuery}
2446		 */
2447		this._playing = null;
2448
2449		/**
2450		 * All event handlers.
2451		 *
2452		 * @todo The cloned content removale is too late
2453		 * @protected
2454		 * @type {Object}
2455		 */
2456		this._handlers = {
2457			'initialized.owl.carousel': $.proxy( function( e ) {
2458				if ( e.namespace ) {
2459					this._core.register( { type: 'state', name: 'playing', tags: [ 'interacting' ] } );
2460				}
2461			}, this ),
2462			'resize.owl.carousel': $.proxy( function( e ) {
2463				if ( e.namespace && this._core.settings.video && this.isInFullScreen() ) {
2464					e.preventDefault();
2465				}
2466			}, this ),
2467			'refreshed.owl.carousel': $.proxy( function( e ) {
2468				if ( e.namespace && this._core.is( 'resizing' ) ) {
2469					this._core.$stage.find( '.cloned .owl-video-frame' ).remove();
2470				}
2471			}, this ),
2472			'changed.owl.carousel': $.proxy( function( e ) {
2473				if ( e.namespace && e.property.name === 'position' && this._playing ) {
2474					this.stop();
2475				}
2476			}, this ),
2477			'prepared.owl.carousel': $.proxy( function( e ) {
2478				var $element;
2479				if ( ! e.namespace ) {
2480					return;
2481				}
2482
2483				$element = $( e.content ).find( '.owl-video' );
2484
2485				if ( $element.length ) {
2486					$element.css( 'display', 'none' );
2487					this.fetch( $element, $( e.content ) );
2488				}
2489			}, this )
2490		};
2491
2492		// set default options
2493		this._core.options = $.extend( {}, Video.Defaults, this._core.options );
2494
2495		// register event handlers
2496		this._core.$element.on( this._handlers );
2497
2498		this._core.$element.on(
2499			'click.owl.video',
2500			'.owl-video-play-icon',
2501			$.proxy( function( e ) {
2502				this.play( e );
2503			}, this )
2504		);
2505	};
2506
2507	/**
2508	 * Default options.
2509	 *
2510	 * @public
2511	 */
2512	Video.Defaults = {
2513		video: false,
2514		videoHeight: false,
2515		videoWidth: false
2516	};
2517
2518	/**
2519	 * Gets the video ID and the type (YouTube/Vimeo/vzaar only).
2520	 *
2521	 * @protected
2522	 * @param {jQuery} target - The target containing the video data.
2523	 * @param {jQuery} item   - The item containing the video.
2524	 */
2525	Video.prototype.fetch = function( target, item ) {
2526		var type = ( function() {
2527				if ( target.attr( 'data-vimeo-id' ) ) {
2528					return 'vimeo';
2529				} else if ( target.attr( 'data-vzaar-id' ) ) {
2530					return 'vzaar';
2531				}
2532				return 'youtube';
2533			}() ),
2534			id = target.attr( 'data-vimeo-id' ) || target.attr( 'data-youtube-id' ) || target.attr( 'data-vzaar-id' ),
2535			width = target.attr( 'data-width' ) || this._core.settings.videoWidth,
2536			height = target.attr( 'data-height' ) || this._core.settings.videoHeight,
2537			url = target.attr( 'href' );
2538
2539		if ( url ) {
2540			/*
2541             Parses the id's out of the following urls (and probably more):
2542             https://www.youtube.com/watch?v=:id
2543             https://youtu.be/:id
2544             https://vimeo.com/:id
2545             https://vimeo.com/channels/:channel/:id
2546             https://vimeo.com/groups/:group/videos/:id
2547             https://app.vzaar.com/videos/:id
2548
2549             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
2550             */
2551
2552			id = url.match(
2553				// eslint-disable-next-line no-useless-escape
2554				/(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+)?/
2555			);
2556
2557			if ( id[ 3 ].indexOf( 'youtu' ) > -1 ) {
2558				type = 'youtube';
2559			} else if ( id[ 3 ].indexOf( 'vimeo' ) > -1 ) {
2560				type = 'vimeo';
2561			} else if ( id[ 3 ].indexOf( 'vzaar' ) > -1 ) {
2562				type = 'vzaar';
2563			} else {
2564				throw new Error( 'Video URL not supported.' );
2565			}
2566			id = id[ 6 ];
2567		} else {
2568			throw new Error( 'Missing video URL.' );
2569		}
2570
2571		this._videos[ url ] = {
2572			type: type,
2573			id: id,
2574			width: width,
2575			height: height
2576		};
2577
2578		item.attr( 'data-video', url );
2579
2580		this.thumbnail( target, this._videos[ url ] );
2581	};
2582
2583	/**
2584	 * Creates video thumbnail.
2585	 *
2586	 * @protected
2587	 * @param {jQuery} target The target containing the video data.
2588	 * @param {Object} video  The video info object.
2589	 * @see `fetch`
2590	 */
2591	Video.prototype.thumbnail = function( target, video ) {
2592		var tnLink,
2593			icon,
2594			path,
2595			dimensions = video.width && video.height ? 'width:' + video.width + 'px;height:' + video.height + 'px;' : '',
2596			customTn = target.find( 'img' ),
2597			srcType = 'src',
2598			lazyClass = '',
2599			settings = this._core.settings,
2600			create = function( thispath ) {
2601				icon = '<div class="owl-video-play-icon"></div>';
2602
2603				if ( settings.lazyLoad ) {
2604					tnLink = $( '<div/>', {
2605						class: 'owl-video-tn ' + lazyClass,
2606						srcType: thispath
2607					} );
2608				} else {
2609					tnLink = $( '<div/>', {
2610						class: 'owl-video-tn',
2611						style: 'opacity:1;background-image:url(' + thispath + ')'
2612					} );
2613				}
2614				target.after( tnLink );
2615				target.after( icon );
2616			};
2617
2618		// wrap video content into owl-video-wrapper div
2619		target.wrap(
2620			$( '<div/>', {
2621				class: 'owl-video-wrapper',
2622				style: dimensions
2623			} )
2624		);
2625
2626		if ( this._core.settings.lazyLoad ) {
2627			srcType = 'data-src';
2628			lazyClass = 'owl-lazy';
2629		}
2630
2631		// custom thumbnail
2632		if ( customTn.length ) {
2633			create( customTn.attr( srcType ) );
2634			customTn.remove();
2635			return false;
2636		}
2637
2638		if ( video.type === 'youtube' ) {
2639			path = '//img.youtube.com/vi/' + video.id + '/hqdefault.jpg';
2640			create( path );
2641		} else if ( video.type === 'vimeo' ) {
2642			$.ajax( {
2643				type: 'GET',
2644				url: '//vimeo.com/api/v2/video/' + video.id + '.json',
2645				jsonp: 'callback',
2646				dataType: 'jsonp',
2647				success: function( data ) {
2648					path = data[ 0 ].thumbnail_large;
2649					create( path );
2650				}
2651			} );
2652		} else if ( video.type === 'vzaar' ) {
2653			$.ajax( {
2654				type: 'GET',
2655				url: '//vzaar.com/api/videos/' + video.id + '.json',
2656				jsonp: 'callback',
2657				dataType: 'jsonp',
2658				success: function( data ) {
2659					path = data.framegrab_url;
2660					create( path );
2661				}
2662			} );
2663		}
2664	};
2665
2666	/**
2667	 * Stops the current video.
2668	 *
2669	 * @public
2670	 */
2671	Video.prototype.stop = function() {
2672		this._core.trigger( 'stop', null, 'video' );
2673		this._playing.find( '.owl-video-frame' ).remove();
2674		this._playing.removeClass( 'owl-video-playing' );
2675		this._playing = null;
2676		this._core.leave( 'playing' );
2677		this._core.trigger( 'stopped', null, 'video' );
2678	};
2679
2680	/**
2681	 * Starts the current video.
2682	 *
2683	 * @public
2684	 * @param {Event} event - The event arguments.
2685	 */
2686	Video.prototype.play = function( event ) {
2687		var target = $( event.target ),
2688			item = target.closest( '.' + this._core.settings.itemClass ),
2689			video = this._videos[ item.attr( 'data-video' ) ],
2690			width = video.width || '100%',
2691			height = video.height || this._core.$stage.height(),
2692			html;
2693
2694		if ( this._playing ) {
2695			return;
2696		}
2697
2698		this._core.enter( 'playing' );
2699		this._core.trigger( 'play', null, 'video' );
2700
2701		item = this._core.items( this._core.relative( item.index() ) );
2702
2703		this._core.reset( item.index() );
2704
2705		html = $( '<iframe frameborder="0" allowfullscreen mozallowfullscreen webkitAllowFullScreen ></iframe>' );
2706		html.attr( 'height', height );
2707		html.attr( 'width', width );
2708		if ( video.type === 'youtube' ) {
2709			html.attr( 'src', '//www.youtube.com/embed/' + video.id + '?autoplay=1&rel=0&v=' + video.id );
2710		} else if ( video.type === 'vimeo' ) {
2711			html.attr( 'src', '//player.vimeo.com/video/' + video.id + '?autoplay=1' );
2712		} else if ( video.type === 'vzaar' ) {
2713			html.attr( 'src', '//view.vzaar.com/' + video.id + '/player?autoplay=true' );
2714		}
2715
2716		$( html ).wrap( '<div class="owl-video-frame" />' ).insertAfter( item.find( '.owl-video' ) );
2717
2718		this._playing = item.addClass( 'owl-video-playing' );
2719	};
2720
2721	/**
2722	 * Checks whether an video is currently in full screen mode or not.
2723	 *
2724	 * @todo Bad style because looks like a readonly method but changes members.
2725	 * @protected
2726	 * @returns {boolean}
2727	 */
2728	Video.prototype.isInFullScreen = function() {
2729		var element = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement;
2730
2731		return element && $( element ).parent().hasClass( 'owl-video-frame' );
2732	};
2733
2734	/**
2735	 * Destroys the plugin.
2736	 */
2737	Video.prototype.destroy = function() {
2738		var handler, property;
2739
2740		this._core.$element.off( 'click.owl.video' );
2741
2742		for ( handler in this._handlers ) {
2743			if ( handler ) {
2744				this._core.$element.off( handler, this._handlers[ handler ] );
2745			}
2746		}
2747		for ( property in Object.getOwnPropertyNames( this ) ) {
2748			if ( typeof this[ property ] !== 'function' ) {
2749				this[ property ] = null;
2750			}
2751		}
2752	};
2753
2754	$.fn.tmowlCarousel.Constructor.Plugins.Video = Video;
2755}( window.Zepto || window.jQuery, window, document ) );
2756
2757/**
2758 * Animate Plugin
2759 *
2760 * @param {jQuery} $
2761 * @version 2.3.4
2762 * @author Bartosz Wojciechowski
2763 * @author David Deutsch
2764 * @license The MIT License (MIT)
2765 */
2766( function( $ ) {
2767	'use strict';
2768	/**
2769	 * Creates the animate plugin.
2770	 *
2771	 * @class The Navigation Plugin
2772	 * @param {Owl} scope - The Owl Carousel