/*!

* EDITED BY LIQUID THEMES *

* pagepiling.js 1.5.5
*
* https://github.com/alvarotrigo/pagePiling.js
* @license MIT licensed
*
* Copyright (C) 2016 alvarotrigo.com - A project by Alvaro Trigo
*/
(function ($, document, window, undefined) {
	'use strict';
	
	$.fn.pagepiling = function (custom) {
		var PP = $.fn.pagepiling;
		var container = $(this);
		var lastScrolledDestiny;
		var lastAnimation = 0;
		var isTouch = (('ontouchstart' in window) || (navigator.msMaxTouchPoints > 0) || (navigator.maxTouchPoints));
		var touchStartY = 0, touchStartX = 0, touchEndY = 0, touchEndX = 0;
		var scrollings = [];
		
		//Defines the delay to take place before being able to scroll to the next section
		//BE CAREFUL! Not recommened to change it under 400 for a good behavior in laptops and
		//Apple devices (laptops, mouses...)
		var scrollDelay = 600;
		
		// Create some defaults, extending them with any options that were provided
		var options = $.extend(true, {
			direction: 'vertical',
			menu: null,
			verticalCentered: true,
			sectionsColor: [],
			anchors: [],
			scrollingSpeed: 700,
			easing: 'easeInQuart',
			loopBottom: false,
			loopTop: false,
			css3: true,
			navigation: {
				textColor: '#000',
				bulletsColor: '#000',
				position: 'right',
				tooltips: []
			},
			normalScrollElements: null,
			normalScrollElementTouchThreshold: 5,
			touchSensitivity: 5,
			keyboardScrolling: true,
			sectionSelector: '.section',
			animateAnchor: false,
			
			//events
			afterLoad: null,
			onLeave: null,
			afterRender: null
		}, custom);
		
		
		//easeInQuart animation included in the plugin
		$.extend($.easing,{ easeInQuart: function (x, t, b, c, d) { return c*(t/=d)*t*t*t + b; }});
		
		/**
		* Defines the scrolling speed
		*/
		PP.setScrollingSpeed = function(value){
			options.scrollingSpeed = value;
		};
		
		/**
		* Adds or remove the possiblity of scrolling through sections by using the mouse wheel or the trackpad.
		*/
		PP.setMouseWheelScrolling = function (value){
			if(value){
				addMouseWheelHandler();
			}else{
				removeMouseWheelHandler();
			}
		};
		
		/**
		* Adds or remove the possiblity of scrolling through sections by using the mouse wheel/trackpad or touch gestures.
		*/
		PP.setAllowScrolling = function (value){
			if(value){
				PP.setMouseWheelScrolling(true);
				addTouchHandler();
			}else{
				PP.setMouseWheelScrolling(false);
				removeTouchHandler();
			}
		};
		
		/**
		* Adds or remove the possiblity of scrolling through sections by using the keyboard arrow keys
		*/
		PP.setKeyboardScrolling = function (value){
			options.keyboardScrolling = value;
		};
		
		/**
		* Moves sectio up
		*/
		PP.moveSectionUp = function () {
			var prev = $('.pp-section.active').prev('.pp-section');
			
			//looping to the bottom if there's no more sections above
			if (!prev.length && options.loopTop) {
				prev = $('.pp-section').last();
			}
			
			if (prev.length) {
				scrollPage(prev);
			}
		};
		
		/**
		* Moves sectio down
		*/
		PP.moveSectionDown = function () {
			var next = $('.pp-section.active').next('.pp-section');
			
			//looping to the top if there's no more sections below
			if(!next.length && options.loopBottom){
				next = $('.pp-section').first();
			}
			
			if (next.length) {
				scrollPage(next);
			}
		};
		
		/**
		* Moves the site to the given anchor or index
		*/
		PP.moveTo = function (section){
			var destiny = '';
			
			if(isNaN(section)){
				destiny = $(document).find('[data-anchor="'+section+'"]');
			}else{
				destiny = $('.pp-section').eq( (section -1) );
			}
			
			
			if(destiny.length > 0){
				scrollPage(destiny);
			}
		};
		
		//adding internal class names to void problem with common ones
		$(options.sectionSelector).each(function(){
			$(this).addClass('pp-section');
		});
		
		//if css3 is not supported, it will use jQuery animations
		if(options.css3){
			options.css3 = support3d();
		}
		
		$(container).css({
			'overflow' : 'hidden',
			'-ms-touch-action': 'none',  /* Touch detection for Windows 8 */
			'touch-action': 'none'       /* IE 11 on Windows Phone 8.1*/
		});
		
		//init
		PP.setAllowScrolling(true);
		
		//creating the navigation dots
		if (!$.isEmptyObject(options.navigation) ) {
			addVerticalNavigation();
		}
		
		var zIndex = $('.pp-section').length;
		
		$('.pp-section').each(function (index) {
			$(this).data('data-index', index);
			$(this).css('z-index', zIndex);
			
			//if no active section is defined, the 1st one will be the default one
			if (!index && $('.pp-section.active').length === 0) {
				$(this).addClass('active');
			}
			
			if (typeof options.anchors[index] !== 'undefined') {
				$(this).attr('data-anchor', options.anchors[index]);
			}
			
			if (typeof options.sectionsColor[index] !== 'undefined') {
				$(this).css('background-color', options.sectionsColor[index]);
			}
			
			if(options.verticalCentered && !$(this).hasClass('pp-scrollable')){
				addTableClass($(this));
			}
			
			zIndex = zIndex - 1;
		}).promise().done(function(){
			//vertical centered of the navigation + first bullet active
			if(options.navigation){
				$('#pp-nav').find('li').eq($('.pp-section.active').index('.pp-section')).find('a').addClass('active');
			}
			
			$(window).on('load', function() {
				scrollToAnchor();
			});
			
			$.isFunction( options.afterRender ) && options.afterRender.call( this);
		});
		
		/**
		* Enables vertical centering by wrapping the content and the use of table and table-cell
		*/
		function addTableClass(element){
			element.addClass('pp-table').wrapInner('<div class="pp-tableCell" style="height:100%" />');
		}
		
		
		/**
		* Retuns `up` or `down` depending on the scrolling movement to reach its destination
		* from the current section.
		*/
		function getYmovement(destiny){
			var fromIndex = $('.pp-section.active').index('.pp-section');
			var toIndex = destiny.index('.pp-section');
			
			if(fromIndex > toIndex){
				return 'up';
			}
			return 'down';
		}
		
		/**
		* Scrolls the page to the given destination
		*/
		function scrollPage(destination, animated) {
			var v ={
				destination: destination,
				animated: animated,
				activeSection: $('.pp-section.active'),
				anchorLink: destination.data('anchor'),
				sectionIndex: destination.index('.pp-section'),
				toMove: destination,
				yMovement: getYmovement(destination),
				leavingSection: $('.pp-section.active').index('.pp-section') + 1
			};
			
			//quiting when activeSection is the target element
			if(v.activeSection.is(destination)){ return; }
			
			if(typeof v.animated === 'undefined'){
				v.animated = true;
			}
			
			if(typeof v.anchorLink !== 'undefined'){
				setURLHash(v.anchorLink, v.sectionIndex);
			}
			
			v.destination.addClass('active').siblings().removeClass('active');
			
			v.sectionsToMove = getSectionsToMove(v);
			
			//scrolling down (moving sections up making them disappear)
			if (v.yMovement === 'down') {
				
				v.translate3d = getTranslate3d();
				
				if ( v.destination.is('.pp-auto-height') ) {
					
					var destinationTransform = ( v.destination.outerHeight() * -1 ) + 'px';
					
					v.translate3d = `translate3d(0px, ${destinationTransform}, 0px)`;
					
					v.scrolling = destinationTransform;

					v.sectionsToMove = v.activeSection;
					
				} else {
					
					v.scrolling = '-100%';
					
				}
				
				if(!options.css3){
					v.sectionsToMove.each(function(index){
						if(index != v.activeSection.index('.pp-section')){
							$(this).css(getScrollProp(v.scrolling));
						}
					});
				}
				
				v.animateSection = v.activeSection;
				
			}
			
			//scrolling up (moving section down to the viewport)
			else {
				v.translate3d = 'translate3d(0px, 0px, 0px)';
				v.scrolling = '0';
				
				v.animateSection = destination;
			}
			
			$.isFunction(options.onLeave) && options.onLeave.call(this, v.leavingSection, (v.sectionIndex + 1), v.yMovement);
			
			performMovement(v);
			
			activateMenuElement(v.anchorLink);
			activateNavDots(v.anchorLink, v.sectionIndex);
			lastScrolledDestiny = v.anchorLink;
			
			var timeNow = new Date().getTime();
			lastAnimation = timeNow;
		}
		
		/**
		* Performs the movement (by CSS3 or by jQuery)
		*/
		function performMovement(v){
			if(options.css3){
				transformContainer(v.animateSection, v.translate3d, v.animated);
				
				v.sectionsToMove.each(function(){
					transformContainer($(this), v.translate3d, v.animated);
				});
				
				setTimeout(function () {
					afterSectionLoads(v);
				}, options.scrollingSpeed);
			}else{
				v.scrollOptions = getScrollProp(v.scrolling);
				
				if(v.animated){
					v.animateSection.animate(
						v.scrollOptions,
						options.scrollingSpeed, options.easing, function () {
							readjustSections(v);
							afterSectionLoads(v);
						});
					}else{
						v.animateSection.css(getScrollProp(v.scrolling));
						setTimeout(function(){
							readjustSections(v);
							afterSectionLoads(v);
						},400);
					}
				}
			}
			
			/**
			* Actions to execute after a secion is loaded
			*/
			function afterSectionLoads(v){
				//callback (afterLoad) if the site is not just resizing and readjusting the slides
				$.isFunction(options.afterLoad) && options.afterLoad.call(this, v.anchorLink, (v.sectionIndex + 1));
			}
			
			
			function getSectionsToMove(v){
				var sectionToMove;
				
				if(v.yMovement === 'down'){
					sectionToMove = $('.pp-section').map(function(index){
						if (index < v.destination.index('.pp-section')){
							return $(this);
						}
					});
				}else{
					sectionToMove = $('.pp-section').map(function(index){
						if (index > v.destination.index('.pp-section')){
							return $(this);
						}
					});
				}
				
				return sectionToMove;
			}
			
			/**
			* Returns the sections to re-adjust in the background after the section loads.
			*/
			function readjustSections(v){
				if(v.yMovement === 'up'){
					v.sectionsToMove.each(function(index){
						$(this).css(getScrollProp(v.scrolling));
					});
				}
			}
			
			/**
			* Gets the property used to create the scrolling effect when using jQuery animations
			* depending on the plugin direction option.
			*/
			function getScrollProp(propertyValue){
				if(options.direction === 'vertical'){
					return {'top': propertyValue};
				}
				return {'left': propertyValue};
			}
			
			/**
			* Scrolls the site without anymations (usually used in the background without the user noticing it)
			*/
			function silentScroll(section, offset){
				if (options.css3) {
					transformContainer(section, getTranslate3d(), false);
				}
				else{
					section.css(getScrollProp(offset));
				}
			}
			
			/**
			* Sets the URL hash for a section with slides
			*/
			function setURLHash(anchorLink, sectionIndex){
				if(options.anchors.length){
					location.hash = anchorLink;
					
					setBodyClass(location.hash);
				}else{
					setBodyClass(String(sectionIndex));
				}
			}
			
			/**
			* Sets a class for the body of the page depending on the active section / slide
			*/
			function setBodyClass(text){
				//removing the #
				text = text.replace('#','');
				
				//removing previous anchor classes
				$('body')[0].className = $('body')[0].className.replace(/\b\s?pp-viewing-[^\s]+\b/g, '');
				
				//adding the current anchor
				$('body').addClass('pp-viewing-' + text);
			}
			
			//TO DO
			function scrollToAnchor(){
				//getting the anchor link in the URL and deleting the `#`
				var value =  window.location.hash.replace('#', '');
				var sectionAnchor = value;
				var section = $(document).find('.pp-section[data-anchor="'+sectionAnchor+'"]');
				
				if(section.length > 0){  //if theres any #
					scrollPage(section, options.animateAnchor);
				}
			}
			
			/**
			* Determines if the transitions between sections still taking place.
			* The variable `scrollDelay` adds a "save zone" for devices such as Apple laptops and Apple magic mouses
			*/
			function isMoving(){
				var timeNow = new Date().getTime();
				// Cancel scroll if currently animating or within quiet period
				if (timeNow - lastAnimation < scrollDelay + options.scrollingSpeed) {
					return true;
				}
				return false;
			}
			
			//detecting any change on the URL to scroll to the given anchor link
			//(a way to detect back history button as we play with the hashes on the URL)
			$(window).on('hashchange', hashChangeHandler);
			
			/**
			* Actions to do when the hash (#) in the URL changes.
			*/
			function hashChangeHandler(){
				var value =  window.location.hash.replace('#', '').split('/');
				var sectionAnchor = value[0];
				
				if(sectionAnchor.length){
					/*in order to call scrollpage() only once for each destination at a time
					It is called twice for each scroll otherwise, as in case of using anchorlinks `hashChange`
					event is fired on every scroll too.*/
					if (sectionAnchor && sectionAnchor !== lastScrolledDestiny)  {
						var section;
						
						if(isNaN(sectionAnchor)){
							section = $(document).find('[data-anchor="'+sectionAnchor+'"]');
						}else{
							section = $('.pp-section').eq( (sectionAnchor -1) );
						}
						scrollPage(section);
					}
				}
			}
			
			/**
			* Cross browser transformations
			*/
			function getTransforms(translate3d) {
				return {
					'-webkit-transform': translate3d,
					'-moz-transform': translate3d,
					'-ms-transform': translate3d,
					'transform': translate3d
				};
			}
			
			/**
			* Adds a css3 transform property to the container class with or without animation depending on the animated param.
			*/
			function transformContainer(element, translate3d, animated) {
				element.css(getTransforms(translate3d));
			}
			
			/**
			* Sliding with arrow keys, both, vertical and horizontal
			*/
			$(document).keydown(function (e) {
				if(options.keyboardScrolling && !isMoving()){
					//Moving the main page with the keyboard arrows if keyboard scrolling is enabled
					switch (e.which) {
						//up
						case 38:
						case 33:
						PP.moveSectionUp();
						break;
						
						//down
						case 40:
						case 34:
						PP.moveSectionDown();
						break;
						
						//Home
						case 36:
						PP.moveTo(1);
						break;
						
						//End
						case 35:
						PP.moveTo($('.pp-section').length);
						break;
						
						//left
						case 37:
						PP.moveSectionUp();
						break;
						
						//right
						case 39:
						PP.moveSectionDown();
						break;
						
						default:
						return; // exit this handler for other keys
					}
				}
			});
			
			/**
			* If `normalScrollElements` is used, the mouse wheel scrolling will scroll normally
			* over the defined elements in the option.
			*/
			if(options.normalScrollElements){
				$(document).on('mouseenter', options.normalScrollElements, function () {
					PP.setMouseWheelScrolling(false);
				});
				
				$(document).on('mouseleave', options.normalScrollElements, function(){
					PP.setMouseWheelScrolling(true);
				});
			}
			
			/**
			* Detecting mousewheel scrolling
			*
			* http://blogs.sitepointstatic.com/examples/tech/mouse-wheel/index.html
			* http://www.sitepoint.com/html5-javascript-mouse-wheel/
			*/
			var prevTime = new Date().getTime();
			
			function MouseWheelHandler(e) {
				var curTime = new Date().getTime();
				
				// cross-browser wheel delta
				e = e || window.event;
				var value = e.wheelDelta || -e.deltaY || -e.detail;
				var delta = Math.max(-1, Math.min(1, value));
				
				var horizontalDetection = typeof e.wheelDeltaX !== 'undefined' || typeof e.deltaX !== 'undefined';
				var isScrollingVertically = (Math.abs(e.wheelDeltaX) < Math.abs(e.wheelDelta)) || (Math.abs(e.deltaX ) < Math.abs(e.deltaY) || !horizontalDetection);
				
				//Limiting the array to 150 (lets not waste memory!)
				if(scrollings.length > 149){
					scrollings.shift();
				}
				
				//keeping record of the previous scrollings
				scrollings.push(Math.abs(value));
				
				//time difference between the last scroll and the current one
				var timeDiff = curTime-prevTime;
				prevTime = curTime;
				
				//haven't they scrolled in a while?
				//(enough to be consider a different scrolling action to scroll another section)
				if(timeDiff > 200){
					//emptying the array, we dont care about old scrollings for our averages
					scrollings = [];
				}
				
				if(!isMoving()){
					var activeSection = $('.pp-section.active');
					var scrollable = isScrollable(activeSection);
					
					var averageEnd = getAverage(scrollings, 10);
					var averageMiddle = getAverage(scrollings, 70);
					var isAccelerating = averageEnd >= averageMiddle;
					
					if(isAccelerating && isScrollingVertically){
						//scrolling down?
						if (delta < 0) {
							scrolling('down', scrollable);
							
							//scrolling up?
						}else if(delta>0){
							scrolling('up', scrollable);
						}
					}
					
					return false;
				}
			}
			
			/**
			* Gets the average of the last `number` elements of the given array.
			*/
			function getAverage(elements, number){
				var sum = 0;
				
				//taking `number` elements from the end to make the average, if there are not enought, 1
				var lastElements = elements.slice(Math.max(elements.length - number, 1));
				
				for(var i = 0; i < lastElements.length; i++){
					sum = sum + lastElements[i];
				}
				
				return Math.ceil(sum/number);
			}
			
			/**
			* Determines the way of scrolling up or down:
			* by 'automatically' scrolling a section or by using the default and normal scrolling.
			*/
			function scrolling(type, scrollable){
				var check;
				var scrollSection;
				
				if(type == 'down'){
					check = 'bottom';
					scrollSection = PP.moveSectionDown;
				}else{
					check = 'top';
					scrollSection = PP.moveSectionUp;
				}
				
				if(scrollable.length > 0 ){
					//is the scrollbar at the start/end of the scroll?
					if(isScrolled(check, scrollable)){
						scrollSection();
					}else{
						return true;
					}
				}else{
					//moved up/down
					scrollSection();
				}
			}
			
			/**
			* Return a boolean depending on whether the scrollable element is at the end or at the start of the scrolling
			* depending on the given type.
			*/
			function isScrolled(type, scrollable){
				if(type === 'top'){
					return !scrollable.scrollTop();
				}else if(type === 'bottom'){
					return scrollable.scrollTop() + 1 + scrollable.innerHeight() >= scrollable[0].scrollHeight;
				}
			}
			
			/**
			* Determines whether the active section or slide is scrollable through and scrolling bar
			*/
			function isScrollable(activeSection){
				return activeSection.filter('.pp-scrollable');
			}
			
			/**
			* Removes the auto scrolling action fired by the mouse wheel and tackpad.
			* After this function is called, the mousewheel and trackpad movements won't scroll through sections.
			*/
			function removeMouseWheelHandler(){
				if (container.get(0).addEventListener) {
					container.get(0).removeEventListener('mousewheel', MouseWheelHandler, false); //IE9, Chrome, Safari, Oper
					container.get(0).removeEventListener('wheel', MouseWheelHandler, false); //Firefox
				} else {
					container.get(0).detachEvent('onmousewheel', MouseWheelHandler); //IE 6/7/8
				}
			}
			
			/**
			* Adds the auto scrolling action for the mouse wheel and tackpad.
			* After this function is called, the mousewheel and trackpad movements will scroll through sections
			*/
			function addMouseWheelHandler(){
				if (container.get(0).addEventListener) {
					container.get(0).addEventListener('mousewheel', MouseWheelHandler, false); //IE9, Chrome, Safari, Oper
					container.get(0).addEventListener('wheel', MouseWheelHandler, false); //Firefox
				} else {
					container.get(0).attachEvent('onmousewheel', MouseWheelHandler); //IE 6/7/8
				}
			}
			
			/**
			* Adds the possibility to auto scroll through sections on touch devices.
			*/
			function addTouchHandler(){
				if(isTouch){
					//Microsoft pointers
					var MSPointer = getMSPointer();
					
					container.off('touchstart ' +  MSPointer.down).on('touchstart ' + MSPointer.down, touchStartHandler);
					container.off('touchmove ' + MSPointer.move).on('touchmove ' + MSPointer.move, touchMoveHandler);
				}
			}
			
			/**
			* Removes the auto scrolling for touch devices.
			*/
			function removeTouchHandler(){
				if(isTouch){
					//Microsoft pointers
					var MSPointer = getMSPointer();
					
					container.off('touchstart ' + MSPointer.down);
					container.off('touchmove ' + MSPointer.move);
				}
			}
			
			/*
			* Returns and object with Microsoft pointers (for IE<11 and for IE >= 11)
			* http://msdn.microsoft.com/en-us/library/ie/dn304886(v=vs.85).aspx
			*/
			function getMSPointer(){
				var pointer;
				
				//IE >= 11 & rest of browsers
				if(window.PointerEvent){
					pointer = { down: 'pointerdown', move: 'pointermove', up: 'pointerup'};
				}
				
				//IE < 11
				else{
					pointer = { down: 'MSPointerDown', move: 'MSPointerMove', up: 'MSPointerUp'};
				}
				
				return pointer;
			}
			
			/**
			* Gets the pageX and pageY properties depending on the browser.
			* https://github.com/alvarotrigo/fullPage.js/issues/194#issuecomment-34069854
			*/
			function getEventsPage(e){
				var events = new Array();
				
				events.y = (typeof e.pageY !== 'undefined' && (e.pageY || e.pageX) ? e.pageY : e.touches[0].pageY);
				events.x = (typeof e.pageX !== 'undefined' && (e.pageY || e.pageX) ? e.pageX : e.touches[0].pageX);
				
				return events;
			}
			
			/**
			* As IE >= 10 fires both touch and mouse events when using a mouse in a touchscreen
			* this way we make sure that is really a touch event what IE is detecting.
			*/
			function isReallyTouch(e){
				//if is not IE   ||  IE is detecting `touch` or `pen`
				return typeof e.pointerType === 'undefined' || e.pointerType != 'mouse';
			}
			
			/**
			* Getting the starting possitions of the touch event
			*/
			function touchStartHandler(event){
				var e = event.originalEvent;
				
				if(isReallyTouch(e)){
					var touchEvents = getEventsPage(e);
					touchStartY = touchEvents.y;
					touchStartX = touchEvents.x;
				}
			}
			
			/* Detecting touch events
			*/
			function touchMoveHandler(event){
				var e = event.originalEvent;
				
				// additional: if one of the normalScrollElements isn't within options.normalScrollElementTouchThreshold hops up the DOM chain
				if ( !checkParentForNormalScrollElement(event.target) && isReallyTouch(e) ) {
					
					var activeSection = $('.pp-section.active');
					var scrollable = isScrollable(activeSection);
					
					if(!scrollable.length){
						event.preventDefault();
					}
					
					if (!isMoving()) {
						var touchEvents = getEventsPage(e);
						touchEndY = touchEvents.y;
						touchEndX = touchEvents.x;
						
						//$('body').append('<span style="position:fixed; top: 250px; left: 20px; z-index:88; font-size: 25px; color: #000;">touchEndY: ' + touchEndY  + '</div>');
						
						//X movement bigger than Y movement?
						if (options.direction === 'horizontal' && Math.abs(touchStartX - touchEndX) > (Math.abs(touchStartY - touchEndY))) {
							//is the movement greater than the minimum resistance to scroll?
							if (Math.abs(touchStartX - touchEndX) > (container.width() / 100 * options.touchSensitivity)) {
								if (touchStartX > touchEndX) {
									scrolling('down', scrollable);
								} else if (touchEndX > touchStartX) {
									scrolling('up', scrollable);
								}
							}
						} else {
							if (Math.abs(touchStartY - touchEndY) > (container.height() / 100 * options.touchSensitivity)) {
								if (touchStartY > touchEndY) {
									scrolling('down', scrollable);
								} else if (touchEndY > touchStartY) {
									scrolling('up', scrollable);
								}
							}
						}
					}
				}
			}
			
			/**
			* recursive function to loop up the parent nodes to check if one of them exists in options.normalScrollElements
			* Currently works well for iOS - Android might need some testing
			* @param  {Element} el  target element / jquery selector (in subsequent nodes)
			* @param  {int}     hop current hop compared to options.normalScrollElementTouchThreshold
			* @return {boolean} true if there is a match to options.normalScrollElements
			*/
			function checkParentForNormalScrollElement (el, hop) {
				hop = hop || 0;
				var parent = $(el).parent();
				
				if (hop < options.normalScrollElementTouchThreshold &&
					parent.is(options.normalScrollElements) ) {
						return true;
					} else if (hop == options.normalScrollElementTouchThreshold) {
						return false;
					} else {
						return checkParentForNormalScrollElement(parent, ++hop);
					}
				}
				
				
				/**
				* Creates a vertical navigation bar.
				*/
				function addVerticalNavigation(){
					$('body').append('<div id="pp-nav"><ul></ul></div>');
					var nav = $('#pp-nav');
					
					nav.addClass(options.navigation.position);
					
					for(var cont = 0; cont < $('.pp-section').length; cont++){
						var link = '';
						if(options.anchors.length){
							link = options.anchors[cont];
						}
						if(options.navigation.tooltips !== 'undefined'){
							var tooltip = options.navigation.tooltips[cont];
							if(typeof tooltip === 'undefined'){
								tooltip = '';
							}
						}
						
						nav.find('ul').append(`<li data-tooltip="${tooltip}">
							<a href="#${link}">
								<span></span>
							</a>
							<span class="pp-tooltip ${options.navigation.position}">${tooltip}</span>
						</li>`);
					}
				}
				
				/**
				* Activating the website navigation dots according to the given slide name.
				*/
				function activateNavDots(name, sectionIndex){
					if(options.navigation){
						$('#pp-nav').find('.active').removeClass('active');
						if(name){
							$('#pp-nav').find('a[href="#' + name + '"]').addClass('active');
						}else{
							$('#pp-nav').find('li').eq(sectionIndex).find('a').addClass('active');
						}
					}
				}
				
				/**
				* Activating the website main menu elements according to the given slide name.
				*/
				function activateMenuElement(name){
					if(options.menu){
						$(options.menu).find('.active').removeClass('active');
						$(options.menu).find('[data-menuanchor="'+name+'"]').addClass('active');
					}
				}
				
				/**
				* Checks for translate3d support
				* @return boolean
				* http://stackoverflow.com/questions/5661671/detecting-transform-translate3d-support
				*/
				function support3d() {
					var el = document.createElement('p'),
					has3d,
					transforms = {
						'webkitTransform':'-webkit-transform',
						'OTransform':'-o-transform',
						'msTransform':'-ms-transform',
						'MozTransform':'-moz-transform',
						'transform':'transform'
					};
					
					// Add it to the body to get the computed style.
					document.body.insertBefore(el, null);
					
					for (var t in transforms) {
						if (el.style[t] !== undefined) {
							el.style[t] = 'translate3d(1px,1px,1px)';
							has3d = window.getComputedStyle(el).getPropertyValue(transforms[t]);
						}
					}
					
					document.body.removeChild(el);
					
					return (has3d !== undefined && has3d.length > 0 && has3d !== 'none');
				}
				
				/**
				* Gets the translate3d property to apply when using css3:true depending on the `direction` option.
				*/
				function getTranslate3d(){
					if (options.direction !== 'vertical') {
						return 'translate3d(-100%, 0px, 0px)';
					}
					
					return 'translate3d(0px, -100%, 0px)';
				}
				
			};
		})(jQuery, document, window);