/*
 *  @Website: apollotheme.com - prestashop template provider
 *  @author Apollotheme <apollotheme@gmail.com>
 *  @copyright Apollotheme
 *  @description: ApPageBuilder is module help you can build content for your shop
 */
/*
 * Custom code goes here.
 * A template should always ship with an empty custom.js
 */
function initSlider(selector, options) {
	if ($.fn.slick) {
		$(selector).slick(options)
	} else {
		;(function (factory) {
			'use strict'
			if (typeof define === 'function' && define.amd) {
				define(['jquery'], factory)
			} else if (typeof exports !== 'undefined') {
				module.exports = factory(require('jquery'))
			} else {
				factory(jQuery)
			}
		})(function ($) {
			'use strict'
			var Slick = window.Slick || {}

			Slick = (function () {
				var instanceUid = 0

				function Slick(element, settings) {
					var _ = this,
						dataSettings

					_.defaults = {
						accessibility: true,
						adaptiveHeight: false,
						appendArrows: $(element),
						appendDots: $(element),
						arrows: true,
						asNavFor: null,
						prevArrow:
							'<button class="slick-prev" aria-label="Previous" type="button">Previous</button>',
						nextArrow:
							'<button class="slick-next" aria-label="Next" type="button">Next</button>',
						autoplay: false,
						autoplaySpeed: 3000,
						centerMode: false,
						centerPadding: '50px',
						cssEase: 'ease',
						customPaging: function (slider, i) {
							return $('<button type="button" />').text(i + 1)
						},
						dots: false,
						dotsClass: 'slick-dots',
						draggable: true,
						easing: 'linear',
						edgeFriction: 0.35,
						fade: false,
						focusOnSelect: false,
						focusOnChange: false,
						infinite: true,
						initialSlide: 0,
						lazyLoad: 'ondemand',
						mobileFirst: false,
						pauseOnHover: true,
						pauseOnFocus: true,
						pauseOnDotsHover: false,
						respondTo: 'window',
						responsive: null,
						rows: 1,
						rtl: false,
						slide: '',
						slidesPerRow: 1,
						slidesToShow: 1,
						slidesToScroll: 1,
						speed: 500,
						swipe: true,
						swipeToSlide: false,
						touchMove: true,
						touchThreshold: 5,
						useCSS: true,
						useTransform: true,
						variableWidth: false,
						vertical: false,
						verticalSwiping: false,
						waitForAnimate: true,
						zIndex: 1000,
					}

					_.initials = {
						animating: false,
						dragging: false,
						autoPlayTimer: null,
						currentDirection: 0,
						currentLeft: null,
						currentSlide: 0,
						direction: 1,
						$dots: null,
						listWidth: null,
						listHeight: null,
						loadIndex: 0,
						$nextArrow: null,
						$prevArrow: null,
						scrolling: false,
						slideCount: null,
						slideWidth: null,
						$slideTrack: null,
						$slides: null,
						sliding: false,
						slideOffset: 0,
						swipeLeft: null,
						swiping: false,
						$list: null,
						touchObject: {},
						transformsEnabled: false,
						unslicked: false,
					}

					$.extend(_, _.initials)

					_.activeBreakpoint = null
					_.animType = null
					_.animProp = null
					_.breakpoints = []
					_.breakpointSettings = []
					_.cssTransitions = false
					_.focussed = false
					_.interrupted = false
					_.hidden = 'hidden'
					_.paused = true
					_.positionProp = null
					_.respondTo = null
					_.rowCount = 1
					_.shouldClick = true
					_.$slider = $(element)
					_.$slidesCache = null
					_.transformType = null
					_.transitionType = null
					_.visibilityChange = 'visibilitychange'
					_.windowWidth = 0
					_.windowTimer = null

					dataSettings = $(element).data('slick') || {}

					_.options = $.extend({}, _.defaults, settings, dataSettings)

					_.currentSlide = _.options.initialSlide

					_.originalSettings = _.options

					if (typeof document.mozHidden !== 'undefined') {
						_.hidden = 'mozHidden'
						_.visibilityChange = 'mozvisibilitychange'
					} else if (typeof document.webkitHidden !== 'undefined') {
						_.hidden = 'webkitHidden'
						_.visibilityChange = 'webkitvisibilitychange'
					}

					_.autoPlay = $.proxy(_.autoPlay, _)
					_.autoPlayClear = $.proxy(_.autoPlayClear, _)
					_.autoPlayIterator = $.proxy(_.autoPlayIterator, _)
					_.changeSlide = $.proxy(_.changeSlide, _)
					_.clickHandler = $.proxy(_.clickHandler, _)
					_.selectHandler = $.proxy(_.selectHandler, _)
					_.setPosition = $.proxy(_.setPosition, _)
					_.swipeHandler = $.proxy(_.swipeHandler, _)
					_.dragHandler = $.proxy(_.dragHandler, _)
					_.keyHandler = $.proxy(_.keyHandler, _)

					_.instanceUid = instanceUid++

					// A simple way to check for HTML strings
					// Strict HTML recognition (must start with <)
					// Extracted from jQuery v1.11 source
					_.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/

					_.registerBreakpoints()
					_.init(true)
				}

				return Slick
			})()

			Slick.prototype.activateADA = function () {
				var _ = this
				if (_.$slideTrack) {
					_.$slideTrack
						.find('.slick-active')
						.attr({
							'aria-hidden': 'false',
						})
						.find('a, input, button, select')
						.attr({
							tabindex: '0',
						})
				}
			}

			Slick.prototype.addSlide = Slick.prototype.slickAdd = function (
				markup,
				index,
				addBefore
			) {
				var _ = 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).detach()

				_.$slideTrack.append(_.$slides)

				_.$slides.each(function (index, element) {
					$(element).attr('data-slick-index', index)
				})

				_.$slidesCache = _.$slides

				_.reinit()
			}

			Slick.prototype.animateHeight = function () {
				var _ = this
				if (
					_.options.slidesToShow === 1 &&
					_.options.adaptiveHeight === true &&
					_.options.vertical === false
				) {
					var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true)
					_.$list.animate(
						{
							height: targetHeight,
						},
						_.options.speed
					)
				}
			}

			Slick.prototype.animateSlide = function (targetLeft, callback) {
				var animProps = {},
					_ = this

				_.animateHeight()

				if (_.options.rtl === true && _.options.vertical === false) {
					targetLeft = -targetLeft
				}
				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) {
						if (_.options.rtl === true) {
							_.currentLeft = -_.currentLeft
						}
						$({
							animStart: _.currentLeft,
						}).animate(
							{
								animStart: targetLeft,
							},
							{
								duration: _.options.speed,
								easing: _.options.easing,
								step: function (now) {
									now = Math.ceil(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: function () {
									if (callback) {
										callback.call()
									}
								},
							}
						)
					} else {
						_.applyTransition()
						targetLeft = Math.ceil(targetLeft)

						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.getNavTarget = function () {
				var _ = this,
					asNavFor = _.options.asNavFor

				if (asNavFor && asNavFor !== null) {
					asNavFor = $(asNavFor).not(_.$slider)
				}

				return asNavFor
			}

			Slick.prototype.asNavFor = function (index) {
				var _ = this,
					asNavFor = _.getNavTarget()

				if (asNavFor !== null && typeof asNavFor === 'object') {
					asNavFor.each(function () {
						var target = $(this).slick('getSlick')
						if (!target.unslicked) {
							target.slideHandler(index, true)
						}
					})
				}
			}

			Slick.prototype.applyTransition = function (slide) {
				var _ = 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 () {
				var _ = this

				_.autoPlayClear()

				if (_.slideCount > _.options.slidesToShow) {
					_.autoPlayTimer = setInterval(
						_.autoPlayIterator,
						_.options.autoplaySpeed
					)
				}
			}

			Slick.prototype.autoPlayClear = function () {
				var _ = this

				if (_.autoPlayTimer) {
					clearInterval(_.autoPlayTimer)
				}
			}

			Slick.prototype.autoPlayIterator = function () {
				var _ = this,
					slideTo = _.currentSlide + _.options.slidesToScroll

				if (!_.paused && !_.interrupted && !_.focussed) {
					if (_.options.infinite === false) {
						if (_.direction === 1 && _.currentSlide + 1 === _.slideCount - 1) {
							_.direction = 0
						} else if (_.direction === 0) {
							slideTo = _.currentSlide - _.options.slidesToScroll

							if (_.currentSlide - 1 === 0) {
								_.direction = 1
							}
						}
					}

					_.slideHandler(slideTo)
				}
			}

			Slick.prototype.buildArrows = function () {
				var _ = this

				if (_.options.arrows === true) {
					_.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow')
					_.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow')

					//THANHNT: add class has-arrow when pagination
					if (!_.$slider.hasClass('has-arrows'))
						_.$slider.addClass('has-arrows')

					if (_.slideCount > _.options.slidesToShow) {
						_.$prevArrow
							.removeClass('slick-hidden')
							.removeAttr('aria-hidden tabindex')
						_.$nextArrow
							.removeClass('slick-hidden')
							.removeAttr('aria-hidden tabindex')

						if (
							_.htmlExpr.test(_.options.nextArrow) &&
							_.htmlExpr.test(_.options.prevArrow)
						) {
							_.options.appendArrows.find('.slick-arrows').remove()
							_.options.appendArrows.append('<div class="slick-arrows "></div>')

							_.options.appendArrows.find('.slick-arrows').prepend(_.$prevArrow)
							_.options.appendArrows.find('.slick-arrows').append(_.$nextArrow)
						}

						if (_.options.infinite !== true) {
							_.$prevArrow
								.addClass('slick-disabled')
								.attr('aria-disabled', 'true')
						}
					} else {
						//THANHNT: remove class has-arrow when no pagination
						if (_.$slider.hasClass('has-arrows'))
							_.$slider.removeClass('has-arrows')

						_.$prevArrow
							.add(_.$nextArrow)

							.addClass('slick-hidden')
							.attr({
								'aria-disabled': 'true',
								tabindex: '-1',
							})
					}
				}
			}

			Slick.prototype.buildDots = function () {
				var _ = this,
					i,
					dot

				if (_.options.dots === true) {
					_.$slider.addClass('slick-dotted')

					dot = $('<ul />').addClass(_.options.dotsClass)

					for (i = 0; i <= _.getDotCount(); i += 1) {
						dot.append(
							$('<li />').append(_.options.customPaging.call(this, _, i))
						)
					}

					_.$dots = dot.appendTo(_.options.appendDots)

					_.$dots.find('li').first().addClass('slick-active')
				}
			}

			Slick.prototype.buildOut = function () {
				var _ = this

				_.$slides = _.$slider
					.children(_.options.slide + ':not(.slick-cloned, .slick-arrows)')
					.addClass('slick-slide')

				_.slideCount = _.$slides.length

				_.$slides.each(function (index, element) {
					$(element)
						.attr('data-slick-index', index)
						.data('originalStyling', $(element).attr('style') || '')
				})

				_.$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.swipeToSlide === true) {
					_.options.slidesToScroll = 1
				}

				$('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading')

				_.setupInfinite()

				_.buildArrows()

				_.buildDots()

				_.updateDots()

				_.setSlideClasses(
					typeof _.currentSlide === 'number' ? _.currentSlide : 0
				)

				if (_.options.draggable === true) {
					_.$list.addClass('draggable')
				}
			}

			Slick.prototype.buildRows = function () {
				var _ = this,
					a,
					b,
					c,
					newSlides,
					numOfSlides,
					originalSlides,
					slidesPerSection

				newSlides = document.createDocumentFragment()
				originalSlides = _.$slider.children()

				if (_.options.rows > 1) {
					slidesPerSection = _.options.slidesPerRow * _.options.rows
					numOfSlides = Math.ceil(originalSlides.length / slidesPerSection)

					for (a = 0; a < numOfSlides; a++) {
						var slide = document.createElement('div')
						for (b = 0; b < _.options.rows; b++) {
							var row = document.createElement('div')
							for (c = 0; c < _.options.slidesPerRow; c++) {
								var target =
									a * slidesPerSection + (b * _.options.slidesPerRow + c)
								if (originalSlides.get(target)) {
									row.appendChild(originalSlides.get(target))
								}
							}
							slide.appendChild(row)
						}
						newSlides.appendChild(slide)
					}

					_.$slider.empty().append(newSlides)
					_.$slider
						.children()
						.children()
						.children()
						.css({
							width: 100 / _.options.slidesPerRow + '%',
							display: 'inline-block',
						})
				}
			}

			Slick.prototype.checkResponsive = function (initial, forceUpdate) {
				var _ = this,
					breakpoint,
					targetBreakpoint,
					respondToWidth,
					triggerBreakpoint = false
				var sliderWidth = _.$slider.width()
				var windowWidth = window.innerWidth || $(window).width()

				if (_.respondTo === 'window') {
					respondToWidth = windowWidth
				} else if (_.respondTo === 'slider') {
					respondToWidth = sliderWidth
				} else if (_.respondTo === 'min') {
					respondToWidth = Math.min(windowWidth, sliderWidth)
				}

				if (
					_.options.responsive &&
					_.options.responsive.length &&
					_.options.responsive !== null
				) {
					targetBreakpoint = null

					for (breakpoint in _.breakpoints) {
						if (_.breakpoints.hasOwnProperty(breakpoint)) {
							if (_.originalSettings.mobileFirst === false) {
								if (respondToWidth < _.breakpoints[breakpoint]) {
									targetBreakpoint = _.breakpoints[breakpoint]
								}
							} else {
								if (respondToWidth > _.breakpoints[breakpoint]) {
									targetBreakpoint = _.breakpoints[breakpoint]
								}
							}
						}
					}

					if (targetBreakpoint !== null) {
						if (_.activeBreakpoint !== null) {
							if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
								_.activeBreakpoint = targetBreakpoint
								if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
									_.unslick(targetBreakpoint)
								} else {
									_.options = $.extend(
										{},
										_.originalSettings,
										_.breakpointSettings[targetBreakpoint]
									)
									if (initial === true) {
										_.currentSlide = _.options.initialSlide
									}
									_.refresh(initial)
								}
								triggerBreakpoint = targetBreakpoint
							}
						} else {
							_.activeBreakpoint = targetBreakpoint
							if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
								_.unslick(targetBreakpoint)
							} else {
								_.options = $.extend(
									{},
									_.originalSettings,
									_.breakpointSettings[targetBreakpoint]
								)
								if (initial === true) {
									_.currentSlide = _.options.initialSlide
								}
								_.refresh(initial)
							}
							triggerBreakpoint = targetBreakpoint
						}
					} else {
						if (_.activeBreakpoint !== null) {
							_.activeBreakpoint = null
							_.options = _.originalSettings
							if (initial === true) {
								_.currentSlide = _.options.initialSlide
							}
							_.refresh(initial)
							triggerBreakpoint = targetBreakpoint
						}
					}

					// only trigger breakpoints during an actual break. not on initialize.
					if (!initial && triggerBreakpoint !== false) {
						_.$slider.trigger('breakpoint', [_, triggerBreakpoint])
					}
				}
			}

			Slick.prototype.changeSlide = function (event, dontAnimate) {
				var _ = this,
					$target = $(event.currentTarget),
					indexOffset,
					slideOffset,
					unevenOffset

				// If target is a link, prevent default action.
				if ($target.is('a')) {
					event.preventDefault()
				}

				// If target is not the <li> element (ie: a child), find the <li>.
				if (!$target.is('li')) {
					$target = $target.closest('li')
				}

				unevenOffset = _.slideCount % _.options.slidesToScroll !== 0
				indexOffset = unevenOffset
					? 0
					: (_.slideCount - _.currentSlide) % _.options.slidesToScroll

				switch (event.data.message) {
					case 'previous':
						slideOffset =
							indexOffset === 0
								? _.options.slidesToScroll
								: _.options.slidesToShow - indexOffset
						if (_.slideCount > _.options.slidesToShow) {
							_.slideHandler(_.currentSlide - slideOffset, false, dontAnimate)
						}
						break

					case 'next':
						slideOffset =
							indexOffset === 0 ? _.options.slidesToScroll : indexOffset
						if (_.slideCount > _.options.slidesToShow) {
							_.slideHandler(_.currentSlide + slideOffset, false, dontAnimate)
						}
						break

					case 'index':
						var index =
							event.data.index === 0
								? 0
								: event.data.index || $target.index() * _.options.slidesToScroll

						_.slideHandler(_.checkNavigable(index), false, dontAnimate)
						$target.children().trigger('focus')
						break

					default:
						return
				}
			}

			Slick.prototype.checkNavigable = function (index) {
				var _ = this,
					navigables,
					prevNavigable

				navigables = _.getNavigableIndexes()
				prevNavigable = 0
				if (index > navigables[navigables.length - 1]) {
					index = navigables[navigables.length - 1]
				} else {
					for (var n in navigables) {
						if (index < navigables[n]) {
							index = prevNavigable
							break
						}
						prevNavigable = navigables[n]
					}
				}

				return index
			}

			Slick.prototype.cleanUpEvents = function () {
				var _ = this

				if (_.options.dots && _.$dots !== null) {
					$('li', _.$dots)
						.off('click.slick', _.changeSlide)
						.off('mouseenter.slick', $.proxy(_.interrupt, _, true))
						.off('mouseleave.slick', $.proxy(_.interrupt, _, false))

					if (_.options.accessibility === true) {
						_.$dots.off('keydown.slick', _.keyHandler)
					}
				}

				_.$slider.off('focus.slick blur.slick')

				if (
					_.options.arrows === true &&
					_.slideCount > _.options.slidesToShow
				) {
					_.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide)
					_.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide)

					if (_.options.accessibility === true) {
						_.$prevArrow && _.$prevArrow.off('keydown.slick', _.keyHandler)
						_.$nextArrow && _.$nextArrow.off('keydown.slick', _.keyHandler)
					}
				}

				_.$list.off('touchstart.slick mousedown.slick', _.swipeHandler)
				_.$list.off('touchmove.slick mousemove.slick', _.swipeHandler)
				_.$list.off('touchend.slick mouseup.slick', _.swipeHandler)
				_.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler)

				_.$list.off('click.slick', _.clickHandler)

				$(document).off(_.visibilityChange, _.visibility)

				_.cleanUpSlideEvents()

				if (_.options.accessibility === true) {
					_.$list.off('keydown.slick', _.keyHandler)
				}

				if (_.options.focusOnSelect === true) {
					$(_.$slideTrack).children().off('click.slick', _.selectHandler)
				}

				$(window).off(
					'orientationchange.slick.slick-' + _.instanceUid,
					_.orientationChange
				)

				$(window).off('resize.slick.slick-' + _.instanceUid, _.resize)

				$('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault)

				$(window).off('load.slick.slick-' + _.instanceUid, _.setPosition)
			}

			Slick.prototype.cleanUpSlideEvents = function () {
				var _ = this

				_.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true))
				_.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false))
			}

			Slick.prototype.cleanUpRows = function () {
				var _ = this,
					originalSlides

				if (_.options.rows > 1) {
					originalSlides = _.$slides.children().children()
					originalSlides.removeAttr('style')
					_.$slider.empty().append(originalSlides)
				}
			}

			Slick.prototype.clickHandler = function (event) {
				var _ = this

				if (_.shouldClick === false) {
					event.stopImmediatePropagation()
					event.stopPropagation()
					event.preventDefault()
				}
			}

			Slick.prototype.destroy = function (refresh) {
				var _ = this

				_.autoPlayClear()

				_.touchObject = {}

				_.cleanUpEvents()

				$('.slick-cloned', _.$slider).detach()

				if (_.$dots) {
					_.$dots.remove()
				}

				if (_.$prevArrow && _.$prevArrow.length) {
					_.$prevArrow
						.removeClass('slick-disabled slick-arrow slick-hidden')
						.removeAttr('aria-hidden aria-disabled tabindex')
						.css('display', '')

					if (_.htmlExpr.test(_.options.prevArrow)) {
						_.$prevArrow.remove()
					}
				}

				if (_.$nextArrow && _.$nextArrow.length) {
					_.$nextArrow
						.removeClass('slick-disabled slick-arrow slick-hidden')
						.removeAttr('aria-hidden aria-disabled tabindex')
						.css('display', '')

					if (_.htmlExpr.test(_.options.nextArrow)) {
						_.$nextArrow.remove()
					}
				}

				if (_.$slides) {
					_.$slides
						.removeClass(
							'slick-slide slick-active slick-center slick-visible slick-current'
						)
						.removeAttr('aria-hidden')
						.removeAttr('data-slick-index')
						.each(function () {
							$(this).attr('style', $(this).data('originalStyling'))
						})

					_.$slideTrack.children(this.options.slide).detach()

					_.$slideTrack.detach()

					_.$list.detach()

					_.$slider.append(_.$slides)
				}

				_.cleanUpRows()

				_.$slider.removeClass('slick-slider')
				_.$slider.removeClass('slick-initialized')
				_.$slider.removeClass('slick-dotted')

				_.unslicked = true

				if (!refresh) {
					_.$slider.trigger('destroy', [_])
				}
			}

			Slick.prototype.disableTransition = function (slide) {
				var _ = this,
					transition = {}

				transition[_.transitionType] = ''

				if (_.options.fade === false) {
					_.$slideTrack.css(transition)
				} else {
					_.$slides.eq(slide).css(transition)
				}
			}

			Slick.prototype.fadeSlide = function (slideIndex, callback) {
				var _ = this

				if (_.cssTransitions === false) {
					_.$slides.eq(slideIndex).css({
						zIndex: _.options.zIndex,
					})

					_.$slides.eq(slideIndex).animate(
						{
							opacity: 1,
						},
						_.options.speed,
						_.options.easing,
						callback
					)
				} else {
					_.applyTransition(slideIndex)

					_.$slides.eq(slideIndex).css({
						opacity: 1,
						zIndex: _.options.zIndex,
					})

					if (callback) {
						setTimeout(function () {
							_.disableTransition(slideIndex)

							callback.call()
						}, _.options.speed)
					}
				}
			}

			Slick.prototype.fadeSlideOut = function (slideIndex) {
				var _ = this

				if (_.cssTransitions === false) {
					_.$slides.eq(slideIndex).animate(
						{
							opacity: 0,
							zIndex: _.options.zIndex - 2,
						},
						_.options.speed,
						_.options.easing
					)
				} else {
					_.applyTransition(slideIndex)

					_.$slides.eq(slideIndex).css({
						opacity: 0,
						zIndex: _.options.zIndex - 2,
					})
				}
			}

			Slick.prototype.filterSlides = Slick.prototype.slickFilter = function (
				filter
			) {
				var _ = this

				if (filter !== null) {
					_.$slidesCache = _.$slides

					_.unload()

					_.$slideTrack.children(this.options.slide).detach()

					_.$slidesCache.filter(filter).appendTo(_.$slideTrack)

					_.reinit()
				}
			}

			Slick.prototype.focusHandler = function () {
				var _ = this

				_.$slider
					.off('focus.slick blur.slick')
					.on('focus.slick blur.slick', '*', function (event) {
						event.stopImmediatePropagation()
						var $sf = $(this)

						setTimeout(function () {
							if (_.options.pauseOnFocus) {
								_.focussed = $sf.is(':focus')
								_.autoPlay()
							}
						}, 0)
					})
			}

			Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide =
				function () {
					var _ = this
					return _.currentSlide
				}

			Slick.prototype.getDotCount = function () {
				var _ = this

				var breakPoint = 0
				var counter = 0
				var pagerQty = 0

				if (_.options.infinite === true) {
					if (_.slideCount <= _.options.slidesToShow) {
						++pagerQty
					} else {
						while (breakPoint < _.slideCount) {
							++pagerQty
							breakPoint = counter + _.options.slidesToScroll
							counter +=
								_.options.slidesToScroll <= _.options.slidesToShow
									? _.options.slidesToScroll
									: _.options.slidesToShow
						}
					}
				} else if (_.options.centerMode === true) {
					pagerQty = _.slideCount
				} else if (!_.options.asNavFor) {
					pagerQty =
						1 +
						Math.ceil(
							(_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll
						)
				} else {
					while (breakPoint < _.slideCount) {
						++pagerQty
						breakPoint = counter + _.options.slidesToScroll
						counter +=
							_.options.slidesToScroll <= _.options.slidesToShow
								? _.options.slidesToScroll
								: _.options.slidesToShow
					}
				}

				return pagerQty - 1
			}

			Slick.prototype.getLeft = function (slideIndex) {
				var _ = this,
					targetLeft,
					verticalHeight,
					verticalOffset = 0,
					targetSlide,
					coef

				_.slideOffset = 0
				verticalHeight = _.$slides.first().outerHeight(true)

				if (_.options.infinite === true) {
					if (_.slideCount > _.options.slidesToShow) {
						_.slideOffset = _.slideWidth * _.options.slidesToShow * -1
						coef = -1

						if (_.options.vertical === true && _.options.centerMode === true) {
							if (_.options.slidesToShow === 2) {
								coef = -1.5
							} else if (_.options.slidesToShow === 1) {
								coef = -2
							}
						}
						verticalOffset = verticalHeight * _.options.slidesToShow * coef
					}
					if (_.slideCount % _.options.slidesToScroll !== 0) {
						if (
							slideIndex + _.options.slidesToScroll > _.slideCount &&
							_.slideCount > _.options.slidesToShow
						) {
							if (slideIndex > _.slideCount) {
								_.slideOffset =
									(_.options.slidesToShow - (slideIndex - _.slideCount)) *
									_.slideWidth *
									-1
								verticalOffset =
									(_.options.slidesToShow - (slideIndex - _.slideCount)) *
									verticalHeight *
									-1
							} else {
								_.slideOffset =
									(_.slideCount % _.options.slidesToScroll) * _.slideWidth * -1
								verticalOffset =
									(_.slideCount % _.options.slidesToScroll) *
									verticalHeight *
									-1
							}
						}
					}
				} else {
					if (slideIndex + _.options.slidesToShow > _.slideCount) {
						_.slideOffset =
							(slideIndex + _.options.slidesToShow - _.slideCount) *
							_.slideWidth
						verticalOffset =
							(slideIndex + _.options.slidesToShow - _.slideCount) *
							verticalHeight
					}
				}

				if (_.slideCount <= _.options.slidesToShow) {
					_.slideOffset = 0
					verticalOffset = 0
				}

				if (
					_.options.centerMode === true &&
					_.slideCount <= _.options.slidesToShow
				) {
					_.slideOffset =
						(_.slideWidth * Math.floor(_.options.slidesToShow)) / 2 -
						(_.slideWidth * _.slideCount) / 2
				} else if (
					_.options.centerMode === true &&
					_.options.infinite === true
				) {
					_.slideOffset +=
						_.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth
				} else if (_.options.centerMode === true) {
					_.slideOffset = 0
					_.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2)
				}

				if (_.options.vertical === false) {
					targetLeft = slideIndex * _.slideWidth * -1 + _.slideOffset
				} else {
					targetLeft = slideIndex * verticalHeight * -1 + verticalOffset
				}

				if (_.options.variableWidth === true) {
					if (
						_.slideCount <= _.options.slidesToShow ||
						_.options.infinite === false
					) {
						targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex)
					} else {
						targetSlide = _.$slideTrack
							.children('.slick-slide')
							.eq(slideIndex + _.options.slidesToShow)
					}

					if (_.options.rtl === true) {
						if (targetSlide[0]) {
							targetLeft =
								(_.$slideTrack.width() -
									targetSlide[0].offsetLeft -
									targetSlide.width()) *
								-1
						} else {
							targetLeft = 0
						}
					} else {
						targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0
					}

					if (_.options.centerMode === true) {
						if (
							_.slideCount <= _.options.slidesToShow ||
							_.options.infinite === false
						) {
							targetSlide = _.$slideTrack
								.children('.slick-slide')
								.eq(slideIndex)
						} else {
							targetSlide = _.$slideTrack
								.children('.slick-slide')
								.eq(slideIndex + _.options.slidesToShow + 1)
						}

						if (_.options.rtl === true) {
							if (targetSlide[0]) {
								targetLeft =
									(_.$slideTrack.width() -
										targetSlide[0].offsetLeft -
										targetSlide.width()) *
									-1
							} else {
								targetLeft = 0
							}
						} else {
							targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0
						}

						targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2
					}
				}

				return targetLeft
			}

			Slick.prototype.getOption = Slick.prototype.slickGetOption = function (
				option
			) {
				var _ = this

				return _.options[option]
			}

			Slick.prototype.getNavigableIndexes = function () {
				var _ = this,
					breakPoint = 0,
					counter = 0,
					indexes = [],
					max

				if (_.options.infinite === false) {
					max = _.slideCount
				} else {
					breakPoint = _.options.slidesToScroll * -1
					counter = _.options.slidesToScroll * -1
					max = _.slideCount * 2
				}

				while (breakPoint < max) {
					indexes.push(breakPoint)
					breakPoint = counter + _.options.slidesToScroll
					counter +=
						_.options.slidesToScroll <= _.options.slidesToShow
							? _.options.slidesToScroll
							: _.options.slidesToShow
				}

				return indexes
			}

			Slick.prototype.getSlick = function () {
				return this
			}

			Slick.prototype.getSlideCount = function () {
				var _ = this,
					slidesTraversed,
					swipedSlide,
					centerOffset

				centerOffset =
					_.options.centerMode === true
						? _.slideWidth * Math.floor(_.options.slidesToShow / 2)
						: 0

				if (_.options.swipeToSlide === true) {
					_.$slideTrack.find('.slick-slide').each(function (index, slide) {
						if (
							slide.offsetLeft - centerOffset + $(slide).outerWidth() / 2 >
							_.swipeLeft * -1
						) {
							swipedSlide = slide
							return false
						}
					})

					slidesTraversed =
						Math.abs(
							$(swipedSlide).attr('data-slick-index') - _.currentSlide
						) || 1

					return slidesTraversed
				} else {
					return _.options.slidesToScroll
				}
			}

			Slick.prototype.goTo = Slick.prototype.slickGoTo = function (
				slide,
				dontAnimate
			) {
				var _ = this

				_.changeSlide(
					{
						data: {
							message: 'index',
							index: parseInt(slide),
						},
					},
					dontAnimate
				)
			}

			Slick.prototype.init = function (creation) {
				var _ = this

				if (!$(_.$slider).hasClass('slick-initialized')) {
					$(_.$slider).addClass('slick-initialized')

					_.buildRows()
					_.buildOut()
					_.setProps()
					_.startLoad()
					_.loadSlider()
					_.initializeEvents()
					_.updateArrows()
					_.updateDots()
					_.checkResponsive(true)
					_.focusHandler()
				}

				if (creation) {
					_.$slider.trigger('init', [_])
				}

				if (_.options.accessibility === true) {
					_.initADA()
				}

				if (_.options.autoplay) {
					_.paused = false
					_.autoPlay()
				}
			}

			Slick.prototype.initADA = function () {
				var _ = this,
					numDotGroups = Math.ceil(_.slideCount / _.options.slidesToShow),
					tabControlIndexes = _.getNavigableIndexes().filter(function (val) {
						return val >= 0 && val < _.slideCount
					})

				if (_.$slides) {
					_.$slides
						.add(_.$slideTrack.find('.slick-cloned'))
						.attr({
							'aria-hidden': 'true',
							tabindex: '-1',
						})
						.find('a, input, button, select')
						.attr({
							tabindex: '-1',
						})
				}

				if (_.$dots !== null) {
					_.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function (i) {
						var slideControlIndex = tabControlIndexes.indexOf(i)

						$(this).attr({
							role: 'tabpanel',
							id: 'slick-slide' + _.instanceUid + i,
							tabindex: -1,
						})

						if (slideControlIndex !== -1) {
							$(this).attr({
								'aria-describedby':
									'slick-slide-control' + _.instanceUid + slideControlIndex,
							})
						}
					})

					_.$dots
						.attr('role', 'tablist')
						.find('li')
						.each(function (i) {
							var mappedSlideIndex = tabControlIndexes[i]

							$(this).attr({
								role: 'presentation',
							})

							$(this)
								.find('button')
								.first()
								.attr({
									role: 'tab',
									id: 'slick-slide-control' + _.instanceUid + i,
									'aria-controls':
										'slick-slide' + _.instanceUid + mappedSlideIndex,
									'aria-label': i + 1 + ' of ' + numDotGroups,
									'aria-selected': null,
									tabindex: '-1',
								})
						})
						.eq(_.currentSlide)
						.find('button')
						.attr({
							'aria-selected': 'true',
							tabindex: '0',
						})
						.end()
				}
				if (_.$slides) {
					for (
						var i = _.currentSlide, max = i + _.options.slidesToShow;
						i < max;
						i++
					) {
						_.$slides.eq(i).attr('tabindex', 0)
					}
				}
				_.activateADA()
			}

			Slick.prototype.initArrowEvents = function () {
				var _ = this

				if (
					_.options.arrows === true &&
					_.slideCount > _.options.slidesToShow
				) {
					_.$prevArrow.off('click.slick').on(
						'click.slick',
						{
							message: 'previous',
						},
						_.changeSlide
					)
					_.$nextArrow.off('click.slick').on(
						'click.slick',
						{
							message: 'next',
						},
						_.changeSlide
					)

					if (_.options.accessibility === true) {
						_.$prevArrow.on('keydown.slick', _.keyHandler)
						_.$nextArrow.on('keydown.slick', _.keyHandler)
					}
				}
			}

			Slick.prototype.initDotEvents = function () {
				var _ = this

				if (_.options.dots === true) {
					$('li', _.$dots).on(
						'click.slick',
						{
							message: 'index',
						},
						_.changeSlide
					)

					if (_.options.accessibility === true) {
						_.$dots.on('keydown.slick', _.keyHandler)
					}
				}

				if (_.options.dots === true && _.options.pauseOnDotsHover === true) {
					$('li', _.$dots)
						.on('mouseenter.slick', $.proxy(_.interrupt, _, true))
						.on('mouseleave.slick', $.proxy(_.interrupt, _, false))
				}
			}

			Slick.prototype.initSlideEvents = function () {
				var _ = this

				if (_.options.pauseOnHover) {
					_.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true))
					_.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false))
				}
			}

			Slick.prototype.initializeEvents = function () {
				var _ = this

				_.initArrowEvents()

				_.initDotEvents()
				_.initSlideEvents()

				_.$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
				)

				_.$list.on('click.slick', _.clickHandler)

				$(document).on(_.visibilityChange, $.proxy(_.visibility, _))

				if (_.options.accessibility === true) {
					_.$list.on('keydown.slick', _.keyHandler)
				}

				if (_.options.focusOnSelect === true) {
					$(_.$slideTrack).children().on('click.slick', _.selectHandler)
				}

				$(window).on(
					'orientationchange.slick.slick-' + _.instanceUid,
					$.proxy(_.orientationChange, _)
				)

				$(window).on(
					'resize.slick.slick-' + _.instanceUid,
					$.proxy(_.resize, _)
				)

				$('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault)

				$(window).on('load.slick.slick-' + _.instanceUid, _.setPosition)
				$(_.setPosition)
			}

			Slick.prototype.initUI = function () {
				var _ = this

				if (
					_.options.arrows === true &&
					_.slideCount > _.options.slidesToShow
				) {
					_.$prevArrow.show()
					_.$nextArrow.show()
				}

				if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
					_.$dots.show()
				}
			}

			Slick.prototype.keyHandler = function (event) {
				var _ = this
				//Dont slide if the cursor is inside the form fields and arrow keys are pressed
				if (!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
					if (event.keyCode === 37 && _.options.accessibility === true) {
						_.changeSlide({
							data: {
								message: _.options.rtl === true ? 'next' : 'previous',
							},
						})
					} else if (event.keyCode === 39 && _.options.accessibility === true) {
						_.changeSlide({
							data: {
								message: _.options.rtl === true ? 'previous' : 'next',
							},
						})
					}
				}
			}

			Slick.prototype.lazyLoad = function () {
				var _ = this,
					loadRange,
					cloneRange,
					rangeStart,
					rangeEnd

				function loadImages(imagesScope) {
					$('img[data-lazy]', imagesScope).each(function () {
						var image = $(this),
							imageSource = $(this).attr('data-lazy'),
							imageSrcSet = $(this).attr('data-srcset'),
							imageSizes =
								$(this).attr('data-sizes') || _.$slider.attr('data-sizes'),
							imageToLoad = document.createElement('img')

						imageToLoad.onload = function () {
							image.animate(
								{
									opacity: 0,
								},
								100,
								function () {
									if (imageSrcSet) {
										image.attr('srcset', imageSrcSet)

										if (imageSizes) {
											image.attr('sizes', imageSizes)
										}
									}

									image.attr('src', imageSource).animate(
										{
											opacity: 1,
										},
										200,
										function () {
											image
												.removeAttr('data-lazy data-srcset data-sizes')
												.removeClass('slick-loading')
										}
									)
									_.$slider.trigger('lazyLoaded', [_, image, imageSource])
								}
							)
						}

						imageToLoad.onerror = function () {
							image
								.removeAttr('data-lazy')
								.removeClass('slick-loading')
								.addClass('slick-lazyload-error')

							_.$slider.trigger('lazyLoadError', [_, image, imageSource])
						}

						imageToLoad.src = imageSource
					})
				}

				if (_.options.centerMode === true) {
					if (_.options.infinite === true) {
						rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1)
						rangeEnd = rangeStart + _.options.slidesToShow + 2
					} else {
						rangeStart = Math.max(
							0,
							_.currentSlide - (_.options.slidesToShow / 2 + 1)
						)
						rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide
					}
				} else {
					rangeStart = _.options.infinite
						? _.options.slidesToShow + _.currentSlide
						: _.currentSlide
					rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow)
					if (_.options.fade === true) {
						if (rangeStart > 0) rangeStart--
						if (rangeEnd <= _.slideCount) rangeEnd++
					}
				}

				loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd)

				if (_.options.lazyLoad === 'anticipated') {
					var prevSlide = rangeStart - 1,
						nextSlide = rangeEnd,
						$slides = _.$slider.find('.slick-slide')

					for (var i = 0; i < _.options.slidesToScroll; i++) {
						if (prevSlide < 0) prevSlide = _.slideCount - 1
						loadRange = loadRange.add($slides.eq(prevSlide))
						loadRange = loadRange.add($slides.eq(nextSlide))
						prevSlide--
						nextSlide++
					}
				}

				loadImages(loadRange)

				if (_.slideCount <= _.options.slidesToShow) {
					cloneRange = _.$slider.find('.slick-slide')
					loadImages(cloneRange)
				} else if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
					cloneRange = _.$slider
						.find('.slick-cloned')
						.slice(0, _.options.slidesToShow)
					loadImages(cloneRange)
				} else if (_.currentSlide === 0) {
					cloneRange = _.$slider
						.find('.slick-cloned')
						.slice(_.options.slidesToShow * -1)
					loadImages(cloneRange)
				}
			}

			Slick.prototype.loadSlider = function () {
				var _ = this

				_.setPosition()

				_.$slideTrack.css({
					opacity: 1,
				})

				_.$slider.removeClass('slick-loading')

				_.initUI()

				if (_.options.lazyLoad === 'progressive') {
					_.progressiveLazyLoad()
				}
			}

			Slick.prototype.next = Slick.prototype.slickNext = function () {
				var _ = this

				_.changeSlide({
					data: {
						message: 'next',
					},
				})
			}

			Slick.prototype.orientationChange = function () {
				var _ = this

				_.checkResponsive()
				_.setPosition()
			}

			Slick.prototype.pause = Slick.prototype.slickPause = function () {
				var _ = this

				_.autoPlayClear()
				_.paused = true
			}

			Slick.prototype.play = Slick.prototype.slickPlay = function () {
				var _ = this

				_.autoPlay()
				_.options.autoplay = true
				_.paused = false
				_.focussed = false
				_.interrupted = false
			}

			Slick.prototype.postSlide = function (index) {
				var _ = this

				if (!_.unslicked) {
					_.$slider.trigger('afterChange', [_, index])

					_.animating = false

					if (_.slideCount > _.options.slidesToShow) {
						_.setPosition()
					}

					_.swipeLeft = null

					if (_.options.autoplay) {
						_.autoPlay()
					}

					if (_.options.accessibility === true) {
						_.initADA()

						if (_.options.focusOnChange) {
							var $currentSlide = $(_.$slides.get(_.currentSlide))
							$currentSlide.attr('tabindex', 0).focus()
						}
					}
				}
			}

			Slick.prototype.prev = Slick.prototype.slickPrev = function () {
				var _ = this

				_.changeSlide({
					data: {
						message: 'previous',
					},
				})
			}

			Slick.prototype.preventDefault = function (event) {
				event.preventDefault()
			}

			Slick.prototype.progressiveLazyLoad = function (tryCount) {
				tryCount = tryCount || 1

				var _ = this,
					$imgsToLoad = $('img[data-lazy]', _.$slider),
					image,
					imageSource,
					imageSrcSet,
					imageSizes,
					imageToLoad

				if ($imgsToLoad.length) {
					image = $imgsToLoad.first()
					imageSource = image.attr('data-lazy')
					imageSrcSet = image.attr('data-srcset')
					imageSizes = image.attr('data-sizes') || _.$slider.attr('data-sizes')
					imageToLoad = document.createElement('img')

					imageToLoad.onload = function () {
						if (imageSrcSet) {
							image.attr('srcset', imageSrcSet)

							if (imageSizes) {
								image.attr('sizes', imageSizes)
							}
						}

						image
							.attr('src', imageSource)
							.removeAttr('data-lazy data-srcset data-sizes')
							.removeClass('slick-loading')

						if (_.options.adaptiveHeight === true) {
							_.setPosition()
						}

						_.$slider.trigger('lazyLoaded', [_, image, imageSource])
						_.progressiveLazyLoad()
					}

					imageToLoad.onerror = function () {
						if (tryCount < 3) {
							/**
							 * try to load the image 3 times,
							 * leave a slight delay so we don't get
							 * servers blocking the request.
							 */
							setTimeout(function () {
								_.progressiveLazyLoad(tryCount + 1)
							}, 500)
						} else {
							image
								.removeAttr('data-lazy')
								.removeClass('slick-loading')
								.addClass('slick-lazyload-error')

							_.$slider.trigger('lazyLoadError', [_, image, imageSource])

							_.progressiveLazyLoad()
						}
					}

					imageToLoad.src = imageSource
				} else {
					_.$slider.trigger('allImagesLoaded', [_])
				}
			}

			Slick.prototype.refresh = function (initializing) {
				var _ = this,
					currentSlide,
					lastVisibleIndex

				lastVisibleIndex = _.slideCount - _.options.slidesToShow

				// in non-infinite sliders, we don't want to go past the
				// last visible index.
				if (!_.options.infinite && _.currentSlide > lastVisibleIndex) {
					_.currentSlide = lastVisibleIndex
				}

				// if less slides than to show, go to start.
				if (_.slideCount <= _.options.slidesToShow) {
					_.currentSlide = 0
				}

				currentSlide = _.currentSlide

				_.destroy(true)

				$.extend(_, _.initials, {
					currentSlide: currentSlide,
				})

				_.init()

				if (!initializing) {
					_.changeSlide(
						{
							data: {
								message: 'index',
								index: currentSlide,
							},
						},
						false
					)
				}
			}

			Slick.prototype.registerBreakpoints = function () {
				var _ = this,
					breakpoint,
					currentBreakpoint,
					l,
					responsiveSettings = _.options.responsive || null

				if (
					$.type(responsiveSettings) === 'array' &&
					responsiveSettings.length
				) {
					_.respondTo = _.options.respondTo || 'window'

					for (breakpoint in responsiveSettings) {
						l = _.breakpoints.length - 1

						if (responsiveSettings.hasOwnProperty(breakpoint)) {
							currentBreakpoint = responsiveSettings[breakpoint].breakpoint

							// loop through the breakpoints and cut out any existing
							// ones with the same breakpoint number, we don't want dupes.
							while (l >= 0) {
								if (
									_.breakpoints[l] &&
									_.breakpoints[l] === currentBreakpoint
								) {
									_.breakpoints.splice(l, 1)
								}
								l--
							}

							_.breakpoints.push(currentBreakpoint)
							_.breakpointSettings[currentBreakpoint] =
								responsiveSettings[breakpoint].settings
						}
					}

					_.breakpoints.sort(function (a, b) {
						return _.options.mobileFirst ? a - b : b - a
					})
				}
			}

			Slick.prototype.reinit = function () {
				var _ = this

				_.$slides = _.$slideTrack
					.children(_.options.slide)
					.addClass('slick-slide')

				_.slideCount = _.$slides.length

				if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
					_.currentSlide = _.currentSlide - _.options.slidesToScroll
				}

				if (_.slideCount <= _.options.slidesToShow) {
					_.currentSlide = 0
				}

				_.registerBreakpoints()

				_.setProps()
				_.setupInfinite()
				_.buildArrows()
				_.updateArrows()
				_.initArrowEvents()
				_.buildDots()
				_.updateDots()
				_.initDotEvents()
				_.cleanUpSlideEvents()
				_.initSlideEvents()

				_.checkResponsive(false, true)

				if (_.options.focusOnSelect === true) {
					$(_.$slideTrack).children().on('click.slick', _.selectHandler)
				}

				_.setSlideClasses(
					typeof _.currentSlide === 'number' ? _.currentSlide : 0
				)

				_.setPosition()
				_.focusHandler()

				_.paused = !_.options.autoplay
				_.autoPlay()

				_.$slider.trigger('reInit', [_])
			}

			Slick.prototype.resize = function () {
				var _ = this

				if ($(window).width() !== _.windowWidth) {
					clearTimeout(_.windowDelay)
					_.windowDelay = window.setTimeout(function () {
						_.windowWidth = $(window).width()
						_.checkResponsive()
						if (!_.unslicked) {
							_.setPosition()
						}
					}, 50)
				}
			}

			Slick.prototype.removeSlide = Slick.prototype.slickRemove = function (
				index,
				removeBefore,
				removeAll
			) {
				var _ = 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()

				if (removeAll === true) {
					_.$slideTrack.children().remove()
				} else {
					_.$slideTrack.children(this.options.slide).eq(index).remove()
				}

				_.$slides = _.$slideTrack.children(this.options.slide)

				_.$slideTrack.children(this.options.slide).detach()

				_.$slideTrack.append(_.$slides)

				_.$slidesCache = _.$slides

				_.reinit()
			}

			Slick.prototype.setCSS = function (position) {
				var _ = this,
					positionProps = {},
					x,
					y

				if (_.options.rtl === true) {
					position = -position
				}
				x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px'
				y = _.positionProp == 'top' ? Math.ceil(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 () {
				var _ = this

				if (_.options.vertical === false) {
					if (_.options.centerMode === true) {
						_.$list.css({
							padding: '0px ' + _.options.centerPadding,
						})
					}
				} else {
					// THANHNT fix height at decimal value
					_.$list.height(
						parseInt(
							_.$slides.first()[0].getBoundingClientRect().height *
								_.options.slidesToShow
						)
					)
					// _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);

					if (_.options.centerMode === true) {
						_.$list.css({
							padding: _.options.centerPadding + ' 0px',
						})
					}
				}

				_.listWidth = _.$list.width()
				_.listHeight = _.$list.height()

				if (_.options.vertical === false && _.options.variableWidth === false) {
					//THANHNT fix width at decimal value
					// _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
					_.slideWidth =
						Math.ceil((_.listWidth / _.options.slidesToShow) * 100) / 100
					_.$slideTrack.width(
						Math.ceil(
							_.slideWidth * _.$slideTrack.children('.slick-slide').length
						)
					)
				} else if (_.options.variableWidth === true) {
					_.$slideTrack.width(5000 * _.slideCount)
				} else {
					_.slideWidth = Math.ceil(_.listWidth)
					_.$slideTrack.height(
						Math.ceil(
							_.$slides.first().outerHeight(true) *
								_.$slideTrack.children('.slick-slide').length
						)
					)
				}

				var offset =
					_.$slides.first().outerWidth(true) - _.$slides.first().width()
				if (_.options.variableWidth === false)
					_.$slideTrack.children('.slick-slide').width(_.slideWidth - offset)
			}

			Slick.prototype.setFade = function () {
				var _ = this,
					targetLeft

				_.$slides.each(function (index, element) {
					targetLeft = _.slideWidth * index * -1
					if (_.options.rtl === true) {
						$(element).css({
							position: 'relative',
							right: targetLeft,
							top: 0,
							zIndex: _.options.zIndex - 2,
							opacity: 0,
						})
					} else {
						$(element).css({
							position: 'relative',
							left: targetLeft,
							top: 0,
							zIndex: _.options.zIndex - 2,
							opacity: 0,
						})
					}
				})

				_.$slides.eq(_.currentSlide).css({
					zIndex: _.options.zIndex - 1,
					opacity: 1,
				})
			}

			Slick.prototype.setHeight = function () {
				var _ = this

				if (
					_.options.slidesToShow === 1 &&
					_.options.adaptiveHeight === true &&
					_.options.vertical === false
				) {
					var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true)
					_.$list.css('height', targetHeight)
				}
			}

			Slick.prototype.setOption = Slick.prototype.slickSetOption = function () {
				/**
				 * accepts arguments in format of:
				 *
				 *  - for changing a single option's value:
				 *     .slick("setOption", option, value, refresh )
				 *
				 *  - for changing a set of responsive options:
				 *     .slick("setOption", 'responsive', [{}, ...], refresh )
				 *
				 *  - for updating multiple values at once (not responsive)
				 *     .slick("setOption", { 'option': value, ... }, refresh )
				 */

				var _ = this,
					l,
					item,
					option,
					value,
					refresh = false,
					type

				if ($.type(arguments[0]) === 'object') {
					option = arguments[0]
					refresh = arguments[1]
					type = 'multiple'
				} else if ($.type(arguments[0]) === 'string') {
					option = arguments[0]
					value = arguments[1]
					refresh = arguments[2]

					if (
						arguments[0] === 'responsive' &&
						$.type(arguments[1]) === 'array'
					) {
						type = 'responsive'
					} else if (typeof arguments[1] !== 'undefined') {
						type = 'single'
					}
				}

				if (type === 'single') {
					_.options[option] = value
				} else if (type === 'multiple') {
					$.each(option, function (opt, val) {
						_.options[opt] = val
					})
				} else if (type === 'responsive') {
					for (item in value) {
						if ($.type(_.options.responsive) !== 'array') {
							_.options.responsive = [value[item]]
						} else {
							l = _.options.responsive.length - 1

							// loop through the responsive object and splice out duplicates.
							while (l >= 0) {
								if (
									_.options.responsive[l].breakpoint === value[item].breakpoint
								) {
									_.options.responsive.splice(l, 1)
								}

								l--
							}

							_.options.responsive.push(value[item])
						}
					}
				}

				if (refresh) {
					_.unload()
					_.reinit()
				}
			}

			Slick.prototype.setPosition = function () {
				var _ = this

				_.setDimensions()

				_.setHeight()

				if (_.options.fade === false) {
					_.setCSS(_.getLeft(_.currentSlide))
				} else {
					_.setFade()
				}

				_.$slider.trigger('setPosition', [_])
			}

			Slick.prototype.setProps = function () {
				var _ = this,
					bodyStyle = document.body.style

				_.positionProp = _.options.vertical === true ? 'top' : 'left'

				if (_.positionProp === 'top') {
					_.$slider.addClass('slick-vertical')
				} else {
					_.$slider.removeClass('slick-vertical')
				}

				if (
					bodyStyle.WebkitTransition !== undefined ||
					bodyStyle.MozTransition !== undefined ||
					bodyStyle.msTransition !== undefined
				) {
					if (_.options.useCSS === true) {
						_.cssTransitions = true
					}
				}

				if (_.options.fade) {
					if (typeof _.options.zIndex === 'number') {
						if (_.options.zIndex < 3) {
							_.options.zIndex = 3
						}
					} else {
						_.options.zIndex = _.defaults.zIndex
					}
				}

				if (bodyStyle.OTransform !== undefined) {
					_.animType = 'OTransform'
					_.transformType = '-o-transform'
					_.transitionType = 'OTransition'
					if (
						bodyStyle.perspectiveProperty === undefined &&
						bodyStyle.webkitPerspective === undefined
					)
						_.animType = false
				}
				if (bodyStyle.MozTransform !== undefined) {
					_.animType = 'MozTransform'
					_.transformType = '-moz-transform'
					_.transitionType = 'MozTransition'
					if (
						bodyStyle.perspectiveProperty === undefined &&
						bodyStyle.MozPerspective === undefined
					)
						_.animType = false
				}
				if (bodyStyle.webkitTransform !== undefined) {
					_.animType = 'webkitTransform'
					_.transformType = '-webkit-transform'
					_.transitionType = 'webkitTransition'
					if (
						bodyStyle.perspectiveProperty === undefined &&
						bodyStyle.webkitPerspective === undefined
					)
						_.animType = false
				}
				if (bodyStyle.msTransform !== undefined) {
					_.animType = 'msTransform'
					_.transformType = '-ms-transform'
					_.transitionType = 'msTransition'
					if (bodyStyle.msTransform === undefined) _.animType = false
				}
				if (bodyStyle.transform !== undefined && _.animType !== false) {
					_.animType = 'transform'
					_.transformType = 'transform'
					_.transitionType = 'transition'
				}
				_.transformsEnabled =
					_.options.useTransform && _.animType !== null && _.animType !== false
			}

			Slick.prototype.setSlideClasses = function (index) {
				var _ = this,
					centerOffset,
					allSlides,
					indexOffset,
					remainder

				allSlides = _.$slider
					.find('.slick-slide')
					.removeClass('slick-active slick-center slick-current')
					.attr('aria-hidden', 'true')

				_.$slides.eq(index).addClass('slick-current')

				if (_.options.centerMode === true) {
					var evenCoef = _.options.slidesToShow % 2 === 0 ? 1 : 0

					centerOffset = Math.floor(_.options.slidesToShow / 2)

					if (_.options.infinite === true) {
						if (
							index >= centerOffset &&
							index <= _.slideCount - 1 - centerOffset
						) {
							_.$slides
								.slice(
									index - centerOffset + evenCoef,
									index + centerOffset + 1
								)
								.addClass('slick-active')
								.attr('aria-hidden', 'false')
						} else {
							indexOffset = _.options.slidesToShow + index
							allSlides
								.slice(
									indexOffset - centerOffset + 1 + evenCoef,
									indexOffset + centerOffset + 2
								)
								.addClass('slick-active')
								.attr('aria-hidden', 'false')
						}

						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')
							.attr('aria-hidden', 'false')
					} else if (allSlides.length <= _.options.slidesToShow) {
						allSlides.addClass('slick-active').attr('aria-hidden', 'false')
					} else {
						remainder = _.slideCount % _.options.slidesToShow
						indexOffset =
							_.options.infinite === true
								? _.options.slidesToShow + index
								: index

						if (
							_.options.slidesToShow == _.options.slidesToScroll &&
							_.slideCount - index < _.options.slidesToShow
						) {
							allSlides
								.slice(
									indexOffset - (_.options.slidesToShow - remainder),
									indexOffset + remainder
								)
								.addClass('slick-active')
								.attr('aria-hidden', 'false')
						} else {
							allSlides
								.slice(indexOffset, indexOffset + _.options.slidesToShow)
								.addClass('slick-active')
								.attr('aria-hidden', 'false')
						}
					}
				}

				if (
					_.options.lazyLoad === 'ondemand' ||
					_.options.lazyLoad === 'anticipated'
				) {
					_.lazyLoad()
				}
			}

			Slick.prototype.setupInfinite = function () {
				var _ = this,
					i,
					slideIndex,
					infiniteCount

				if (_.options.fade === 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(true)
								.attr('id', '')
								.attr('data-slick-index', slideIndex - _.slideCount)
								.prependTo(_.$slideTrack)
								.addClass('slick-cloned')
						}
						for (i = 0; i < infiniteCount + _.slideCount; i += 1) {
							slideIndex = i
							$(_.$slides[slideIndex])
								.clone(true)
								.attr('id', '')
								.attr('data-slick-index', slideIndex + _.slideCount)
								.appendTo(_.$slideTrack)
								.addClass('slick-cloned')
						}
						_.$slideTrack
							.find('.slick-cloned')
							.find('[id]')
							.each(function () {
								$(this).attr('id', '')
							})
					}
				}
			}

			Slick.prototype.interrupt = function (toggle) {
				var _ = this

				if (!toggle) {
					_.autoPlay()
				}
				_.interrupted = toggle
			}

			Slick.prototype.selectHandler = function (event) {
				var _ = this

				var targetElement = $(event.target).is('.slick-slide')
					? $(event.target)
					: $(event.target).parents('.slick-slide')

				var index = parseInt(targetElement.attr('data-slick-index'))

				if (!index) index = 0

				if (_.slideCount <= _.options.slidesToShow) {
					_.slideHandler(index, false, true)
					return
				}

				_.slideHandler(index)
			}

			Slick.prototype.slideHandler = function (index, sync, dontAnimate) {
				var targetSlide,
					animSlide,
					oldSlide,
					slideLeft,
					targetLeft = null,
					_ = this,
					navTarget

				sync = sync || false

				if (_.animating === true && _.options.waitForAnimate === true) {
					return
				}

				if (_.options.fade === true && _.currentSlide === index) {
					return
				}

				if (sync === false) {
					_.asNavFor(index)
				}

				targetSlide = index
				targetLeft = _.getLeft(targetSlide)
				slideLeft = _.getLeft(_.currentSlide)

				_.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft

				if (
					_.options.infinite === false &&
					_.options.centerMode === false &&
					(index < 0 || index > _.getDotCount() * _.options.slidesToScroll)
				) {
					if (_.options.fade === false) {
						targetSlide = _.currentSlide
						if (dontAnimate !== true) {
							_.animateSlide(slideLeft, function () {
								_.postSlide(targetSlide)
							})
						} else {
							_.postSlide(targetSlide)
						}
					}
					return
				} else if (
					_.options.infinite === false &&
					_.options.centerMode === true &&
					(index < 0 || index > _.slideCount - _.options.slidesToScroll)
				) {
					if (_.options.fade === false) {
						targetSlide = _.currentSlide
						if (dontAnimate !== true) {
							_.animateSlide(slideLeft, function () {
								_.postSlide(targetSlide)
							})
						} else {
							_.postSlide(targetSlide)
						}
					}
					return
				}

				if (_.options.autoplay) {
					clearInterval(_.autoPlayTimer)
				}

				if (targetSlide < 0) {
					if (_.slideCount % _.options.slidesToScroll !== 0) {
						animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll)
					} else {
						animSlide = _.slideCount + targetSlide
					}
				} else if (targetSlide >= _.slideCount) {
					if (_.slideCount % _.options.slidesToScroll !== 0) {
						animSlide = 0
					} else {
						animSlide = targetSlide - _.slideCount
					}
				} else {
					animSlide = targetSlide
				}

				_.animating = true

				_.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide])

				oldSlide = _.currentSlide
				_.currentSlide = animSlide

				_.setSlideClasses(_.currentSlide)

				if (_.options.asNavFor) {
					navTarget = _.getNavTarget()
					navTarget = navTarget.slick('getSlick')

					if (navTarget.slideCount <= navTarget.options.slidesToShow) {
						navTarget.setSlideClasses(_.currentSlide)
					}
				}

				_.updateDots()
				_.updateArrows()

				if (_.options.fade === true) {
					if (dontAnimate !== true) {
						_.fadeSlideOut(oldSlide)

						_.fadeSlide(animSlide, function () {
							_.postSlide(animSlide)
						})
					} else {
						_.postSlide(animSlide)
					}
					_.animateHeight()
					return
				}

				if (dontAnimate !== true) {
					_.animateSlide(targetLeft, function () {
						_.postSlide(animSlide)
					})
				} else {
					_.postSlide(animSlide)
				}
			}

			Slick.prototype.startLoad = function () {
				var _ = 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 () {
				var 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 _.options.rtl === false ? 'left' : 'right'
				}
				if (swipeAngle <= 360 && swipeAngle >= 315) {
					return _.options.rtl === false ? 'left' : 'right'
				}
				if (swipeAngle >= 135 && swipeAngle <= 225) {
					return _.options.rtl === false ? 'right' : 'left'
				}
				if (_.options.verticalSwiping === true) {
					if (swipeAngle >= 35 && swipeAngle <= 135) {
						return 'down'
					} else {
						return 'up'
					}
				}

				return 'vertical'
			}

			Slick.prototype.swipeEnd = function (event) {
				var _ = this,
					slideCount,
					direction

				_.dragging = false
				_.swiping = false

				if (_.scrolling) {
					_.scrolling = false
					return false
				}

				_.interrupted = false
				_.shouldClick = _.touchObject.swipeLength > 10 ? false : true

				if (_.touchObject.curX === undefined) {
					return false
				}

				if (_.touchObject.edgeHit === true) {
					_.$slider.trigger('edge', [_, _.swipeDirection()])
				}

				if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
					direction = _.swipeDirection()

					switch (direction) {
						case 'left':
						case 'down':
							slideCount = _.options.swipeToSlide
								? _.checkNavigable(_.currentSlide + _.getSlideCount())
								: _.currentSlide + _.getSlideCount()

							_.currentDirection = 0

							break

						case 'right':
						case 'up':
							slideCount = _.options.swipeToSlide
								? _.checkNavigable(_.currentSlide - _.getSlideCount())
								: _.currentSlide - _.getSlideCount()

							_.currentDirection = 1

							break

						default:
					}

					if (direction != 'vertical') {
						_.slideHandler(slideCount)
						_.touchObject = {}
						_.$slider.trigger('swipe', [_, direction])
					}
				} else {
					if (_.touchObject.startX !== _.touchObject.curX) {
						_.slideHandler(_.currentSlide)
						_.touchObject = {}
					}
				}
			}

			Slick.prototype.swipeHandler = function (event) {
				var _ = this

				if (
					_.options.swipe === false ||
					('ontouchend' in document && _.options.swipe === false)
				) {
					return
				} else if (
					_.options.draggable === false &&
					event.type.indexOf('mouse') !== -1
				) {
					return
				}

				_.touchObject.fingerCount =
					event.originalEvent && event.originalEvent.touches !== undefined
						? event.originalEvent.touches.length
						: 1

				_.touchObject.minSwipe = _.listWidth / _.options.touchThreshold

				if (_.options.verticalSwiping === true) {
					_.touchObject.minSwipe = _.listHeight / _.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) {
				var _ = this,
					edgeWasHit = false,
					curLeft,
					swipeDirection,
					swipeLength,
					positionOffset,
					touches,
					verticalSwipeLength

				touches =
					event.originalEvent !== undefined ? event.originalEvent.touches : null

				if (!_.dragging || _.scrolling || (touches && touches.length !== 1)) {
					return false
				}

				curLeft = _.getLeft(_.currentSlide)

				_.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))
				)

				verticalSwipeLength = Math.round(
					Math.sqrt(Math.pow(_.touchObject.curY - _.touchObject.startY, 2))
				)

				if (
					!_.options.verticalSwiping &&
					!_.swiping &&
					verticalSwipeLength > 4
				) {
					_.scrolling = true
					return false
				}

				if (_.options.verticalSwiping === true) {
					_.touchObject.swipeLength = verticalSwipeLength
				}

				swipeDirection = _.swipeDirection()

				if (
					event.originalEvent !== undefined &&
					_.touchObject.swipeLength > 4
				) {
					_.swiping = true
					event.preventDefault()
				}

				positionOffset =
					(_.options.rtl === false ? 1 : -1) *
					(_.touchObject.curX > _.touchObject.startX ? 1 : -1)
				if (_.options.verticalSwiping === true) {
					positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1
				}

				swipeLength = _.touchObject.swipeLength

				_.touchObject.edgeHit = false

				if (_.options.infinite === false) {
					if (
						(_.currentSlide === 0 && swipeDirection === 'right') ||
						(_.currentSlide >= _.getDotCount() && swipeDirection === 'left')
					) {
						swipeLength = _.touchObject.swipeLength * _.options.edgeFriction
						_.touchObject.edgeHit = true
					}
				}

				if (_.options.vertical === false) {
					_.swipeLeft = curLeft + swipeLength * positionOffset
				} else {
					_.swipeLeft =
						curLeft +
						swipeLength * (_.$list.height() / _.listWidth) * positionOffset
				}
				if (_.options.verticalSwiping === true) {
					_.swipeLeft = curLeft + swipeLength * positionOffset
				}

				if (_.options.fade === true || _.options.touchMove === false) {
					return false
				}

				if (_.animating === true) {
					_.swipeLeft = null
					return false
				}

				_.setCSS(_.swipeLeft)
			}

			Slick.prototype.swipeStart = function (event) {
				var _ = this,
					touches

				_.interrupted = true

				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

				_.dragging = true
			}

			Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter =
				function () {
					var _ = this

					if (_.$slidesCache !== null) {
						_.unload()

						_.$slideTrack.children(this.options.slide).detach()

						_.$slidesCache.appendTo(_.$slideTrack)

						_.reinit()
					}
				}

			Slick.prototype.unload = function () {
				var _ = this

				$('.slick-cloned', _.$slider).remove()

				if (_.$dots) {
					_.$dots.remove()
				}

				if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
					_.$prevArrow.remove()
				}

				if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
					_.$nextArrow.remove()
				}

				_.$slides
					.removeClass('slick-slide slick-active slick-visible slick-current')
					.attr('aria-hidden', 'true')
					.css('width', '')
			}

			Slick.prototype.unslick = function (fromBreakpoint) {
				var _ = this
				_.$slider.trigger('unslick', [_, fromBreakpoint])
				_.destroy()
			}

			Slick.prototype.updateArrows = function () {
				var _ = this,
					centerOffset

				centerOffset = Math.floor(_.options.slidesToShow / 2)

				if (
					_.options.arrows === true &&
					_.slideCount > _.options.slidesToShow &&
					!_.options.infinite
				) {
					_.$prevArrow
						.removeClass('slick-disabled')
						.attr('aria-disabled', 'false')
					_.$nextArrow
						.removeClass('slick-disabled')
						.attr('aria-disabled', 'false')

					if (_.currentSlide === 0) {
						_.$prevArrow
							.addClass('slick-disabled')
							.attr('aria-disabled', 'true')
						_.$nextArrow
							.removeClass('slick-disabled')
							.attr('aria-disabled', 'false')
					} else if (
						_.currentSlide >= _.slideCount - _.options.slidesToShow &&
						_.options.centerMode === false
					) {
						_.$nextArrow
							.addClass('slick-disabled')
							.attr('aria-disabled', 'true')
						_.$prevArrow
							.removeClass('slick-disabled')
							.attr('aria-disabled', 'false')
					} else if (
						_.currentSlide >= _.slideCount - 1 &&
						_.options.centerMode === true
					) {
						_.$nextArrow
							.addClass('slick-disabled')
							.attr('aria-disabled', 'true')
						_.$prevArrow
							.removeClass('slick-disabled')
							.attr('aria-disabled', 'false')
					}
				}
			}

			Slick.prototype.updateDots = function () {
				var _ = this

				if (_.$dots !== null) {
					_.$dots.find('li').removeClass('slick-active').end()

					_.$dots
						.find('li')
						.eq(Math.floor(_.currentSlide / _.options.slidesToScroll))
						.addClass('slick-active')
				}
			}

			Slick.prototype.visibility = function () {
				var _ = this

				if (_.options.autoplay) {
					if (document[_.hidden]) {
						_.interrupted = true
					} else {
						_.interrupted = false
					}
				}
			}

			$.fn.slick = function () {
				var _ = this,
					opt = arguments[0],
					args = Array.prototype.slice.call(arguments, 1),
					l = _.length,
					i,
					ret
				for (i = 0; i < l; i++) {
					if (typeof opt == 'object' || typeof opt == 'undefined')
						_[i].slick = new Slick(_[i], opt)
					else ret = _[i].slick[opt].apply(_[i].slick, args)
					if (typeof ret != 'undefined') return ret
				}
				return _
			}
		})

		/*setTimeout(function () {
      initSlider(selector, options);
    }, 250);*/
	}
}
//DONGND:: create option for slick slider of modal popup at product page
var options_modal_product_page = {
	speed: 300,
	dots: false,
	infinite: false,
	slidesToShow: 4,
	slidesToScroll: 1,
	vertical: true,
	verticalSwiping: true,
	responsive: [
		{
			breakpoint: 1200,
			settings: {
				slidesToShow: 3,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 992,
			settings: {
				slidesToShow: 2,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 768,
			settings: {
				slidesToShow: 2,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 576,
			settings: {
				slidesToShow: 1,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 480,
			settings: {
				slidesToShow: 2,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 400,
			settings: {
				slidesToShow: 1,
				slidesToScroll: 1,
			},
		},
	],
}

//DONGND:: create option for slick slider of quickview
var options_quickview = {
	speed: 300,
	dots: false,
	infinite: false,
	slidesToShow: 4,
	slidesToScroll: 1,
	vertical: true,
	verticalSwiping: true,
	responsive: [
		{
			breakpoint: 1200,
			settings: {
				slidesToShow: 4,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 992,
			settings: {
				slidesToShow: 3,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 768,
			settings: {
				slidesToShow: 4,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 576,
			settings: {
				slidesToShow: 3,
				slidesToScroll: 1,
			},
		},
		{
			breakpoint: 480,
			settings: {
				slidesToShow: 2,
				slidesToScroll: 1,
			},
		},
	],
}

$(window).resize(function () {
	//DONGND:: fix zoom, only work at product page
	if (prestashop.page.page_name == 'product') restartElevateZoom()

	//DONGND:: fix lost slider of modal when resize
	if (
		$('#product-modal .product-images').hasClass('slick-initialized') &&
		$('#product-modal .product-images').height() == 0
	) {
		//DONGND:: setup slide for product thumb (modal)
		$('#product-modal .product-images').slick('unslick')
		$('#product-modal .product-images').hide()
		initSlickProductModal()
	}
})

$(document).ready(function () {
	floatHeader()
	backtotop()
	//check page product only
	if (prestashop.page.page_name == 'product') {
		innitSlickandZoom()
	}
	if (prestashop.page.page_name == 'category') {
		setDefaultListGrid()
	}

	if (typeof products_list_functions != 'undefined') {
		for (var i = 0; i < products_list_functions.length; i++) {
			products_list_functions[i]()
		}
	}

	//DONGND:: update for order page - tab adress, when change adress, block adress change class selected
	$('.address-item .radio-block').click(function () {
		if (!$(this).parents('.address-item').hasClass('selected')) {
			$('.address-item.selected').removeClass('selected')
			$(this).parents('.address-item').addClass('selected')
		}
	})

	//DONGND:: loading quickview
	actionQuickViewLoading()

	prestashop.on('updateProductList', function () {
		actionQuickViewLoading()
	})

	prestashop.on('updatedProduct', function () {
		if ($('.quickview.modal .product-thumb-images').length) {
			//DONGND:: run slick slider for product thumb - quickview
			initSlickProductQuickView()
		} else if ($('.product-detail .product-thumb-images').length) {
			//DONGND:: re-call setup slick when change attribute at product page
			innitSlickandZoom()
		}
	})

	//DONGND:: display modal by config
	if (typeof $('#content').data('templatemodal') != 'undefined') {
		if (!$('#content').data('templatemodal')) {
			$('div[data-target="#product-modal"]').hide()
		}
	}

	//DONGND:: create demo product detail from megamenu
	$('.demo-product-detail a').click(function (e) {
		if (!$(this).hasClass('updated')) {
			e.preventDefault()
			var current_url = window.location.href
			if (
				prestashop.page.page_name == 'product' &&
				current_url.indexOf('.html') >= 0
			) {
				var link_href = $(this).attr('href')
				var layout_key_index = link_href.indexOf('?layout=')
				var layout_key_value = link_href.substring(layout_key_index)
				current_url = current_url.substring(0, current_url.indexOf('.html'))
				var new_url = current_url + '.html' + layout_key_value
				window.location.href = new_url
			}
		}
	})
})

function innitSlickandZoom() {
	if ($('#main').hasClass('product-image-thumbs')) {
		/*!
		 * imagesLoaded v5.0.0
		 * JavaScript is all like "You images are done yet or what?"
		 * MIT License
		 */

		;(function (window, factory) {
			// universal module definition
			if (typeof module == 'object' && module.exports) {
				// CommonJS
				module.exports = factory(window, require('ev-emitter'))
			} else {
				// browser global
				window.imagesLoaded = factory(window, window.EvEmitter)
			}
		})(
			typeof window !== 'undefined' ? window : this,
			function factory(window, EvEmitter) {
				let $ = window.jQuery
				let console = window.console

				// -------------------------- helpers -------------------------- //

				// turn element or nodeList into an array
				function makeArray(obj) {
					// use object if already an array
					if (Array.isArray(obj)) return obj

					let isArrayLike =
						typeof obj == 'object' && typeof obj.length == 'number'
					// convert nodeList to array
					if (isArrayLike) return [...obj]

					// array of single index
					return [obj]
				}

				// -------------------------- imagesLoaded -------------------------- //

				/**
				 * @param {[Array, Element, NodeList, String]} elem
				 * @param {[Object, Function]} options - if function, use as callback
				 * @param {Function} onAlways - callback function
				 * @returns {ImagesLoaded}
				 */
				function ImagesLoaded(elem, options, onAlways) {
					// coerce ImagesLoaded() without new, to be new ImagesLoaded()
					if (!(this instanceof ImagesLoaded)) {
						return new ImagesLoaded(elem, options, onAlways)
					}
					// use elem as selector string
					let queryElem = elem
					if (typeof elem == 'string') {
						queryElem = document.querySelectorAll(elem)
					}
					// bail if bad element
					if (!queryElem) {
						console.error(`Bad element for imagesLoaded ${queryElem || elem}`)
						return
					}

					this.elements = makeArray(queryElem)
					this.options = {}
					// shift arguments if no options set
					if (typeof options == 'function') {
						onAlways = options
					} else {
						Object.assign(this.options, options)
					}

					if (onAlways) this.on('always', onAlways)

					this.getImages()
					// add jQuery Deferred object
					if ($) this.jqDeferred = new $.Deferred()

					// HACK check async to allow time to bind listeners
					setTimeout(this.check.bind(this))
				}

				ImagesLoaded.prototype = Object.create(EvEmitter.prototype)

				ImagesLoaded.prototype.getImages = function () {
					this.images = []

					// filter & find items if we have an item selector
					this.elements.forEach(this.addElementImages, this)
				}

				const elementNodeTypes = [1, 9, 11]

				/**
				 * @param {Node} elem
				 */
				ImagesLoaded.prototype.addElementImages = function (elem) {
					// filter siblings
					if (elem.nodeName === 'IMG') {
						this.addImage(elem)
					}
					// get background image on element
					if (this.options.background === true) {
						this.addElementBackgroundImages(elem)
					}

					// find children
					// no non-element nodes, #143
					let { nodeType } = elem
					if (!nodeType || !elementNodeTypes.includes(nodeType)) return

					let childImgs = elem.querySelectorAll('img')
					// concat childElems to filterFound array
					for (let img of childImgs) {
						this.addImage(img)
					}

					// get child background images
					if (typeof this.options.background == 'string') {
						let children = elem.querySelectorAll(this.options.background)
						for (let child of children) {
							this.addElementBackgroundImages(child)
						}
					}
				}

				const reURL = /url\((['"])?(.*?)\1\)/gi

				ImagesLoaded.prototype.addElementBackgroundImages = function (elem) {
					let style = getComputedStyle(elem)
					// Firefox returns null if in a hidden iframe https://bugzil.la/548397
					if (!style) return

					// get url inside url("...")
					let matches = reURL.exec(style.backgroundImage)
					while (matches !== null) {
						let url = matches && matches[2]
						if (url) {
							this.addBackground(url, elem)
						}
						matches = reURL.exec(style.backgroundImage)
					}
				}

				/**
				 * @param {Image} img
				 */
				ImagesLoaded.prototype.addImage = function (img) {
					let loadingImage = new LoadingImage(img)
					this.images.push(loadingImage)
				}

				ImagesLoaded.prototype.addBackground = function (url, elem) {
					let background = new Background(url, elem)
					this.images.push(background)
				}

				ImagesLoaded.prototype.check = function () {
					this.progressedCount = 0
					this.hasAnyBroken = false
					// complete if no images
					if (!this.images.length) {
						this.complete()
						return
					}

					/* eslint-disable-next-line func-style */
					let onProgress = (image, elem, message) => {
						// HACK - Chrome triggers event before object properties have changed. #83
						setTimeout(() => {
							this.progress(image, elem, message)
						})
					}

					this.images.forEach(function (loadingImage) {
						loadingImage.once('progress', onProgress)
						loadingImage.check()
					})
				}

				ImagesLoaded.prototype.progress = function (image, elem, message) {
					this.progressedCount++
					this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded
					// progress event
					this.emitEvent('progress', [this, image, elem])
					if (this.jqDeferred && this.jqDeferred.notify) {
						this.jqDeferred.notify(this, image)
					}
					// check if completed
					if (this.progressedCount === this.images.length) {
						this.complete()
					}

					if (this.options.debug && console) {
						console.log(`progress: ${message}`, image, elem)
					}
				}

				ImagesLoaded.prototype.complete = function () {
					let eventName = this.hasAnyBroken ? 'fail' : 'done'
					this.isComplete = true
					this.emitEvent(eventName, [this])
					this.emitEvent('always', [this])
					if (this.jqDeferred) {
						let jqMethod = this.hasAnyBroken ? 'reject' : 'resolve'
						this.jqDeferred[jqMethod](this)
					}
				}

				// --------------------------  -------------------------- //

				function LoadingImage(img) {
					this.img = img
				}

				LoadingImage.prototype = Object.create(EvEmitter.prototype)

				LoadingImage.prototype.check = function () {
					// If complete is true and browser supports natural sizes,
					// try to check for image status manually.
					let isComplete = this.getIsImageComplete()
					if (isComplete) {
						// report based on naturalWidth
						this.confirm(this.img.naturalWidth !== 0, 'naturalWidth')
						return
					}

					// If none of the checks above matched, simulate loading on detached element.
					this.proxyImage = new Image()
					// add crossOrigin attribute. #204
					if (this.img.crossOrigin) {
						this.proxyImage.crossOrigin = this.img.crossOrigin
					}
					this.proxyImage.addEventListener('load', this)
					this.proxyImage.addEventListener('error', this)
					// bind to image as well for Firefox. #191
					this.img.addEventListener('load', this)
					this.img.addEventListener('error', this)
					this.proxyImage.src = this.img.currentSrc || this.img.src
				}

				LoadingImage.prototype.getIsImageComplete = function () {
					// check for non-zero, non-undefined naturalWidth
					// fixes Safari+InfiniteScroll+Masonry bug infinite-scroll#671
					return this.img.complete && this.img.naturalWidth
				}

				LoadingImage.prototype.confirm = function (isLoaded, message) {
					this.isLoaded = isLoaded
					let { parentNode } = this.img
					// emit progress with parent <picture> or self <img>
					let elem = parentNode.nodeName === 'PICTURE' ? parentNode : this.img
					this.emitEvent('progress', [this, elem, message])
				}

				// ----- events ----- //

				// trigger specified handler for event type
				LoadingImage.prototype.handleEvent = function (event) {
					let method = 'on' + event.type
					if (this[method]) {
						this[method](event)
					}
				}

				LoadingImage.prototype.onload = function () {
					this.confirm(true, 'onload')
					this.unbindEvents()
				}

				LoadingImage.prototype.onerror = function () {
					this.confirm(false, 'onerror')
					this.unbindEvents()
				}

				LoadingImage.prototype.unbindEvents = function () {
					this.proxyImage.removeEventListener('load', this)
					this.proxyImage.removeEventListener('error', this)
					this.img.removeEventListener('load', this)
					this.img.removeEventListener('error', this)
				}

				// -------------------------- Background -------------------------- //

				function Background(url, element) {
					this.url = url
					this.element = element
					this.img = new Image()
				}

				// inherit LoadingImage prototype
				Background.prototype = Object.create(LoadingImage.prototype)

				Background.prototype.check = function () {
					this.img.addEventListener('load', this)
					this.img.addEventListener('error', this)
					this.img.src = this.url
					// check if image is already complete
					let isComplete = this.getIsImageComplete()
					if (isComplete) {
						this.confirm(this.img.naturalWidth !== 0, 'naturalWidth')
						this.unbindEvents()
					}
				}

				Background.prototype.unbindEvents = function () {
					this.img.removeEventListener('load', this)
					this.img.removeEventListener('error', this)
				}

				Background.prototype.confirm = function (isLoaded, message) {
					this.isLoaded = isLoaded
					this.emitEvent('progress', [this, this.element, message])
				}

				// -------------------------- jQuery -------------------------- //

				ImagesLoaded.makeJQueryPlugin = function (jQuery) {
					jQuery = jQuery || window.jQuery
					if (!jQuery) return

					// set local variable
					$ = jQuery
					// $().imagesLoaded()
					$.fn.imagesLoaded = function (options, onAlways) {
						let instance = new ImagesLoaded(this, options, onAlways)
						return instance.jqDeferred.promise($(this))
					}
				}
				// try making plugin
				ImagesLoaded.makeJQueryPlugin()

				// --------------------------  -------------------------- //

				return ImagesLoaded
			}
		)
		//DONGND:: setup slide for product thumb (main)
		$('.product-detail .product-thumb-images').imagesLoaded(function () {
			if (typeof check_loaded_main_product != 'undefined') {
				clearInterval(check_loaded_main_product)
			}

			check_loaded_main_product = setInterval(function () {
				if ($('.product-detail .product-thumb-images').height() > 0) {
					$('.product-detail .product-thumb-images').fadeIn()

					clearInterval(check_loaded_main_product)
					postion = $('#content').data('templateview')
					//DONGND:: add config for over 1200 extra large
					numberimage = $('#content').data('numberimage')
					numberimage1200 = $('#content').data('numberimage1200')
					numberimage992 = $('#content').data('numberimage992')
					numberimage768 = $('#content').data('numberimage768')
					numberimage576 = $('#content').data('numberimage576')
					numberimage480 = $('#content').data('numberimage480')
					numberimage360 = $('#content').data('numberimage360')

					if (postion !== 'undefined') {
						initSlickProductThumb(
							postion,
							numberimage,
							numberimage1200,
							numberimage992,
							numberimage768,
							numberimage576,
							numberimage480,
							numberimage360
						)
					}
				}
			}, 300)
		})

		//DONGND:: setup slide for product thumb (modal)
		initSlickProductModal()
	}
	//call action zoom
	restartElevateZoom()
}

function restartElevateZoom() {
	$('.zoomContainer').remove()
	applyElevateZoom()
}

function applyElevateZoom() {
	if (
		$(window).width() <= 991 ||
		$('#content').data('templatezoomtype') == 'none'
	) {
		//DONGND:: remove elevateZoom on mobile
		if ($('#main').hasClass('product-image-gallery')) {
			if ($('img.js-thumb').data('elevateZoom')) {
				var ezApi = $('img.js-thumb').data('elevateZoom')
				ezApi.changeState('disable')
				$('img.js-thumb').unbind('touchmove')
			}
		} else {
			if ($('#zoom_product').data('elevateZoom')) {
				var ezApi = $('#zoom_product').data('elevateZoom')
				ezApi.changeState('disable')
				$('#zoom_product').unbind('touchmove')
			}
		}
		return false
	}

	//check if that is gallery, zoom all thumb
	//DONGND:: fix zoom, create config
	var zt = $('#content').data('templatezoomtype')
	var zoom_cursor
	var zoom_type
	var scroll_zoom = false
	var lens_FadeIn = 200
	var lens_FadeOut = 200
	var zoomWindow_FadeIn = 200
	var zoomWindow_FadeOut = 200
	var zoom_tint = false
	var zoomWindow_Width = 400
	var zoomWindow_Height = 400
	var zoomWindow_Position = 1

	if (zt == 'in') {
		zoom_cursor = 'crosshair'
		zoom_type = 'inner'
		lens_FadeIn = false
		lens_FadeOut = false
	} else {
		zoom_cursor = 'default'
		zoom_type = 'window'
		zoom_tint = true
		zoomWindow_Width = $('#content').data('zoomwindowwidth')
		zoomWindow_Height = $('#content').data('zoomwindowheight')

		if ($('#content').data('zoomposition') == 'right') {
			//DONGND:: update position of zoom window with ar language
			if (prestashop.language.is_rtl == 1) {
				zoomWindow_Position = 11
			} else {
				zoomWindow_Position = 1
			}
		}
		if ($('#content').data('zoomposition') == 'left') {
			//DONGND:: update position of zoom window with ar language
			if (prestashop.language.is_rtl == 1) {
				zoomWindow_Position = 1
			} else {
				zoomWindow_Position = 11
			}
		}
		if ($('#content').data('zoomposition') == 'top') {
			zoomWindow_Position = 13
		}
		if ($('#content').data('zoomposition') == 'bottom') {
			zoomWindow_Position = 7
		}

		if (zt == 'in_scrooll') {
			//DONGND:: scroll to zoom does not work on IE
			var ua = window.navigator.userAgent
			var old_ie = ua.indexOf('MSIE ')
			var new_ie = ua.indexOf('Trident/')
			if (old_ie > 0 || new_ie > 0) {
				// If Internet Explorer, return version number
				scroll_zoom = false
			} // If another browser, return 0
			else {
				scroll_zoom = true
			}
		}
	}

	if ($('#main').hasClass('product-image-gallery')) {
		lens_FadeIn = false
		lens_FadeOut = false
		zoomWindow_FadeIn = false
		zoomWindow_FadeOut = false
	}

	var zoom_config = {
		responsive: true,
		cursor: zoom_cursor,
		scrollZoom: scroll_zoom,
		scrollZoomIncrement: 0.1,
		zoomLevel: 1,
		zoomType: zoom_type,
		gallery: 'thumb-gallery',
		lensFadeIn: lens_FadeIn,
		lensFadeOut: lens_FadeOut,
		zoomWindowFadeIn: zoomWindow_FadeIn,
		zoomWindowFadeOut: zoomWindow_FadeOut,
		zoomWindowWidth: zoomWindow_Width,
		zoomWindowHeight: zoomWindow_Height,
		borderColour: '#888',
		borderSize: 2,
		zoomWindowOffetx: 0,
		zoomWindowOffety: 0,
		zoomWindowPosition: zoomWindow_Position,
		tint: zoom_tint,
	}

	if ($('#main').hasClass('product-image-gallery')) {
		$('img.js-thumb').each(function () {
			var parent_e = $(this).parent()
			$(this).attr('src', parent_e.data('image'))
			$(this).data('type-zoom', parent_e.data('zoom-image'))
		})

		if ($.fn.elevateZoom !== undefined) {
			$('img.js-thumb').elevateZoom(zoom_config)
			//DONGND:: fix click a thumb replace all image and add fancybox
			$('img.js-thumb').bind('click', function (e) {
				var ez = $(this).data('elevateZoom')
				$.fancybox(ez.getGalleryList())
				return false
			})
		}
	} else {
		if ($.fn.elevateZoom !== undefined) {
			$('#zoom_product').elevateZoom(zoom_config)

			//pass the images to Fancybox
			$('#zoom_product').bind('click', function (e) {
				var ez = $('#zoom_product').data('elevateZoom')
				$.fancybox(ez.getGalleryList())
				return false
			})
		}
	}
}

function initSlickProductThumb(
	postion,
	numberimage,
	numberimage1200,
	numberimage992,
	numberimage768,
	numberimage576,
	numberimage480,
	numberimage360
) {
	var vertical = true
	var verticalSwiping = true
	//DONGND:: update for rtl
	var slick_rtl = false

	if (postion == 'bottom') {
		vertical = false
		verticalSwiping = false
	}

	if (postion == 'none') {
		vertical = false
		verticalSwiping = false
		numberimage =
			numberimage1200 =
			numberimage992 =
			numberimage768 =
			numberimage576 =
			numberimage480 =
			numberimage360 =
				1
	}

	//DONGND:: update for rtl
	if (!vertical && prestashop.language.is_rtl == 1) {
		slick_rtl = true
	}
	initSlider('#thumb-gallery', {
		speed: 300,
		dots: false,
		infinite: false,
		slidesToShow: numberimage,
		vertical: vertical,
		verticalSwiping: verticalSwiping,
		slidesToScroll: 1,
		rtl: slick_rtl,
		responsive: [
			{
				breakpoint: 1200,
				settings: {
					slidesToShow: numberimage1200,
					slidesToScroll: 1,
				},
			},
			{
				breakpoint: 992,
				settings: {
					slidesToShow: numberimage992,
					slidesToScroll: 1,
				},
			},
			{
				breakpoint: 768,
				settings: {
					slidesToShow: numberimage768,
					slidesToScroll: 1,
				},
			},
			{
				breakpoint: 576,
				settings: {
					slidesToShow: numberimage576,
					slidesToScroll: 1,
				},
			},
			{
				breakpoint: 480,
				settings: {
					slidesToShow: numberimage480,
					slidesToScroll: 1,
				},
			},
			{
				breakpoint: 360,
				settings: {
					slidesToShow: numberimage360,
					slidesToScroll: 1,
				},
			},
		],
	})
	$('#thumb-gallery').show()

	if (postion == 'none') {
		var slickInstance = slider[0]
		var slides = $(slickInstance.slick.$slides)
		var positionStart = findPosition(slides)
		var slideCount = slickInstance.slick.slideCount

		//DONGND:: update slick for case without thubms
		if (positionStart + 1 == slideCount) {
			$('.arrows-product-fake .slick-next').addClass('slick-disabled')
		} else if (positionStart == 0) {
			$('.arrows-product-fake .slick-prev').addClass('slick-disabled')
		}

		// active image first load
		slider.slick('slickGoTo', positionStart)

		$('.arrows-product-fake .slick-next').on('click', function () {
			if (!$(this).hasClass('slick-disabled')) {
				$('.arrows-product-fake .slick-prev').removeClass('slick-disabled')
				var positionCurrent = findPosition(slides)
				if (positionCurrent + 1 < slideCount) {
					$(slides[positionCurrent]).removeClass('active')
					$(slides[positionCurrent + 1]).addClass('active')
					$(slides[positionCurrent + 1])
						.find('img')
						.trigger('click')
					slider.slick('slickNext')
					if (positionCurrent + 1 == slideCount - 1) {
						$(this).addClass('slick-disabled')
					}
				}
			}
		})

		$('.arrows-product-fake .slick-prev').on('click', function () {
			if (!$(this).hasClass('slick-disabled')) {
				$('.arrows-product-fake .slick-next').removeClass('slick-disabled')
				var positionCurrent = findPosition(slides)
				if (positionCurrent > 0) {
					$(slides[positionCurrent]).removeClass('active')
					$(slides[positionCurrent - 1]).addClass('active')
					$(slides[positionCurrent - 1])
						.find('img')
						.trigger('click')
					slider.slick('slickPrev')
					if (positionCurrent - 1 == 0) {
						$(this).addClass('slick-disabled')
					}
				}
			}
		})
	}
}

function findPosition(slides) {
	var position
	for (var i = 0; i < slides.length; i++) {
		if ($(slides[i]).hasClass('active')) {
			position = $(slides[i]).data('slick-index')
			return position
		}
	}
}

//DONGND:: loading quickview
function actionQuickViewLoading() {
	$('.quick-view').click(function () {
		if (!$(this).hasClass('active')) {
			$(this).addClass('active')
			$(this).find('.leo-quickview-bt-loading').css({
				display: 'block',
			})
			$(this).find('.leo-quickview-bt-content').hide()
			if (typeof check_active_quickview != 'undefined') {
				clearInterval(check_active_quickview)
			}

			check_active_quickview = setInterval(function () {
				if ($('.quickview.modal').length) {
					$('.quickview.modal').on('hide.bs.modal', function (e) {
						$('.quick-view.active').find('.leo-quickview-bt-loading').hide()
						$('.quick-view.active').find('.leo-quickview-bt-content').show()
						$('.quick-view.active').removeClass('active')
					})
					clearInterval(check_active_quickview)

					//DONGND:: run slick for product thumb - quickview
					initSlickProductQuickView()
				}
			}, 300)
		}
	})
}

$(document).on('click', '.leo_grid', function (e) {
	e.preventDefault()
	$('#js-product-list .product_list').removeClass('list')
	$('#js-product-list .product_list').addClass('grid')

	$(this).parent().find('.leo_list').removeClass('selected')
	$(this).addClass('selected')

	var configName = LEO_COOKIE_THEME + '_grid_list'
	$.cookie(configName, 'grid', {
		expires: 1,
		path: '/',
	})
})

$(document).on('click', '.leo_list', function (e) {
	e.preventDefault()
	$('#js-product-list .product_list').removeClass('grid')
	$('#js-product-list .product_list').addClass('list')

	$(this).parent().find('.leo_grid').removeClass('selected')
	$(this).addClass('selected')

	var configName = LEO_COOKIE_THEME + '_grid_list'
	$.cookie(configName, 'list', {
		expires: 1,
		path: '/',
	})
})

function setDefaultListGrid() {
	if ($.cookie(LEO_COOKIE_THEME + '_grid_list') == 'grid') {
		$('.leo_grid').trigger('click')
	}
	if ($.cookie(LEO_COOKIE_THEME + '_grid_list') == 'list') {
		$('.leo_list').trigger('click')
	}
}

function processFloatHeader(headerAdd, scroolAction) {
	//DONGND:: hide search result when enable float header
	if ($('.ac_results').length) {
		$('.ac_results').hide()
	}

	if (headerAdd) {
		$('#header').addClass('navbar-fixed-top')
		var hideheight = $('#header').height() + 120
		$('#page').css('padding-top', $('#header').height())
		setTimeout(function () {
			$('#page').css('padding-top', $('#header').height())
		}, 200)
	} else {
		$('#header').removeClass('navbar-fixed-top')
		$('#page').css('padding-top', '')
	}

	var pos = $(window).scrollTop()
	if (scroolAction && pos >= hideheight) {
		$('.header-nav').addClass('hide-bar')
		$('.hide-bar').css('margin-top', -$('.header-nav').height())
		$('#header').addClass('mini-navbar')
	} else {
		$('.header-nav').removeClass('hide-bar')
		$('.header-nav').css('margin-top', 0)
		$('#header').removeClass('mini-navbar')
	}
}

//Float Menu
function floatHeader() {
	if (!$('body').hasClass('keep-header') || $(window).width() <= 990) {
		return
	}

	$(window).resize(function () {
		if ($(window).width() <= 990) {
			processFloatHeader(0, 0)
		} else if ($(window).width() > 990) {
			if ($('body').hasClass('keep-header')) processFloatHeader(1, 1)
		}
	})
	var headerScrollTimer

	$(window).scroll(function () {
		if (headerScrollTimer) {
			window.clearTimeout(headerScrollTimer)
		}

		headerScrollTimer = window.setTimeout(function () {
			if (!$('body').hasClass('keep-header')) return
			if ($(window).width() > 990) {
				processFloatHeader(1, 1)
			}
		}, 100)
	})
}

// Back to top
function backtotop() {
	$('#back-top').hide()
	$(window).scroll(function () {
		if ($(this).scrollTop() > 100) {
			$('#back-top').fadeIn()
		} else {
			$('#back-top').fadeOut()
		}
	})

	// scroll body to 0px on click
	$('#back-top a').click(function () {
		$('body,html').animate(
			{
				scrollTop: 0,
			},
			800
		)
		return false
	})
}

//DONGND:: build slick slider for quickview
function initSlickProductQuickView() {
	$('.quickview.modal .product-thumb-images').imagesLoaded(function () {
		if (typeof check_loaded_thumb_quickview != 'undefined') {
			clearInterval(check_loaded_thumb_quickview)
		}
		check_loaded_thumb_quickview = setInterval(function () {
			if ($('.quickview.modal .product-thumb-images').height() > 0) {
				$('.quickview.modal .product-thumb-images').fadeIn()

				clearInterval(check_loaded_thumb_quickview)
				$('.quickview.modal .product-thumb-images').slick(options_quickview)
			}
		}, 300)
	})
}

//DONGND:: build slick slider for modal - product page
function initSlickProductModal() {
	$('#product-modal .product-images').imagesLoaded(function () {
		if (typeof check_loaded_thumb_modal != 'undefined') {
			clearInterval(check_loaded_thumb_modal)
		}
		check_loaded_thumb_modal = setInterval(function () {
			if ($('#product-modal .product-images').height() > 0) {
				$('#product-modal .product-images').fadeIn()

				clearInterval(check_loaded_thumb_modal)
				$('#product-modal .product-images').slick(options_modal_product_page)
			}
		}, 300)
	})
}

//DONGND: fix base prestashop
$(document).ready(function () {
	//DONGND: remove css inline of label
	$('.product-flag').removeAttr('style')
	prestashop.on('updateProductList', function () {
		//DONGND: remove css inline of label
		$('.product-flag').removeAttr('style')
	})
})
//Fix translate button choose file to upload: change "Choose file" to choosefile_text
//Fix filter (category page) does not work on IE change dataset.searchUrl to getAttribute('data-search-url')

$().ready(function () {
	$('#leo_search_block_top .title_block').click(function () {
		$(this).parent().toggleClass('active')
		setTimeout(function () {
			jQuery('#leo_search_block_top.active input.form-control').focus()
		}, 100)
	})

	$(document).keydown(function (e) {
		// ESCAPE key pressed
		if (e.keyCode == 27) {
			$('#leo_search_block_top').removeClass('active')
		}
	})

	$(document).click(function (event) {
		if (!$(event.target).closest('#leo_search_block_top').length) {
			$('#leo_search_block_top').removeClass('active')
		}
	})

	/*
 	// fix bug module Amazzingfilter
	if ($('body#category').hasClass("page-category")){
		customThemeActions.updateContentAfter = function (jsonData) {
		    if (typeof $.LeoCustomAjax == 'function') {
		        var leoCustomAjax = new $.LeoCustomAjax();
		        leoCustomAjax.processAjax();
		    }
		    if ($('.af_pl_wrapper').find('.product_list').hasClass('list')) {
		        $('.leo_list').addClass('selected').siblings().removeClass('selected');
		    }
		}
		$( document ).ajaxComplete(function() {
			actionQuickViewLoading();
			leoBtCart();
			LeoWishlistButtonAction();
		});
	}
	*/

	$(document).on('ready', function () {
		initSlider($('.list-images-mobile'), {
			slidesToShow: 1,
			slidesToScroll: 1,
			arrows: true,
			dots: true,
			infinite: true,
			customPaging: function (slick, index) {
				var targetImage = slick.$slides.eq(index).find('img').attr('src')
				return '<span><img src=" ' + targetImage + ' "/></span>'
			},
		})
	})

	$(document).ajaxComplete(function (event, xhr, settings) {
		if (settings.url.indexOf('controller=product') > 0) {
			$('.list-images-mobile').slick({
				slidesToShow: 1,
				slidesToScroll: 1,
				arrows: true,
				dots: true,
				infinite: true,
				//centerMode: true,
				//fade: true,
				customPaging: function (slick, index) {
					var targetImage = slick.$slides.eq(index).find('img').attr('src')
					return '<span><img src=" ' + targetImage + ' "/></span>'
				},
			})
		}
	})

	customSticky()

	$(document).ajaxComplete(function () {
		$('.p-reference .product-reference').html(
			$('#product-details .product-reference').clone()
		)
		$('.p-reference .product-quantities').html(
			$('#product-details .product-quantities').clone()
		)
	})
})

function customSticky() {
	if ($('body').attr('id') == 'index') var s = $('.header-top > .inner')
	else var s = $('.topnav .wrapper')

	var pos = s.offset()
	var alreadySticky = false

	$(window).scroll(function () {
		var windowpos = $(window).scrollTop()
		if (s.length) {
			if (!alreadySticky) {
				if (windowpos > pos.top) {
					alreadySticky = true
					s.parent().height(s.height())
					s.removeClass('cus-nosticky')
					s.addClass('cus-sticky')
					$('body').removeClass('body-nosticky')
					$('body').addClass('body-sticky')
				}
			}

			if (alreadySticky) {
				if (windowpos <= pos.top) {
					alreadySticky = false
					s.removeClass('cus-sticky')
					s.addClass('cus-nosticky')
					s.parent().removeAttr('style')
					$('body').addClass('body-nosticky')
					$('body').removeClass('body-sticky')
				}
			}
		}
	})
}

$(function () {

    function initSizeChartButton() {

        var sizeTabLink = $('.product-tabs .nav-link[href="#extra-0"]');
        if (!sizeTabLink.length) return;

        if ($('.product-size-tab').length) return;

        var lang = window.location.pathname.split('/')[1];
        var buttonText = lang === 'pl'
            ? 'TABELA ROZMIARÓW'
            : 'SIZE CHART';

        var sizeTableBtn = $(
            '<a href="#" class="btn btn-outline-secondary mb-1 product-size-tab" style="display:block;">' +
                buttonText +
            '</a>'
        );

        var $rozmiarVariant = $('.product-variants .product-variants-item[data-variant="rozmiar"]');

        if ($rozmiarVariant.length) {
            $rozmiarVariant.addClass('set-size-chart');
            $rozmiarVariant.after(sizeTableBtn);
        }

        sizeTableBtn.on('click', function (e) {
            e.preventDefault();

            sizeTabLink.tab('show');

            var tabsOffset = $('.product-tabs').offset().top;
            $('html, body').animate({ scrollTop: tabsOffset - 100 }, 600);
        });
    }
	
    initSizeChartButton();

    if (typeof prestashop !== 'undefined') {
        prestashop.on('updatedProduct', function () {
            setTimeout(initSizeChartButton, 100);
        });
    }

});