/*
     _ _      _       _
 ___| (_) ___| | __  (_)___
/ __| | |/ __| |/ /  | / __|
\__ \ | | (__|   < _ | \__ \
|___/_|_|\___|_|\_(_)/ |___/
                   |__/
  Author: Ken Wheeler
 Website: http://kenwheeler.github.io
    Docs: http://kenwheeler.github.io/slick
    Repo: http://github.com/kenwheeler/slick
  Issues: http://github.com/kenwheeler/slick/issues
 */
/* global window, document, define, jQuery, setInterval, clearInterval */
( function ( factory ) {
	'use strict';
	if ( typeof define === 'function' && define.amd ) {
		define( [ 'jquery' ], factory );
	} else {
		factory( jQuery );
	}
} )( function ( $ ) {
	'use strict';
	let Slick = window.Slick || {};
	Slick = ( function () {
		let instanceUid = 0;
		function Slick( element, settings ) {
			let _ = this,
				responsiveSettings,
				breakpoint;
			_.defaults = {
				accessibility: true,
				arrows: true,
				autoplay: false,
				autoplaySpeed: 3000,
				centerMode: false,
				centerPadding: '50px',
				cssEase: 'ease',
				customPaging( slider, i ) {
					return '<button type="button">' + ( i + 1 ) + '</button>';
				},
				dots: false,
				draggable: true,
				easing: 'linear',
				fade: false,
				infinite: true,
				lazyLoad: 'ondemand',
				onBeforeChange: null,
				onAfterChange: null,
				onInit: null,
				onReInit: null,
				pauseOnHover: true,
				responsive: null,
				slide: 'div',
				slidesToShow: 1,
				slidesToScroll: 1,
				speed: 300,
				swipe: true,
				touchMove: true,
				touchThreshold: 5,
				useCSS: true,
				vertical: false,
			};
			_.initials = {
				animating: false,
				autoPlayTimer: null,
				currentSlide: 0,
				currentLeft: null,
				direction: 1,
				$dots: null,
				listWidth: null,
				listHeight: null,
				loadIndex: 0,
				$nextArrow: null,
				$prevArrow: null,
				slideCount: null,
				slideWidth: null,
				$slideTrack: null,
				$slides: null,
				sliding: false,
				slideOffset: 0,
				swipeLeft: null,
				$list: null,
				touchObject: {},
				transformsEnabled: false,
			};
			$.extend( _, _.initials );
			_.activeBreakpoint = null;
			_.animType = null;
			_.animProp = null;
			_.breakpoints = [];
			_.breakpointSettings = [];
			_.cssTransitions = false;
			_.paused = false;
			_.positionProp = null;
			_.$slider = $( element );
			_.$slidesCache = null;
			_.transformType = null;
			_.transitionType = null;
			_.windowWidth = 0;
			_.windowTimer = null;
			_.options = $.extend( {}, _.defaults, settings );
			_.originalSettings = _.options;
			responsiveSettings = _.options.responsive || null;
			if ( responsiveSettings && responsiveSettings.length > -1 ) {
				for ( breakpoint in responsiveSettings ) {
					if ( responsiveSettings.hasOwnProperty( breakpoint ) ) {
						_.breakpoints.push(
							responsiveSettings[ breakpoint ].breakpoint
						);
						_.breakpointSettings[
							responsiveSettings[ breakpoint ].breakpoint
						] = responsiveSettings[ breakpoint ].settings;
					}
				}
				_.breakpoints.sort( function ( a, b ) {
					return b - a;
				} );
			}
			_.autoPlay = $.proxy( _.autoPlay, _ );
			_.autoPlayClear = $.proxy( _.autoPlayClear, _ );
			_.changeSlide = $.proxy( _.changeSlide, _ );
			_.setPosition = $.proxy( _.setPosition, _ );
			_.swipeHandler = $.proxy( _.swipeHandler, _ );
			_.dragHandler = $.proxy( _.dragHandler, _ );
			_.keyHandler = $.proxy( _.keyHandler, _ );
			_.autoPlayIterator = $.proxy( _.autoPlayIterator, _ );
			_.instanceUid = instanceUid++;
			_.init();
		}
		return Slick;
	} )();
	Slick.prototype.addSlide = function ( markup, index, addBefore ) {
		const _ = this;
		if ( typeof index === 'boolean' ) {
			addBefore = index;
			index = null;
		} else if ( index < 0 || index >= _.slideCount ) {
			return false;
		}
		_.unload();
		if ( typeof index === 'number' ) {
			if ( index === 0 && _.$slides.length === 0 ) {
				$( markup ).appendTo( _.$slideTrack );
			} else if ( addBefore ) {
				$( markup ).insertBefore( _.$slides.eq( index ) );
			} else {
				$( markup ).insertAfter( _.$slides.eq( index ) );
			}
		} else if ( addBefore === true ) {
			$( markup ).prependTo( _.$slideTrack );
		} else {
			$( markup ).appendTo( _.$slideTrack );
		}
		_.$slides = _.$slideTrack.children( this.options.slide );
		_.$slideTrack.children( this.options.slide ).remove();
		_.$slideTrack.append( _.$slides );
		_.$slidesCache = _.$slides;
		_.reinit();
	};
	Slick.prototype.animateSlide = function ( targetLeft, callback ) {
		const animProps = {},
			_ = this;
		if ( _.transformsEnabled === false ) {
			if ( _.options.vertical === false ) {
				_.$slideTrack.animate(
					{
						left: targetLeft,
					},
					_.options.speed,
					_.options.easing,
					callback
				);
			} else {
				_.$slideTrack.animate(
					{
						top: targetLeft,
					},
					_.options.speed,
					_.options.easing,
					callback
				);
			}
		} else if ( _.cssTransitions === false ) {
			$( {
				animStart: _.currentLeft,
			} ).animate(
				{
					animStart: targetLeft,
				},
				{
					duration: _.options.speed,
					easing: _.options.easing,
					step( now ) {
						if ( _.options.vertical === false ) {
							animProps[ _.animType ] =
								'translate(' + now + 'px, 0px)';
							_.$slideTrack.css( animProps );
						} else {
							animProps[ _.animType ] =
								'translate(0px,' + now + 'px)';
							_.$slideTrack.css( animProps );
						}
					},
					complete() {
						if ( callback ) {
							callback.call();
						}
					},
				}
			);
		} else {
			_.applyTransition();
			if ( _.options.vertical === false ) {
				animProps[ _.animType ] =
					'translate3d(' + targetLeft + 'px, 0px, 0px)';
			} else {
				animProps[ _.animType ] =
					'translate3d(0px,' + targetLeft + 'px, 0px)';
			}
			_.$slideTrack.css( animProps );
			if ( callback ) {
				setTimeout( function () {
					_.disableTransition();
					callback.call();
				}, _.options.speed );
			}
		}
	};
	Slick.prototype.applyTransition = function ( slide ) {
		const _ = this,
			transition = {};
		if ( _.options.fade === false ) {
			transition[ _.transitionType ] =
				_.transformType +
				' ' +
				_.options.speed +
				'ms ' +
				_.options.cssEase;
		} else {
			transition[ _.transitionType ] =
				'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
		}
		if ( _.options.fade === false ) {
			_.$slideTrack.css( transition );
		} else {
			_.$slides.eq( slide ).css( transition );
		}
	};
	Slick.prototype.autoPlay = function () {
		const _ = this;
		if ( _.autoPlayTimer ) {
			clearInterval( _.autoPlayTimer );
		}
		if ( _.slideCount > _.options.slidesToShow && _.paused !== true ) {
			_.autoPlayTimer = setInterval(
				_.autoPlayIterator,
				_.options.autoplaySpeed
			);
		}
	};
	Slick.prototype.autoPlayClear = function () {
		const _ = this;
		if ( _.autoPlayTimer ) {
			clearInterval( _.autoPlayTimer );
		}
	};
	Slick.prototype.autoPlayIterator = function () {
		const _ = this;
		if ( _.options.infinite === false ) {
			if ( _.direction === 1 ) {
				if ( _.currentSlide + 1 === _.slideCount - 1 ) {
					_.direction = 0;
				}
				_.slideHandler( _.currentSlide + _.options.slidesToScroll );
			} else {
				if ( _.currentSlide - 1 === 0 ) {
					_.direction = 1;
				}
				_.slideHandler( _.currentSlide - _.options.slidesToScroll );
			}
		} else {
			_.slideHandler( _.currentSlide + _.options.slidesToScroll );
		}
	};
	Slick.prototype.buildArrows = function () {
		const _ = this;
		if (
			_.options.arrows === true &&
			_.slideCount > _.options.slidesToShow
		) {
			_.$prevArrow = $(
				'<button type="button" class="slick-prev"><i class="wooicon-arrow-left10"></i></button>'
			).appendTo( _.$slider );
			_.$nextArrow = $(
				'<button type="button" class="slick-next"><i class="wooicon-uniE626"></i></button>'
			).appendTo( _.$slider );
			if ( _.options.infinite !== true ) {
				_.$prevArrow.addClass( 'slick-disabled' );
			}
		}
	};
	Slick.prototype.buildDots = function () {
		let _ = this,
			i,
			dotString;
		if (
			_.options.dots === true &&
			_.slideCount > _.options.slidesToShow
		) {
			dotString = '<ul class="slick-dots">';
			for ( i = 0; i <= _.getDotCount(); i += 1 ) {
				dotString +=
					'<li>' +
					_.options.customPaging.call( this, _, i ) +
					'</li>';
			}
			dotString += '</ul>';
			_.$dots = $( dotString ).appendTo( _.$slider );
			_.$dots.find( 'li' ).first().addClass( 'slick-active' );
		}
	};
	Slick.prototype.buildOut = function () {
		const _ = this;
		_.$slides = _.$slider
			.children( _.options.slide + ':not(.slick-cloned)' )
			.addClass( 'slick-slide' );
		_.slideCount = _.$slides.length;
		_.$slidesCache = _.$slides;
		_.$slider.addClass( 'slick-slider' );
		_.$slideTrack =
			_.slideCount === 0
				? $( '<div class="slick-track"/>' ).appendTo( _.$slider )
				: _.$slides.wrapAll( '<div class="slick-track"/>' ).parent();
		_.$list = _.$slideTrack.wrap( '<div class="slick-list"/>' ).parent();
		_.$slideTrack.css( 'opacity', 0 );
		if ( _.options.centerMode === true ) {
			_.options.infinite = true;
			_.options.slidesToScroll = 1;
			if ( _.options.slidesToShow % 2 === 0 ) {
				_.options.slidesToShow = 3;
			}
		}
		$( 'img[data-lazy]', _.$slider )
			.not( '[src]' )
			.addClass( 'slick-loading' );
		_.setupInfinite();
		_.buildArrows();
		_.buildDots();
		if ( _.options.accessibility === true ) {
			_.$list.prop( 'tabIndex', 0 );
		}
		_.setSlideClasses( 0 );
		if ( _.options.draggable === true ) {
			_.$list.addClass( 'draggable' );
		}
	};
	Slick.prototype.checkResponsive = function () {
		let _ = this,
			breakpoint,
			targetBreakpoint;
		if (
			_.originalSettings.responsive &&
			_.originalSettings.responsive.length > -1 &&
			_.originalSettings.responsive !== null
		) {
			targetBreakpoint = null;
			for ( breakpoint in _.breakpoints ) {
				if ( _.breakpoints.hasOwnProperty( breakpoint ) ) {
					if ( $( window ).width() < _.breakpoints[ breakpoint ] ) {
						targetBreakpoint = _.breakpoints[ breakpoint ];
					}
				}
			}
			if ( targetBreakpoint !== null ) {
				if ( _.activeBreakpoint !== null ) {
					if ( targetBreakpoint !== _.activeBreakpoint ) {
						_.activeBreakpoint = targetBreakpoint;
						_.options = $.extend(
							{},
							_.defaults,
							_.breakpointSettings[ targetBreakpoint ]
						);
						_.refresh();
					}
				} else {
					_.activeBreakpoint = targetBreakpoint;
					_.options = $.extend(
						{},
						_.defaults,
						_.breakpointSettings[ targetBreakpoint ]
					);
					_.refresh();
				}
			} else if ( _.activeBreakpoint !== null ) {
				_.activeBreakpoint = null;
				_.options = $.extend( {}, _.defaults, _.originalSettings );
				_.refresh();
			}
		}
	};
	Slick.prototype.changeSlide = function ( event ) {
		const _ = this;
		switch ( event.data.message ) {
			case 'previous':
				_.slideHandler( _.currentSlide - _.options.slidesToScroll );
				break;
			case 'next':
				_.slideHandler( _.currentSlide + _.options.slidesToScroll );
				break;
			case 'index':
				_.slideHandler(
					$( event.target ).parent().index() *
						_.options.slidesToScroll
				);
				break;
			default:
				return false;
		}
	};
	Slick.prototype.destroy = function () {
		const _ = this;
		_.autoPlayClear();
		_.touchObject = {};
		$( '.slick-cloned', _.$slider ).remove();
		if ( _.$dots ) {
			_.$dots.remove();
		}
		if ( _.$prevArrow ) {
			_.$prevArrow.remove();
			_.$nextArrow.remove();
		}
		_.$slides.unwrap().unwrap();
		_.$slides
			.removeClass( 'slick-slide slick-active slick-visible' )
			.removeAttr( 'style' );
		_.$slider.removeClass( 'slick-slider' );
		_.$slider.removeClass( 'slick-initialized' );
		_.$list.off( '.slick' );
		$( window ).off( '.slick-' + _.instanceUid );
	};
	Slick.prototype.disableTransition = function ( slide ) {
		const _ = this,
			transition = {};
		transition[ _.transitionType ] = '';
		if ( _.options.fade === false ) {
			_.$slideTrack.css( transition );
		} else {
			_.$slides.eq( slide ).css( transition );
		}
	};
	Slick.prototype.fadeSlide = function ( slideIndex, callback ) {
		const _ = this;
		if ( _.cssTransitions === false ) {
			_.$slides.eq( slideIndex ).css( {
				zIndex: 1000,
			} );
			_.$slides.eq( slideIndex ).animate(
				{
					opacity: 1,
				},
				_.options.speed,
				_.options.easing,
				callback
			);
		} else {
			_.applyTransition( slideIndex );
			_.$slides.eq( slideIndex ).css( {
				opacity: 1,
				zIndex: 1000,
			} );
			if ( callback ) {
				setTimeout( function () {
					_.disableTransition( slideIndex );
					callback.call();
				}, _.options.speed );
			}
		}
	};
	Slick.prototype.filterSlides = function ( filter ) {
		const _ = this;
		if ( filter !== null ) {
			_.unload();
			_.$slideTrack.children( this.options.slide ).remove();
			_.$slidesCache.filter( filter ).appendTo( _.$slideTrack );
			_.reinit();
		}
	};
	Slick.prototype.getCurrent = function () {
		const _ = this;
		return _.currentSlide;
	};
	Slick.prototype.getDotCount = function () {
		let _ = this,
			breaker = 0,
			dotCounter = 0,
			dotCount = 0,
			dotLimit;
		dotLimit =
			_.options.infinite === true
				? _.slideCount +
				  _.options.slidesToShow -
				  _.options.slidesToScroll
				: _.slideCount;
		while ( breaker < dotLimit ) {
			dotCount++;
			dotCounter += _.options.slidesToScroll;
			breaker = dotCounter + _.options.slidesToShow;
		}
		return dotCount;
	};
	Slick.prototype.getLeft = function ( slideIndex ) {
		let _ = this,
			targetLeft,
			verticalHeight,
			verticalOffset = 0;
		_.slideOffset = 0;
		verticalHeight = _.$slides.first().outerHeight();
		if ( _.options.infinite === true ) {
			if ( _.slideCount > _.options.slidesToShow ) {
				_.slideOffset = _.slideWidth * _.options.slidesToShow * -1;
				verticalOffset = verticalHeight * _.options.slidesToShow * -1;
			}
			if ( _.slideCount % _.options.slidesToScroll !== 0 ) {
				if (
					slideIndex + _.options.slidesToScroll > _.slideCount &&
					_.slideCount > _.options.slidesToShow
				) {
					_.slideOffset =
						( _.slideCount % _.options.slidesToShow ) *
						_.slideWidth *
						-1;
					verticalOffset =
						( _.slideCount % _.options.slidesToShow ) *
						verticalHeight *
						-1;
				}
			}
		} else if ( _.slideCount % _.options.slidesToShow !== 0 ) {
			if (
				slideIndex + _.options.slidesToScroll > _.slideCount &&
				_.slideCount > _.options.slidesToShow
			) {
				_.slideOffset =
					_.options.slidesToShow * _.slideWidth -
					( _.slideCount % _.options.slidesToShow ) * _.slideWidth;
				verticalOffset =
					( _.slideCount % _.options.slidesToShow ) * verticalHeight;
			}
		}
		if ( _.options.centerMode === true ) {
			_.slideOffset +=
				_.slideWidth * Math.floor( _.options.slidesToShow / 2 ) -
				_.slideWidth;
		}
		if ( _.options.vertical === false ) {
			targetLeft = slideIndex * _.slideWidth * -1 + _.slideOffset;
		} else {
			targetLeft = slideIndex * verticalHeight * -1 + verticalOffset;
		}
		return targetLeft;
	};
	Slick.prototype.init = function () {
		const _ = this;
		if ( ! $( _.$slider ).hasClass( 'slick-initialized' ) ) {
			$( _.$slider ).addClass( 'slick-initialized' );
			_.buildOut();
			_.setProps();
			_.startLoad();
			_.loadSlider();
			_.initializeEvents();
			_.checkResponsive();
		}
		if ( _.options.onInit !== null ) {
			_.options.onInit.call( this, _ );
		}
	};
	Slick.prototype.initArrowEvents = function () {
		const _ = this;
		if (
			_.options.arrows === true &&
			_.slideCount > _.options.slidesToShow
		) {
			_.$prevArrow.on(
				'click.slick',
				{
					message: 'previous',
				},
				_.changeSlide
			);
			_.$nextArrow.on(
				'click.slick',
				{
					message: 'next',
				},
				_.changeSlide
			);
		}
	};
	Slick.prototype.initDotEvents = function () {
		const _ = this;
		if (
			_.options.dots === true &&
			_.slideCount > _.options.slidesToShow
		) {
			$( 'li', _.$dots ).on(
				'click.slick',
				{
					message: 'index',
				},
				_.changeSlide
			);
		}
	};
	Slick.prototype.initializeEvents = function () {
		const _ = this;
		_.initArrowEvents();
		_.initDotEvents();
		_.$list.on(
			'touchstart.slick mousedown.slick',
			{
				action: 'start',
			},
			_.swipeHandler
		);
		_.$list.on(
			'touchmove.slick mousemove.slick',
			{
				action: 'move',
			},
			_.swipeHandler
		);
		_.$list.on(
			'touchend.slick mouseup.slick',
			{
				action: 'end',
			},
			_.swipeHandler
		);
		_.$list.on(
			'touchcancel.slick mouseleave.slick',
			{
				action: 'end',
			},
			_.swipeHandler
		);
		if ( _.options.pauseOnHover === true && _.options.autoplay === true ) {
			_.$list.on( 'mouseenter.slick', _.autoPlayClear );
			_.$list.on( 'mouseleave.slick', _.autoPlay );
		}
		if ( _.options.accessibility === true ) {
			_.$list.on( 'keydown.slick', _.keyHandler );
		}
		$( window ).on(
			'orientationchange.slick.slick-' + _.instanceUid,
			function () {
				_.checkResponsive();
				_.setPosition();
			}
		);
		$( window ).on( 'resize.slick.slick-' + _.instanceUid, function () {
			if ( $( window ).width !== _.windowWidth ) {
				clearTimeout( _.windowDelay );
				_.windowDelay = window.setTimeout( function () {
					_.windowWidth = $( window ).width();
					_.checkResponsive();
					_.setPosition();
				}, 50 );
			}
		} );
		$( window ).on( 'load.slick.slick-' + _.instanceUid, _.setPosition );
	};
	Slick.prototype.initUI = function () {
		const _ = this;
		if (
			_.options.arrows === true &&
			_.slideCount > _.options.slidesToShow
		) {
			_.$prevArrow.show();
			_.$nextArrow.show();
		}
		if (
			_.options.dots === true &&
			_.slideCount > _.options.slidesToShow
		) {
			_.$dots.show();
		}
		if ( _.options.autoplay === true ) {
			_.autoPlay();
		}
	};
	Slick.prototype.keyHandler = function ( event ) {
		const _ = this;
		if ( event.keyCode === 37 ) {
			_.changeSlide( {
				data: {
					message: 'previous',
				},
			} );
		} else if ( event.keyCode === 39 ) {
			_.changeSlide( {
				data: {
					message: 'next',
				},
			} );
		}
	};
	Slick.prototype.lazyLoad = function () {
		let _ = this,
			loadRange,
			cloneRange,
			rangeStart,
			rangeEnd;
		if ( _.options.centerMode === true ) {
			rangeStart = _.options.slidesToShow + _.currentSlide - 1;
			rangeEnd = rangeStart + _.options.slidesToShow + 2;
		} else {
			rangeStart = _.options.infinite
				? _.options.slidesToShow + _.currentSlide
				: _.currentSlide;
			rangeEnd = rangeStart + _.options.slidesToShow;
		}
		loadRange = _.$slider
			.find( '.slick-slide' )
			.slice( rangeStart, rangeEnd );
		$( 'img[data-lazy]', loadRange )
			.not( '[src]' )
			.each( function () {
				$( this )
					.css( { opacity: 0 } )
					.attr( 'src', $( this ).attr( 'data-lazy' ) )
					.removeClass( 'slick-loading' )
					.load( function () {
						$( this ).animate( { opacity: 1 }, 200 );
					} );
			} );
		if ( _.currentSlide >= _.slideCount - _.options.slidesToShow ) {
			cloneRange = _.$slider
				.find( '.slick-cloned' )
				.slice( 0, _.options.slidesToShow );
			$( 'img[data-lazy]', cloneRange )
				.not( '[src]' )
				.each( function () {
					$( this )
						.css( { opacity: 0 } )
						.attr( 'src', $( this ).attr( 'data-lazy' ) )
						.removeClass( 'slick-loading' )
						.load( function () {
							$( this ).animate( { opacity: 1 }, 200 );
						} );
				} );
		} else if ( _.currentSlide === 0 ) {
			cloneRange = _.$slider
				.find( '.slick-cloned' )
				.slice( _.options.slidesToShow * -1 );
			$( 'img[data-lazy]', cloneRange )
				.not( '[src]' )
				.each( function () {
					$( this )
						.css( { opacity: 0 } )
						.attr( 'src', $( this ).attr( 'data-lazy' ) )
						.removeClass( 'slick-loading' )
						.load( function () {
							$( this ).animate( { opacity: 1 }, 200 );
						} );
				} );
		}
	};
	Slick.prototype.loadSlider = function () {
		const _ = this;
		_.setPosition();
		_.$slideTrack.css( {
			opacity: 1,
		} );
		_.$slider.removeClass( 'slick-loading' );
		_.initUI();
		if ( _.options.lazyLoad === 'progressive' ) {
			_.progressiveLazyLoad();
		}
	};
	Slick.prototype.postSlide = function ( index ) {
		const _ = this;
		if ( _.options.onAfterChange !== null ) {
			_.options.onAfterChange.call( this, _, index );
		}
		_.animating = false;
		_.setPosition();
		_.swipeLeft = null;
		if ( _.options.autoplay === true && _.paused === false ) {
			_.autoPlay();
		}
	};
	Slick.prototype.progressiveLazyLoad = function () {
		let _ = this,
			imgCount,
			targetImage;
		imgCount = $( 'img[data-lazy]' ).not( '[src]' ).length;
		if ( imgCount > 0 ) {
			targetImage = $(
				$( 'img[data-lazy]', _.$slider ).not( '[src]' ).get( 0 )
			);
			targetImage
				.attr( 'src', targetImage.attr( 'data-lazy' ) )
				.removeClass( 'slick-loading' )
				.load( function () {
					_.progressiveLazyLoad();
				} );
		}
	};
	Slick.prototype.refresh = function () {
		const _ = this;
		_.destroy();
		$.extend( _, _.initials );
		_.init();
	};
	Slick.prototype.reinit = function () {
		const _ = this;
		_.$slides = _.$slideTrack
			.children( _.options.slide )
			.addClass( 'slick-slide' );
		_.slideCount = _.$slides.length;
		if ( _.currentSlide >= _.slideCount && _.currentSlide !== 0 ) {
			_.currentSlide = _.currentSlide - _.options.slidesToScroll;
		}
		_.setProps();
		_.setupInfinite();
		_.buildArrows();
		_.updateArrows();
		_.initArrowEvents();
		_.buildDots();
		_.updateDots();
		_.initDotEvents();
		_.setSlideClasses( 0 );
		_.setPosition();
		if ( _.options.onReInit !== null ) {
			_.options.onReInit.call( this, _ );
		}
	};
	Slick.prototype.removeSlide = function ( index, removeBefore ) {
		const _ = this;
		if ( typeof index === 'boolean' ) {
			removeBefore = index;
			index = removeBefore === true ? 0 : _.slideCount - 1;
		} else {
			index = removeBefore === true ? --index : index;
		}
		if ( _.slideCount < 1 || index < 0 || index > _.slideCount - 1 ) {
			return false;
		}
		_.unload();
		_.$slideTrack.children( this.options.slide ).eq( index ).remove();
		_.$slides = _.$slideTrack.children( this.options.slide );
		_.$slideTrack.children( this.options.slide ).remove();
		_.$slideTrack.append( _.$slides );
		_.$slidesCache = _.$slides;
		_.reinit();
	};
	Slick.prototype.setCSS = function ( position ) {
		let _ = this,
			positionProps = {},
			x,
			y;
		x = _.positionProp == 'left' ? position + 'px' : '0px';
		y = _.positionProp == 'top' ? position + 'px' : '0px';
		positionProps[ _.positionProp ] = position;
		if ( _.transformsEnabled === false ) {
			_.$slideTrack.css( positionProps );
		} else {
			positionProps = {};
			if ( _.cssTransitions === false ) {
				positionProps[ _.animType ] = 'translate(' + x + ', ' + y + ')';
				_.$slideTrack.css( positionProps );
			} else {
				positionProps[ _.animType ] =
					'translate3d(' + x + ', ' + y + ', 0px)';
				_.$slideTrack.css( positionProps );
			}
		}
	};
	Slick.prototype.setDimensions = function () {
		const _ = this;
		if ( _.options.centerMode === true ) {
			_.$slideTrack.children( '.slick-slide' ).width( _.slideWidth );
		} else {
			_.$slideTrack.children( '.slick-slide' ).width( _.slideWidth );
		}
		if ( _.options.vertical === false ) {
			_.$slideTrack.width(
				Math.ceil(
					_.slideWidth *
						_.$slideTrack.children( '.slick-slide' ).length
				)
			);
			if ( _.options.centerMode === true ) {
				_.$list.css( {
					padding: '0px ' + _.options.centerPadding,
				} );
			}
		} else {
			_.$list.height(
				_.$slides.first().outerHeight() * _.options.slidesToShow
			);
			_.$slideTrack.height(
				Math.ceil(
					_.$slides.first().outerHeight() *
						_.$slideTrack.children( '.slick-slide' ).length
				)
			);
			if ( _.options.centerMode === true ) {
				_.$list.css( {
					padding: _.options.centerPadding + ' 0px',
				} );
			}
		}
	};
	Slick.prototype.setFade = function () {
		let _ = this,
			targetLeft;
		_.$slides.each( function ( index, element ) {
			targetLeft = _.slideWidth * index * -1;
			$( element ).css( {
				position: 'relative',
				left: targetLeft,
				top: 0,
				zIndex: 800,
				opacity: 0,
			} );
		} );
		_.$slides.eq( _.currentSlide ).css( {
			zIndex: 900,
			opacity: 1,
		} );
	};
	Slick.prototype.setPosition = function () {
		const _ = this;
		_.setValues();
		_.setDimensions();
		if ( _.options.fade === false ) {
			_.setCSS( _.getLeft( _.currentSlide ) );
		} else {
			_.setFade();
		}
	};
	Slick.prototype.setProps = function () {
		const _ = this;
		_.positionProp = _.options.vertical === true ? 'top' : 'left';
		if ( _.positionProp === 'top' ) {
			_.$slider.addClass( 'slick-vertical' );
		} else {
			_.$slider.removeClass( 'slick-vertical' );
		}
		if (
			document.body.style.WebkitTransition !== undefined ||
			document.body.style.MozTransition !== undefined ||
			document.body.style.msTransition !== undefined
		) {
			if ( _.options.useCSS === true ) {
				_.cssTransitions = true;
			}
		}
		if ( document.body.style.MozTransform !== undefined ) {
			_.animType = 'MozTransform';
			_.transformType = '-moz-transform';
			_.transitionType = 'MozTransition';
		}
		if ( document.body.style.webkitTransform !== undefined ) {
			_.animType = 'webkitTransform';
			_.transformType = '-webkit-transform';
			_.transitionType = 'webkitTransition';
		}
		if ( document.body.style.msTransform !== undefined ) {
			_.animType = 'transform';
			_.transformType = 'transform';
			_.transitionType = 'transition';
		}
		_.transformsEnabled = _.animType !== null;
	};
	Slick.prototype.setValues = function () {
		const _ = this;
		_.listWidth = _.$list.width();
		_.listHeight = _.$list.height();
		if ( _.options.vertical === false ) {
			_.slideWidth = Math.ceil( _.listWidth / _.options.slidesToShow );
		} else {
			_.slideWidth = Math.ceil( _.listWidth );
		}
	};
	Slick.prototype.setSlideClasses = function ( index ) {
		let _ = this,
			centerOffset,
			allSlides,
			indexOffset;
		var animate = _.$slider.find( '.slick-slide' ).data( 'animation' );
		_.$slider.find( '.slick-slide' ).removeClass( animate );
		_.$slider
			.find( '.slick-slide' )
			.removeClass( 'slick-active' )
			.removeClass( 'slick-center' );
		allSlides = _.$slider.find( '.slick-slide' );
		if ( _.options.centerMode === true ) {
			centerOffset = Math.floor( _.options.slidesToShow / 2 );
			if (
				index >= centerOffset &&
				index <= _.slideCount - 1 - centerOffset
			) {
				_.$slides
					.slice( index - centerOffset, index + centerOffset + 1 )
					.addClass( 'slick-active' );
			} else {
				indexOffset = _.options.slidesToShow + index;
				allSlides
					.slice(
						indexOffset - centerOffset + 1,
						indexOffset + centerOffset + 2
					)
					.addClass( 'slick-active' );
			}
			if ( index === 0 ) {
				allSlides
					.eq( allSlides.length - 1 - _.options.slidesToShow )
					.addClass( 'slick-center' );
			} else if ( index === _.slideCount - 1 ) {
				allSlides
					.eq( _.options.slidesToShow )
					.addClass( 'slick-center' );
			}
			_.$slides.eq( index ).addClass( 'slick-center' );
		} else if (
			index > 0 &&
			index < _.slideCount - _.options.slidesToShow
		) {
			_.$slides
				.slice( index, index + _.options.slidesToShow )
				.addClass( 'slick-active' );
			var animate = _.$slides
				.slice( index, index + _.options.slidesToShow )
				.data( 'animation' );
			_.$slides
				.slice( index, index + _.options.slidesToShow )
				.addClass( animate );
		} else {
			indexOffset =
				_.options.infinite === true
					? _.options.slidesToShow + index
					: index;
			allSlides
				.slice( indexOffset, indexOffset + _.options.slidesToShow )
				.addClass( 'slick-active' );
			var animate = allSlides
				.slice( indexOffset, indexOffset + _.options.slidesToShow )
				.data( 'animation' );
			allSlides
				.slice( indexOffset, indexOffset + _.options.slidesToShow )
				.addClass( animate );
		}
		if ( _.options.lazyLoad === 'ondemand' ) {
			_.lazyLoad();
		}
	};
	Slick.prototype.setupInfinite = function () {
		let _ = this,
			i,
			slideIndex,
			infiniteCount;
		if ( _.options.fade === true || _.options.vertical === true ) {
			_.options.centerMode = false;
		}
		if ( _.options.infinite === true && _.options.fade === false ) {
			slideIndex = null;
			if ( _.slideCount > _.options.slidesToShow ) {
				if ( _.options.centerMode === true ) {
					infiniteCount = _.options.slidesToShow + 1;
				} else {
					infiniteCount = _.options.slidesToShow;
				}
				for (
					i = _.slideCount;
					i > _.slideCount - infiniteCount;
					i -= 1
				) {
					slideIndex = i - 1;
					$( _.$slides[ slideIndex ] )
						.clone()
						.attr( 'id', '' )
						.prependTo( _.$slideTrack )
						.addClass( 'slick-cloned' );
				}
				for ( i = 0; i < infiniteCount; i += 1 ) {
					slideIndex = i;
					$( _.$slides[ slideIndex ] )
						.clone()
						.attr( 'id', '' )
						.appendTo( _.$slideTrack )
						.addClass( 'slick-cloned' );
				}
				_.$slideTrack
					.find( '.slick-cloned' )
					.find( '[id]' )
					.each( function () {
						$( this ).attr( 'id', '' );
					} );
			}
		}
	};
	Slick.prototype.slideHandler = function ( index ) {
		let targetSlide,
			animSlide,
			slideLeft,
			unevenOffset,
			targetLeft = null,
			_ = this;
		if ( _.animating === true ) {
			return false;
		}
		targetSlide = index;
		targetLeft = _.getLeft( targetSlide );
		slideLeft = _.getLeft( _.currentSlide );
		unevenOffset =
			_.slideCount % _.options.slidesToScroll !== 0
				? _.options.slidesToScroll
				: 0;
		_.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
		if (
			_.options.infinite === false &&
			( index < 0 ||
				index > _.slideCount - _.options.slidesToShow + unevenOffset )
		) {
			targetSlide = _.currentSlide;
			_.animateSlide( slideLeft, function () {
				_.postSlide( targetSlide );
			} );
			return false;
		}
		if ( _.options.autoplay === true ) {
			clearInterval( _.autoPlayTimer );
		}
		if ( targetSlide < 0 ) {
			if ( _.slideCount % _.options.slidesToScroll !== 0 ) {
				animSlide =
					_.slideCount - ( _.slideCount % _.options.slidesToScroll );
			} else {
				animSlide = _.slideCount - _.options.slidesToScroll;
			}
		} else if ( targetSlide > _.slideCount - 1 ) {
			animSlide = 0;
		} else {
			animSlide = targetSlide;
		}
		_.animating = true;
		if ( _.options.onBeforeChange !== null && index !== _.currentSlide ) {
			_.options.onBeforeChange.call( this, _, _.currentSlide, animSlide );
		}
		_.currentSlide = animSlide;
		_.setSlideClasses( _.currentSlide );
		_.updateDots();
		_.updateArrows();
		if ( _.options.fade === true ) {
			_.fadeSlide( animSlide, function () {
				_.postSlide( animSlide );
			} );
			return false;
		}
		_.animateSlide( targetLeft, function () {
			_.postSlide( animSlide );
		} );
	};
	Slick.prototype.startLoad = function () {
		const _ = this;
		if (
			_.options.arrows === true &&
			_.slideCount > _.options.slidesToShow
		) {
			_.$prevArrow.hide();
			_.$nextArrow.hide();
		}
		if (
			_.options.dots === true &&
			_.slideCount > _.options.slidesToShow
		) {
			_.$dots.hide();
		}
		_.$slider.addClass( 'slick-loading' );
	};
	Slick.prototype.swipeDirection = function () {
		let xDist,
			yDist,
			r,
			swipeAngle,
			_ = this;
		xDist = _.touchObject.startX - _.touchObject.curX;
		yDist = _.touchObject.startY - _.touchObject.curY;
		r = Math.atan2( yDist, xDist );
		swipeAngle = Math.round( ( r * 180 ) / Math.PI );
		if ( swipeAngle < 0 ) {
			swipeAngle = 360 - Math.abs( swipeAngle );
		}
		if ( swipeAngle <= 45 && swipeAngle >= 0 ) {
			return 'left';
		}
		if ( swipeAngle <= 360 && swipeAngle >= 315 ) {
			return 'left';
		}
		if ( swipeAngle >= 135 && swipeAngle <= 225 ) {
			return 'right';
		}
		return 'vertical';
	};
	Slick.prototype.swipeEnd = function ( event ) {
		const _ = this;
		_.$list.removeClass( 'dragging' );
		if ( _.touchObject.curX === undefined ) {
			return false;
		}
		if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {
			$( event.target ).on( 'click.slick', function ( event ) {
				event.stopImmediatePropagation();
				event.stopPropagation();
				event.preventDefault();
				$( event.target ).off( 'click.slick' );
			} );
			switch ( _.swipeDirection() ) {
				case 'left':
					_.slideHandler( _.currentSlide + _.options.slidesToScroll );
					_.touchObject = {};
					break;
				case 'right':
					_.slideHandler( _.currentSlide - _.options.slidesToScroll );
					_.touchObject = {};
					break;
			}
		} else if ( _.touchObject.startX !== _.touchObject.curX ) {
			_.slideHandler( _.currentSlide );
			_.touchObject = {};
		}
	};
	Slick.prototype.swipeHandler = function ( event ) {
		const _ = this;
		if ( 'ontouchend' in document && _.options.swipe === false ) {
			return false;
		} else if (
			_.options.draggable === false &&
			! event.originalEvent.touches
		) {
			return false;
		}
		_.touchObject.fingerCount =
			event.originalEvent && event.originalEvent.touches !== undefined
				? event.originalEvent.touches.length
				: 1;
		_.touchObject.minSwipe = _.listWidth / _.options.touchThreshold;
		switch ( event.data.action ) {
			case 'start':
				_.swipeStart( event );
				break;
			case 'move':
				_.swipeMove( event );
				break;
			case 'end':
				_.swipeEnd( event );
				break;
		}
	};
	Slick.prototype.swipeMove = function ( event ) {
		let _ = this,
			curLeft,
			swipeDirection,
			positionOffset,
			touches;
		touches =
			event.originalEvent !== undefined
				? event.originalEvent.touches
				: null;
		curLeft = _.getLeft( _.currentSlide );
		if (
			! _.$list.hasClass( 'dragging' ) ||
			( touches && touches.length !== 1 )
		) {
			return false;
		}
		_.touchObject.curX =
			touches !== undefined ? touches[ 0 ].pageX : event.clientX;
		_.touchObject.curY =
			touches !== undefined ? touches[ 0 ].pageY : event.clientY;
		_.touchObject.swipeLength = Math.round(
			Math.sqrt(
				Math.pow( _.touchObject.curX - _.touchObject.startX, 2 )
			)
		);
		swipeDirection = _.swipeDirection();
		if ( swipeDirection === 'vertical' ) {
			return;
		}
		if (
			event.originalEvent !== undefined &&
			_.touchObject.swipeLength > 4
		) {
			event.preventDefault();
		}
		positionOffset = _.touchObject.curX > _.touchObject.startX ? 1 : -1;
		if ( _.options.vertical === false ) {
			_.swipeLeft = curLeft + _.touchObject.swipeLength * positionOffset;
		} else {
			_.swipeLeft =
				curLeft +
				_.touchObject.swipeLength *
					( _.$list.height() / _.listWidth ) *
					positionOffset;
		}
		if ( _.options.fade === true || _.options.touchMove === false ) {
			return false;
		}
		if ( _.animating === true ) {
			_.swipeLeft = null;
			return false;
		}
		_.setCSS( _.swipeLeft );
	};
	Slick.prototype.swipeStart = function ( event ) {
		let _ = this,
			touches;
		if (
			_.touchObject.fingerCount !== 1 ||
			_.slideCount <= _.options.slidesToShow
		) {
			_.touchObject = {};
			return false;
		}
		if (
			event.originalEvent !== undefined &&
			event.originalEvent.touches !== undefined
		) {
			touches = event.originalEvent.touches[ 0 ];
		}
		_.touchObject.startX = _.touchObject.curX =
			touches !== undefined ? touches.pageX : event.clientX;
		_.touchObject.startY = _.touchObject.curY =
			touches !== undefined ? touches.pageY : event.clientY;
		_.$list.addClass( 'dragging' );
	};
	Slick.prototype.unfilterSlides = function () {
		const _ = this;
		if ( _.$slidesCache !== null ) {
			_.unload();
			_.$slideTrack.children( this.options.slide ).remove();
			_.$slidesCache.appendTo( _.$slideTrack );
			_.reinit();
		}
	};
	Slick.prototype.unload = function () {
		const _ = this;
		$( '.slick-cloned', _.$slider ).remove();
		if ( _.$dots ) {
			_.$dots.remove();
		}
		if ( _.$prevArrow ) {
			_.$prevArrow.remove();
			_.$nextArrow.remove();
		}
		_.$slides
			.removeClass( 'slick-slide slick-active slick-visible' )
			.removeAttr( 'style' );
	};
	Slick.prototype.updateArrows = function () {
		const _ = this;
		if (
			_.options.arrows === true &&
			_.options.infinite !== true &&
			_.slideCount > _.options.slidesToShow
		) {
			_.$prevArrow.removeClass( 'slick-disabled' );
			_.$nextArrow.removeClass( 'slick-disabled' );
			if ( _.currentSlide === 0 ) {
				_.$prevArrow.addClass( 'slick-disabled' );
				_.$nextArrow.removeClass( 'slick-disabled' );
			} else if (
				_.currentSlide >=
				_.slideCount - _.options.slidesToShow
			) {
				_.$nextArrow.addClass( 'slick-disabled' );
				_.$prevArrow.removeClass( 'slick-disabled' );
			}
		}
	};
	Slick.prototype.updateDots = function () {
		const _ = this;
		if ( _.$dots !== null ) {
			_.$dots.find( 'li' ).removeClass( 'slick-active' );
			_.$dots
				.find( 'li' )
				.eq( _.currentSlide / _.options.slidesToScroll )
				.addClass( 'slick-active' );
		}
	};
	$.fn.slick = function ( options ) {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick = new Slick( element, options );
		} );
	};
	$.fn.slickAdd = function ( slide, slideIndex, addBefore ) {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.addSlide( slide, slideIndex, addBefore );
		} );
	};
	$.fn.slickCurrentSlide = function () {
		const _ = this;
		return _.get( 0 ).slick.getCurrent();
	};
	$.fn.slickFilter = function ( filter ) {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.filterSlides( filter );
		} );
	};
	$.fn.slickGoTo = function ( slide ) {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.slideHandler( slide );
		} );
	};
	$.fn.slickNext = function () {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.changeSlide( {
				data: {
					message: 'next',
				},
			} );
		} );
	};
	$.fn.slickPause = function () {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.autoPlayClear();
			element.slick.paused = true;
		} );
	};
	$.fn.slickPlay = function () {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.paused = false;
			element.slick.autoPlay();
		} );
	};
	$.fn.slickPrev = function () {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.changeSlide( {
				data: {
					message: 'previous',
				},
			} );
		} );
	};
	$.fn.slickRemove = function ( slideIndex, removeBefore ) {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.removeSlide( slideIndex, removeBefore );
		} );
	};
	$.fn.slickSetOption = function ( option, value, refresh ) {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.options[ option ] = value;
			if ( refresh === true ) {
				element.slick.unload();
				element.slick.reinit();
			}
		} );
	};
	$.fn.slickUnfilter = function () {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.unfilterSlides();
		} );
	};
	$.fn.unslick = function () {
		const _ = this;
		return _.each( function ( index, element ) {
			element.slick.destroy();
		} );
	};
} );
