/* locomotive-scroll v4.0.6 | MIT License | https://github.com/locomotivemtl/locomotive-scroll */
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.LocomotiveScroll = factory());
}(this, (function () { 'use strict';

	function _classCallCheck(instance, Constructor) {
		if (!(instance instanceof Constructor)) {
			throw new TypeError("Cannot call a class as a function");
		}
	}

	function _defineProperties(target, props) {
		for (var i = 0; i < props.length; i++) {
			var descriptor = props[i];
			descriptor.enumerable = descriptor.enumerable || false;
			descriptor.configurable = true;
			if ("value" in descriptor) descriptor.writable = true;
			Object.defineProperty(target, descriptor.key, descriptor);
		}
	}

	function _createClass(Constructor, protoProps, staticProps) {
		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
		if (staticProps) _defineProperties(Constructor, staticProps);
		return Constructor;
	}

	function _defineProperty(obj, key, value) {
		if (key in obj) {
			Object.defineProperty(obj, key, {
				value: value,
				enumerable: true,
				configurable: true,
				writable: true
			});
		} else {
			obj[key] = value;
		}

		return obj;
	}

	function ownKeys(object, enumerableOnly) {
		var keys = Object.keys(object);

		if (Object.getOwnPropertySymbols) {
			var symbols = Object.getOwnPropertySymbols(object);
			if (enumerableOnly) symbols = symbols.filter(function (sym) {
				return Object.getOwnPropertyDescriptor(object, sym).enumerable;
			});
			keys.push.apply(keys, symbols);
		}

		return keys;
	}

	function _objectSpread2(target) {
		for (var i = 1; i < arguments.length; i++) {
			var source = arguments[i] != null ? arguments[i] : {};

			if (i % 2) {
				ownKeys(Object(source), true).forEach(function (key) {
					_defineProperty(target, key, source[key]);
				});
			} else if (Object.getOwnPropertyDescriptors) {
				Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
			} else {
				ownKeys(Object(source)).forEach(function (key) {
					Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
				});
			}
		}

		return target;
	}

	function _inherits(subClass, superClass) {
		if (typeof superClass !== "function" && superClass !== null) {
			throw new TypeError("Super expression must either be null or a function");
		}

		subClass.prototype = Object.create(superClass && superClass.prototype, {
			constructor: {
				value: subClass,
				writable: true,
				configurable: true
			}
		});
		if (superClass) _setPrototypeOf(subClass, superClass);
	}

	function _getPrototypeOf(o) {
		_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
			return o.__proto__ || Object.getPrototypeOf(o);
		};
		return _getPrototypeOf(o);
	}

	function _setPrototypeOf(o, p) {
		_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
			o.__proto__ = p;
			return o;
		};

		return _setPrototypeOf(o, p);
	}

	function _isNativeReflectConstruct() {
		if (typeof Reflect === "undefined" || !Reflect.construct) return false;
		if (Reflect.construct.sham) return false;
		if (typeof Proxy === "function") return true;

		try {
			Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
			return true;
		} catch (e) {
			return false;
		}
	}

	function _assertThisInitialized(self) {
		if (self === void 0) {
			throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		}

		return self;
	}

	function _possibleConstructorReturn(self, call) {
		if (call && (typeof call === "object" || typeof call === "function")) {
			return call;
		}

		return _assertThisInitialized(self);
	}

	function _createSuper(Derived) {
		var hasNativeReflectConstruct = _isNativeReflectConstruct();

		return function _createSuperInternal() {
			var Super = _getPrototypeOf(Derived),
					result;

			if (hasNativeReflectConstruct) {
				var NewTarget = _getPrototypeOf(this).constructor;

				result = Reflect.construct(Super, arguments, NewTarget);
			} else {
				result = Super.apply(this, arguments);
			}

			return _possibleConstructorReturn(this, result);
		};
	}

	function _superPropBase(object, property) {
		while (!Object.prototype.hasOwnProperty.call(object, property)) {
			object = _getPrototypeOf(object);
			if (object === null) break;
		}

		return object;
	}

	function _get(target, property, receiver) {
		if (typeof Reflect !== "undefined" && Reflect.get) {
			_get = Reflect.get;
		} else {
			_get = function _get(target, property, receiver) {
				var base = _superPropBase(target, property);

				if (!base) return;
				var desc = Object.getOwnPropertyDescriptor(base, property);

				if (desc.get) {
					return desc.get.call(receiver);
				}

				return desc.value;
			};
		}

		return _get(target, property, receiver || target);
	}

	function _slicedToArray(arr, i) {
		return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
	}

	function _toConsumableArray(arr) {
		return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
	}

	function _arrayWithoutHoles(arr) {
		if (Array.isArray(arr)) return _arrayLikeToArray(arr);
	}

	function _arrayWithHoles(arr) {
		if (Array.isArray(arr)) return arr;
	}

	function _iterableToArray(iter) {
		if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
	}

	function _iterableToArrayLimit(arr, i) {
		if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
		var _arr = [];
		var _n = true;
		var _d = false;
		var _e = undefined;

		try {
			for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
				_arr.push(_s.value);

				if (i && _arr.length === i) break;
			}
		} catch (err) {
			_d = true;
			_e = err;
		} finally {
			try {
				if (!_n && _i["return"] != null) _i["return"]();
			} finally {
				if (_d) throw _e;
			}
		}

		return _arr;
	}

	function _unsupportedIterableToArray(o, minLen) {
		if (!o) return;
		if (typeof o === "string") return _arrayLikeToArray(o, minLen);
		var n = Object.prototype.toString.call(o).slice(8, -1);
		if (n === "Object" && o.constructor) n = o.constructor.name;
		if (n === "Map" || n === "Set") return Array.from(o);
		if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
	}

	function _arrayLikeToArray(arr, len) {
		if (len == null || len > arr.length) len = arr.length;

		for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

		return arr2;
	}

	function _nonIterableSpread() {
		throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}

	function _nonIterableRest() {
		throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}

	var defaults = {
		el: document,
		name: 'scroll',
		offset: [0, 0],
		repeat: false,
		smooth: false,
		direction: 'vertical',
		gestureDirection: 'vertical',
		reloadOnContextChange: false,
		lerp: 0.1,
		"class": 'is-inview',
		scrollbarContainer: false,
		scrollbarClass: 'c-scrollbar',
		scrollingClass: 'has-scroll-scrolling',
		draggingClass: 'has-scroll-dragging',
		smoothClass: 'has-scroll-smooth',
		initClass: 'has-scroll-init',
		getSpeed: false,
		getDirection: false,
		scrollFromAnywhere: false,
		multiplier: 1,
		firefoxMultiplier: 50,
		touchMultiplier: 2,
		resetNativeScroll: true,
		tablet: {
			smooth: true,
			direction: 'vertical',
			gestureDirection: 'vertical',
			breakpoint: 1024
		},
		smartphone: {
			smooth: false,
			direction: 'vertical',
			gestureDirection: 'vertical'
		}
	};

	var _default = /*#__PURE__*/function () {
		function _default() {
			var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			_classCallCheck(this, _default);

			Object.assign(this, defaults, options);
			this.smartphone = defaults.smartphone;
			if (options.smartphone) Object.assign(this.smartphone, options.smartphone);
			this.tablet = defaults.tablet;
			if (options.tablet) Object.assign(this.tablet, options.tablet);
			this.namespace = 'locomotive';
			this.html = document.documentElement;
			this.windowHeight = window.innerHeight;
			this.windowWidth = window.innerWidth;
			this.windowMiddle = {
				x: this.windowWidth / 2,
				y: this.windowHeight / 2
			};
			this.els = {};
			this.currentElements = {};
			this.listeners = {};
			this.hasScrollTicking = false;
			this.hasCallEventSet = false;
			this.checkScroll = this.checkScroll.bind(this);
			this.checkResize = this.checkResize.bind(this);
			this.checkEvent = this.checkEvent.bind(this);
			this.instance = {
				scroll: {
					x: 0,
					y: 0
				},
				limit: {
					x: this.html.offsetHeight,
					y: this.html.offsetHeight
				},
				currentElements: this.currentElements
			};

			if (this.isMobile) {
				if (this.isTablet) {
					this.context = 'tablet';
				} else {
					this.context = 'smartphone';
				}
			} else {
				this.context = 'desktop';
			}

			if (this.isMobile) this.direction = this[this.context].direction;

			if (this.direction === 'horizontal') {
				this.directionAxis = 'x';
			} else {
				this.directionAxis = 'y';
			}

			if (this.getDirection) {
				this.instance.direction = null;
			}

			if (this.getDirection) {
				this.instance.speed = 0;
			}

			this.html.classList.add(this.initClass);
			window.addEventListener('resize', this.checkResize, false);
		}

		_createClass(_default, [{
			key: "init",
			value: function init() {
				this.initEvents();
			}
		}, {
			key: "checkScroll",
			value: function checkScroll() {
				this.dispatchScroll();
			}
		}, {
			key: "checkResize",
			value: function checkResize() {
				var _this = this;

				if (!this.resizeTick) {
					this.resizeTick = true;
					requestAnimationFrame(function () {
						_this.resize();

						_this.resizeTick = false;
					});
				}
			}
		}, {
			key: "resize",
			value: function resize() {}
		}, {
			key: "checkContext",
			value: function checkContext() {
				if (!this.reloadOnContextChange) return;
				this.isMobile = /Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1 || this.windowWidth < this.tablet.breakpoint;
				this.isTablet = this.isMobile && this.windowWidth >= this.tablet.breakpoint;
				var oldContext = this.context;

				if (this.isMobile) {
					if (this.isTablet) {
						this.context = 'tablet';
					} else {
						this.context = 'smartphone';
					}
				} else {
					this.context = 'desktop';
				}

				if (oldContext != this.context) {
					var oldSmooth = oldContext == 'desktop' ? this.smooth : this[oldContext].smooth;
					var newSmooth = this.context == 'desktop' ? this.smooth : this[this.context].smooth;
					if (oldSmooth != newSmooth) window.location.reload();
				}
			}
		}, {
			key: "initEvents",
			value: function initEvents() {
				var _this2 = this;

				this.scrollToEls = this.el.querySelectorAll("[data-".concat(this.name, "-to]"));
				this.setScrollTo = this.setScrollTo.bind(this);
				this.scrollToEls.forEach(function (el) {
					el.addEventListener('click', _this2.setScrollTo, false);
				});
			}
		}, {
			key: "setScrollTo",
			value: function setScrollTo(event) {
				event.preventDefault();
				this.scrollTo(event.currentTarget.getAttribute("data-".concat(this.name, "-href")) || event.currentTarget.getAttribute('href'), {
					offset: event.currentTarget.getAttribute("data-".concat(this.name, "-offset"))
				});
			}
		}, {
			key: "addElements",
			value: function addElements() {}
		}, {
			key: "detectElements",
			value: function detectElements(hasCallEventSet) {
				var _this3 = this;

				var scrollTop = this.instance.scroll.y;
				var scrollBottom = scrollTop + this.windowHeight;
				var scrollLeft = this.instance.scroll.x;
				var scrollRight = scrollLeft + this.windowWidth;
				Object.entries(this.els).forEach(function (_ref) {
					var _ref2 = _slicedToArray(_ref, 2),
							i = _ref2[0],
							el = _ref2[1];

					if (el && (!el.inView || hasCallEventSet)) {
						if (_this3.direction === 'horizontal') {
							if (scrollRight >= el.left && scrollLeft < el.right) {
								_this3.setInView(el, i);
							}
						} else {
							if (scrollBottom >= el.top && scrollTop < el.bottom) {
								_this3.setInView(el, i);
							}
						}
					}

					if (el && el.inView) {
						if (_this3.direction === 'horizontal') {
							var width = el.right - el.left;
							el.progress = (_this3.instance.scroll.x - (el.left - _this3.windowWidth)) / (width + _this3.windowWidth);

							if (scrollRight < el.left || scrollLeft > el.right) {
								_this3.setOutOfView(el, i);
							}
						} else {
							var height = el.bottom - el.top;
							el.progress = (_this3.instance.scroll.y - (el.top - _this3.windowHeight)) / (height + _this3.windowHeight);

							if (scrollBottom < el.top || scrollTop > el.bottom) {
								_this3.setOutOfView(el, i);
							}
						}
					}
				}); // this.els = this.els.filter((current, i) => {
				//     return current !== null;
				// });

				this.hasScrollTicking = false;
			}
		}, {
			key: "setInView",
			value: function setInView(current, i) {
				this.els[i].inView = true;
				current.el.classList.add(current["class"]);
				this.currentElements[i] = current;

				if (current.call && this.hasCallEventSet) {
					this.dispatchCall(current, 'enter');

					if (!current.repeat) {
						this.els[i].call = false;
					}
				} // if (!current.repeat && !current.speed && !current.sticky) {
				//     if (!current.call || current.call && this.hasCallEventSet) {
				//        this.els[i] = null
				//     }
				// }

			}
		}, {
			key: "setOutOfView",
			value: function setOutOfView(current, i) {
				var _this4 = this;

				// if (current.repeat || current.speed !== undefined) {
				this.els[i].inView = false; // }

				Object.keys(this.currentElements).forEach(function (el) {
					el === i && delete _this4.currentElements[el];
				});

				if (current.call && this.hasCallEventSet) {
					this.dispatchCall(current, 'exit');
				}

				if (current.repeat) {
					current.el.classList.remove(current["class"]);
				}
			}
		}, {
			key: "dispatchCall",
			value: function dispatchCall(current, way) {
				this.callWay = way;
				this.callValue = current.call.split(',').map(function (item) {
					return item.trim();
				});
				this.callObj = current;
				if (this.callValue.length == 1) this.callValue = this.callValue[0];
				var callEvent = new Event(this.namespace + 'call');
				this.el.dispatchEvent(callEvent);
			}
		}, {
			key: "dispatchScroll",
			value: function dispatchScroll() {
				var scrollEvent = new Event(this.namespace + 'scroll');
				this.el.dispatchEvent(scrollEvent);
			}
		}, {
			key: "setEvents",
			value: function setEvents(event, func) {
				if (!this.listeners[event]) {
					this.listeners[event] = [];
				}

				var list = this.listeners[event];
				list.push(func);

				if (list.length === 1) {
					this.el.addEventListener(this.namespace + event, this.checkEvent, false);
				}

				if (event === 'call') {
					this.hasCallEventSet = true;
					this.detectElements(true);
				}
			}
		}, {
			key: "unsetEvents",
			value: function unsetEvents(event, func) {
				if (!this.listeners[event]) return;
				var list = this.listeners[event];
				var index = list.indexOf(func);
				if (index < 0) return;
				list.splice(index, 1);

				if (list.index === 0) {
					this.el.removeEventListener(this.namespace + event, this.checkEvent, false);
				}
			}
		}, {
			key: "checkEvent",
			value: function checkEvent(event) {
				var _this5 = this;

				var name = event.type.replace(this.namespace, '');
				var list = this.listeners[name];
				if (!list || list.length === 0) return;
				list.forEach(function (func) {
					switch (name) {
						case 'scroll':
							return func(_this5.instance);

						case 'call':
							return func(_this5.callValue, _this5.callWay, _this5.callObj);

						default:
							return func();
					}
				});
			}
		}, {
			key: "startScroll",
			value: function startScroll() {}
		}, {
			key: "stopScroll",
			value: function stopScroll() {}
		}, {
			key: "setScroll",
			value: function setScroll(x, y) {
				this.instance.scroll = {
					x: 0,
					y: 0
				};
			}
		}, {
			key: "destroy",
			value: function destroy() {
				var _this6 = this;

				window.removeEventListener('resize', this.checkResize, false);
				Object.keys(this.listeners).forEach(function (event) {
					_this6.el.removeEventListener(_this6.namespace + event, _this6.checkEvent, false);
				});
				this.listeners = {};
				this.scrollToEls.forEach(function (el) {
					el.removeEventListener('click', _this6.setScrollTo, false);
				});
				this.html.classList.remove(this.initClass);
			}
		}]);

		return _default;
	}();

	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

	function createCommonjsModule(fn, module) {
			return module = { exports: {} }, fn(module, module.exports), module.exports;
	}

	var smoothscroll = createCommonjsModule(function (module, exports) {
	/* smoothscroll v0.4.4 - 2019 - Dustan Kasten, Jeremias Menichelli - MIT License */
	(function () {

		// polyfill
		function polyfill() {
			// aliases
			var w = window;
			var d = document;

			// return if scroll behavior is supported and polyfill is not forced
			if (
				'scrollBehavior' in d.documentElement.style &&
				w.__forceSmoothScrollPolyfill__ !== true
			) {
				return;
			}

			// globals
			var Element = w.HTMLElement || w.Element;
			var SCROLL_TIME = 468;

			// object gathering original scroll methods
			var original = {
				scroll: w.scroll || w.scrollTo,
				scrollBy: w.scrollBy,
				elementScroll: Element.prototype.scroll || scrollElement,
				scrollIntoView: Element.prototype.scrollIntoView
			};

			// define timing method
			var now =
				w.performance && w.performance.now
					? w.performance.now.bind(w.performance)
					: Date.now;

			/**
			 * indicates if a the current browser is made by Microsoft
			 * @method isMicrosoftBrowser
			 * @param {String} userAgent
			 * @returns {Boolean}
			 */
			function isMicrosoftBrowser(userAgent) {
				var userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];

				return new RegExp(userAgentPatterns.join('|')).test(userAgent);
			}

			/*
			 * IE has rounding bug rounding down clientHeight and clientWidth and
			 * rounding up scrollHeight and scrollWidth causing false positives
			 * on hasScrollableSpace
			 */
			var ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;

			/**
			 * changes scroll position inside an element
			 * @method scrollElement
			 * @param {Number} x
			 * @param {Number} y
			 * @returns {undefined}
			 */
			function scrollElement(x, y) {
				this.scrollLeft = x;
				this.scrollTop = y;
			}

			/**
			 * returns result of applying ease math function to a number
			 * @method ease
			 * @param {Number} k
			 * @returns {Number}
			 */
			function ease(k) {
				return 0.5 * (1 - Math.cos(Math.PI * k));
			}

			/**
			 * indicates if a smooth behavior should be applied
			 * @method shouldBailOut
			 * @param {Number|Object} firstArg
			 * @returns {Boolean}
			 */
			function shouldBailOut(firstArg) {
				if (
					firstArg === null ||
					typeof firstArg !== 'object' ||
					firstArg.behavior === undefined ||
					firstArg.behavior === 'auto' ||
					firstArg.behavior === 'instant'
				) {
					// first argument is not an object/null
					// or behavior is auto, instant or undefined
					return true;
				}

				if (typeof firstArg === 'object' && firstArg.behavior === 'smooth') {
					// first argument is an object and behavior is smooth
					return false;
				}

				// throw error when behavior is not supported
				throw new TypeError(
					'behavior member of ScrollOptions ' +
						firstArg.behavior +
						' is not a valid value for enumeration ScrollBehavior.'
				);
			}

			/**
			 * indicates if an element has scrollable space in the provided axis
			 * @method hasScrollableSpace
			 * @param {Node} el
			 * @param {String} axis
			 * @returns {Boolean}
			 */
			function hasScrollableSpace(el, axis) {
				if (axis === 'Y') {
					return el.clientHeight + ROUNDING_TOLERANCE < el.scrollHeight;
				}

				if (axis === 'X') {
					return el.clientWidth + ROUNDING_TOLERANCE < el.scrollWidth;
				}
			}

			/**
			 * indicates if an element has a scrollable overflow property in the axis
			 * @method canOverflow
			 * @param {Node} el
			 * @param {String} axis
			 * @returns {Boolean}
			 */
			function canOverflow(el, axis) {
				var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];

				return overflowValue === 'auto' || overflowValue === 'scroll';
			}

			/**
			 * indicates if an element can be scrolled in either axis
			 * @method isScrollable
			 * @param {Node} el
			 * @param {String} axis
			 * @returns {Boolean}
			 */
			function isScrollable(el) {
				var isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');
				var isScrollableX = hasScrollableSpace(el, 'X') && canOverflow(el, 'X');

				return isScrollableY || isScrollableX;
			}

			/**
			 * finds scrollable parent of an element
			 * @method findScrollableParent
			 * @param {Node} el
			 * @returns {Node} el
			 */
			function findScrollableParent(el) {
				while (el !== d.body && isScrollable(el) === false) {
					el = el.parentNode || el.host;
				}

				return el;
			}

			/**
			 * self invoked function that, given a context, steps through scrolling
			 * @method step
			 * @param {Object} context
			 * @returns {undefined}
			 */
			function step(context) {
				var time = now();
				var value;
				var currentX;
				var currentY;
				var elapsed = (time - context.startTime) / SCROLL_TIME;

				// avoid elapsed times higher than one
				elapsed = elapsed > 1 ? 1 : elapsed;

				// apply easing to elapsed time
				value = ease(elapsed);

				currentX = context.startX + (context.x - context.startX) * value;
				currentY = context.startY + (context.y - context.startY) * value;

				context.method.call(context.scrollable, currentX, currentY);

				// scroll more if we have not reached our destination
				if (currentX !== context.x || currentY !== context.y) {
					w.requestAnimationFrame(step.bind(w, context));
				}
			}

			/**
			 * scrolls window or element with a smooth behavior
			 * @method smoothScroll
			 * @param {Object|Node} el
			 * @param {Number} x
			 * @param {Number} y
			 * @returns {undefined}
			 */
			function smoothScroll(el, x, y) {
				var scrollable;
				var startX;
				var startY;
				var method;
				var startTime = now();

				// define scroll context
				if (el === d.body) {
					scrollable = w;
					startX = w.scrollX || w.pageXOffset;
					startY = w.scrollY || w.pageYOffset;
					method = original.scroll;
				} else {
					scrollable = el;
					startX = el.scrollLeft;
					startY = el.scrollTop;
					method = scrollElement;
				}

				// scroll looping over a frame
				step({
					scrollable: scrollable,
					method: method,
					startTime: startTime,
					startX: startX,
					startY: startY,
					x: x,
					y: y
				});
			}

			// ORIGINAL METHODS OVERRIDES
			// w.scroll and w.scrollTo
			w.scroll = w.scrollTo = function() {
				// avoid action when no arguments are passed
				if (arguments[0] === undefined) {
					return;
				}

				// avoid smooth behavior if not required
				if (shouldBailOut(arguments[0]) === true) {
					original.scroll.call(
						w,
						arguments[0].left !== undefined
							? arguments[0].left
							: typeof arguments[0] !== 'object'
								? arguments[0]
								: w.scrollX || w.pageXOffset,
						// use top prop, second argument if present or fallback to scrollY
						arguments[0].top !== undefined
							? arguments[0].top
							: arguments[1] !== undefined
								? arguments[1]
								: w.scrollY || w.pageYOffset
					);

					return;
				}

				// LET THE SMOOTHNESS BEGIN!
				smoothScroll.call(
					w,
					d.body,
					arguments[0].left !== undefined
						? ~~arguments[0].left
						: w.scrollX || w.pageXOffset,
					arguments[0].top !== undefined
						? ~~arguments[0].top
						: w.scrollY || w.pageYOffset
				);
			};

			// w.scrollBy
			w.scrollBy = function() {
				// avoid action when no arguments are passed
				if (arguments[0] === undefined) {
					return;
				}

				// avoid smooth behavior if not required
				if (shouldBailOut(arguments[0])) {
					original.scrollBy.call(
						w,
						arguments[0].left !== undefined
							? arguments[0].left
							: typeof arguments[0] !== 'object' ? arguments[0] : 0,
						arguments[0].top !== undefined
							? arguments[0].top
							: arguments[1] !== undefined ? arguments[1] : 0
					);

					return;
				}

				// LET THE SMOOTHNESS BEGIN!
				smoothScroll.call(
					w,
					d.body,
					~~arguments[0].left + (w.scrollX || w.pageXOffset),
					~~arguments[0].top + (w.scrollY || w.pageYOffset)
				);
			};

			// Element.prototype.scroll and Element.prototype.scrollTo
			Element.prototype.scroll = Element.prototype.scrollTo = function() {
				// avoid action when no arguments are passed
				if (arguments[0] === undefined) {
					return;
				}

				// avoid smooth behavior if not required
				if (shouldBailOut(arguments[0]) === true) {
					// if one number is passed, throw error to match Firefox implementation
					if (typeof arguments[0] === 'number' && arguments[1] === undefined) {
						throw new SyntaxError('Value could not be converted');
					}

					original.elementScroll.call(
						this,
						// use left prop, first number argument or fallback to scrollLeft
						arguments[0].left !== undefined
							? ~~arguments[0].left
							: typeof arguments[0] !== 'object' ? ~~arguments[0] : this.scrollLeft,
						// use top prop, second argument or fallback to scrollTop
						arguments[0].top !== undefined
							? ~~arguments[0].top
							: arguments[1] !== undefined ? ~~arguments[1] : this.scrollTop
					);

					return;
				}

				var left = arguments[0].left;
				var top = arguments[0].top;

				// LET THE SMOOTHNESS BEGIN!
				smoothScroll.call(
					this,
					this,
					typeof left === 'undefined' ? this.scrollLeft : ~~left,
					typeof top === 'undefined' ? this.scrollTop : ~~top
				);
			};

			// Element.prototype.scrollBy
			Element.prototype.scrollBy = function() {
				// avoid action when no arguments are passed
				if (arguments[0] === undefined) {
					return;
				}

				// avoid smooth behavior if not required
				if (shouldBailOut(arguments[0]) === true) {
					original.elementScroll.call(
						this,
						arguments[0].left !== undefined
							? ~~arguments[0].left + this.scrollLeft
							: ~~arguments[0] + this.scrollLeft,
						arguments[0].top !== undefined
							? ~~arguments[0].top + this.scrollTop
							: ~~arguments[1] + this.scrollTop
					);

					return;
				}

				this.scroll({
					left: ~~arguments[0].left + this.scrollLeft,
					top: ~~arguments[0].top + this.scrollTop,
					behavior: arguments[0].behavior
				});
			};

			// Element.prototype.scrollIntoView
			Element.prototype.scrollIntoView = function() {
				// avoid smooth behavior if not required
				if (shouldBailOut(arguments[0]) === true) {
					original.scrollIntoView.call(
						this,
						arguments[0] === undefined ? true : arguments[0]
					);

					return;
				}

				// LET THE SMOOTHNESS BEGIN!
				var scrollableParent = findScrollableParent(this);
				var parentRects = scrollableParent.getBoundingClientRect();
				var clientRects = this.getBoundingClientRect();

				if (scrollableParent !== d.body) {
					// reveal element inside parent
					smoothScroll.call(
						this,
						scrollableParent,
						scrollableParent.scrollLeft + clientRects.left - parentRects.left,
						scrollableParent.scrollTop + clientRects.top - parentRects.top
					);

					// reveal parent in viewport unless is fixed
					if (w.getComputedStyle(scrollableParent).position !== 'fixed') {
						w.scrollBy({
							left: parentRects.left,
							top: parentRects.top,
							behavior: 'smooth'
						});
					}
				} else {
					// reveal element in viewport
					w.scrollBy({
						left: clientRects.left,
						top: clientRects.top,
						behavior: 'smooth'
					});
				}
			};
		}

		{
			// commonjs
			module.exports = { polyfill: polyfill };
		}

	}());
	});
	var smoothscroll_1 = smoothscroll.polyfill;

	var _default$1 = /*#__PURE__*/function (_Core) {
		_inherits(_default, _Core);

		var _super = _createSuper(_default);

		function _default() {
			var _this;

			var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			_classCallCheck(this, _default);

			_this = _super.call(this, options);

			if (_this.resetNativeScroll) {
				if (history.scrollRestoration) {
					history.scrollRestoration = 'manual';
				}

				window.scrollTo(0, 0);
			}

			window.addEventListener('scroll', _this.checkScroll, false);

			if (window.smoothscrollPolyfill === undefined) {
				window.smoothscrollPolyfill = smoothscroll;
				window.smoothscrollPolyfill.polyfill();
			}

			return _this;
		}

		_createClass(_default, [{
			key: "init",
			value: function init() {
				this.instance.scroll.y = window.pageYOffset;
				this.addElements();
				this.detectElements();

				_get(_getPrototypeOf(_default.prototype), "init", this).call(this);
			}
		}, {
			key: "checkScroll",
			value: function checkScroll() {
				var _this2 = this;

				_get(_getPrototypeOf(_default.prototype), "checkScroll", this).call(this);

				if (this.getDirection) {
					this.addDirection();
				}

				if (this.getSpeed) {
					this.addSpeed();
					this.speedTs = Date.now();
				}

				this.instance.scroll.y = window.pageYOffset;

				if (Object.entries(this.els).length) {
					if (!this.hasScrollTicking) {
						requestAnimationFrame(function () {
							_this2.detectElements();
						});
						this.hasScrollTicking = true;
					}
				}
			}
		}, {
			key: "addDirection",
			value: function addDirection() {
				if (window.pageYOffset > this.instance.scroll.y) {
					if (this.instance.direction !== 'down') {
						this.instance.direction = 'down';
					}
				} else if (window.pageYOffset < this.instance.scroll.y) {
					if (this.instance.direction !== 'up') {
						this.instance.direction = 'up';
					}
				}
			}
		}, {
			key: "addSpeed",
			value: function addSpeed() {
				if (window.pageYOffset != this.instance.scroll.y) {
					this.instance.speed = (window.pageYOffset - this.instance.scroll.y) / Math.max(1, Date.now() - this.speedTs);
				} else {
					this.instance.speed = 0;
				}
			}
		}, {
			key: "resize",
			value: function resize() {
				if (Object.entries(this.els).length) {
					this.windowHeight = window.innerHeight;
					this.updateElements();
				}
			}
		}, {
			key: "addElements",
			value: function addElements() {
				var _this3 = this;

				this.els = {};
				var els = this.el.querySelectorAll('[data-' + this.name + ']');
				els.forEach(function (el, index) {
					var BCR = el.getBoundingClientRect();
					var cl = el.dataset[_this3.name + 'Class'] || _this3["class"];
					var id = typeof el.dataset[_this3.name + 'Id'] === 'string' ? el.dataset[_this3.name + 'Id'] : index;
					var top;
					var left;
					var offset = typeof el.dataset[_this3.name + 'Offset'] === 'string' ? el.dataset[_this3.name + 'Offset'].split(',') : _this3.offset;
					var repeat = el.dataset[_this3.name + 'Repeat'];
					var call = el.dataset[_this3.name + 'Call'];
					var target = el.dataset[_this3.name + 'Target'];
					var targetEl;

					if (target !== undefined) {
						targetEl = document.querySelector("".concat(target));
					} else {
						targetEl = el;
					}

					var targetElBCR = targetEl.getBoundingClientRect();
					top = targetElBCR.top + _this3.instance.scroll.y;
					left = targetElBCR.left + _this3.instance.scroll.x;
					var bottom = top + targetEl.offsetHeight;
					var right = left + targetEl.offsetWidth;

					if (target === '#header') {
						console.log(top, bottom);
					}

					if (repeat == 'false') {
						repeat = false;
					} else if (repeat != undefined) {
						repeat = true;
					} else {
						repeat = _this3.repeat;
					}

					var relativeOffset = _this3.getRelativeOffset(offset);

					top = top + relativeOffset[0];
					bottom = bottom - relativeOffset[1];
					var mappedEl = {
						el: el,
						targetEl: targetEl,
						id: id,
						"class": cl,
						top: top,
						bottom: bottom,
						left: left,
						right: right,
						offset: offset,
						progress: 0,
						repeat: repeat,
						inView: false,
						call: call
					};
					_this3.els[id] = mappedEl;

					if (el.classList.contains(cl)) {
						_this3.setInView(_this3.els[id], id);
					}
				});
			}
		}, {
			key: "updateElements",
			value: function updateElements() {
				var _this4 = this;

				Object.entries(this.els).forEach(function (_ref) {
					var _ref2 = _slicedToArray(_ref, 2),
							i = _ref2[0],
							el = _ref2[1];

					var top = el.targetEl.getBoundingClientRect().top + _this4.instance.scroll.y;

					var bottom = top + el.targetEl.offsetHeight;

					var relativeOffset = _this4.getRelativeOffset(el.offset);

					_this4.els[i].top = top + relativeOffset[0];
					_this4.els[i].bottom = bottom - relativeOffset[1];
				});
				this.hasScrollTicking = false;
			}
		}, {
			key: "getRelativeOffset",
			value: function getRelativeOffset(offset) {
				var relativeOffset = [0, 0];

				if (offset) {
					for (var i = 0; i < offset.length; i++) {
						if (typeof offset[i] == 'string') {
							if (offset[i].includes('%')) {
								relativeOffset[i] = parseInt(offset[i].replace('%', '') * this.windowHeight / 100);
							} else {
								relativeOffset[i] = parseInt(offset[i]);
							}
						} else {
							relativeOffset[i] = offset[i];
						}
					}
				}

				return relativeOffset;
			}
			/**
			 * Scroll to a desired target.
			 *
			 * @param  Available options :
			 *          target {node, string, "top", "bottom", int} - The DOM element we want to scroll to
			 *          options {object} - Options object for additionnal settings.
			 * @return {void}
			 */

		}, {
			key: "scrollTo",
			value: function scrollTo(target) {
				var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
				// Parse options
				var offset = parseInt(options.offset) || 0; // An offset to apply on top of given `target` or `sourceElem`'s target

				var callback = options.callback ? options.callback : false; // function called when scrollTo completes (note that it won't wait for lerp to stabilize)

				if (typeof target === 'string') {
					// Selector or boundaries
					if (target === 'top') {
						target = this.html;
					} else if (target === 'bottom') {
						target = this.html.offsetHeight - window.innerHeight;
					} else {
						target = document.querySelector(target); // If the query fails, abort

						if (!target) {
							return;
						}
					}
				} else if (typeof target === 'number') {
					// Absolute coordinate
					target = parseInt(target);
				} else if (target && target.tagName) ; else {
					console.warn('`target` parameter is not valid');
					return;
				} // We have a target that is not a coordinate yet, get it


				if (typeof target !== 'number') {
					offset = target.getBoundingClientRect().top + offset + this.instance.scroll.y;
				} else {
					offset = target + offset;
				}

				if (callback) {
					offset = offset.toFixed();

					var onScroll = function onScroll() {
						if (window.pageYOffset.toFixed() === offset) {
							window.removeEventListener('scroll', onScroll);
							callback();
						}
					};

					window.addEventListener('scroll', onScroll);
				}

				window.scrollTo({
					top: offset,
					behavior: 'smooth'
				});
			}
		}, {
			key: "update",
			value: function update() {
				this.addElements();
				this.detectElements();
			}
		}, {
			key: "destroy",
			value: function destroy() {
				_get(_getPrototypeOf(_default.prototype), "destroy", this).call(this);

				window.removeEventListener('scroll', this.checkScroll, false);
			}
		}]);

		return _default;
	}(_default);

	/*
	object-assign
	(c) Sindre Sorhus
	@license MIT
	*/
	/* eslint-disable no-unused-vars */
	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
	var hasOwnProperty = Object.prototype.hasOwnProperty;
	var propIsEnumerable = Object.prototype.propertyIsEnumerable;

	function toObject(val) {
			if (val === null || val === undefined) {
					throw new TypeError('Object.assign cannot be called with null or undefined');
			}

			return Object(val);
	}

	function shouldUseNative() {
			try {
					if (!Object.assign) {
							return false;
					}

					// Detect buggy property enumeration order in older V8 versions.

					// https://bugs.chromium.org/p/v8/issues/detail?id=4118
					var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
					test1[5] = 'de';
					if (Object.getOwnPropertyNames(test1)[0] === '5') {
							return false;
					}

					// https://bugs.chromium.org/p/v8/issues/detail?id=3056
					var test2 = {};
					for (var i = 0; i < 10; i++) {
							test2['_' + String.fromCharCode(i)] = i;
					}
					var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
							return test2[n];
					});
					if (order2.join('') !== '0123456789') {
							return false;
					}

					// https://bugs.chromium.org/p/v8/issues/detail?id=3056
					var test3 = {};
					'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
							test3[letter] = letter;
					});
					if (Object.keys(Object.assign({}, test3)).join('') !==
									'abcdefghijklmnopqrst') {
							return false;
					}

					return true;
			} catch (err) {
					// We don't expect any of the above to throw, but better to be safe.
					return false;
			}
	}

	var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
			var from;
			var to = toObject(target);
			var symbols;

			for (var s = 1; s < arguments.length; s++) {
					from = Object(arguments[s]);

					for (var key in from) {
							if (hasOwnProperty.call(from, key)) {
									to[key] = from[key];
							}
					}

					if (getOwnPropertySymbols) {
							symbols = getOwnPropertySymbols(from);
							for (var i = 0; i < symbols.length; i++) {
									if (propIsEnumerable.call(from, symbols[i])) {
											to[symbols[i]] = from[symbols[i]];
									}
							}
					}
			}

			return to;
	};

	function E () {
		// Keep this empty so it's easier to inherit from
		// (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
	}

	E.prototype = {
		on: function (name, callback, ctx) {
			var e = this.e || (this.e = {});

			(e[name] || (e[name] = [])).push({
				fn: callback,
				ctx: ctx
			});

			return this;
		},

		once: function (name, callback, ctx) {
			var self = this;
			function listener () {
				self.off(name, listener);
				callback.apply(ctx, arguments);
			}
			listener._ = callback;
			return this.on(name, listener, ctx);
		},

		emit: function (name) {
			var data = [].slice.call(arguments, 1);
			var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
			var i = 0;
			var len = evtArr.length;

			for (i; i < len; i++) {
				evtArr[i].fn.apply(evtArr[i].ctx, data);
			}

			return this;
		},

		off: function (name, callback) {
			var e = this.e || (this.e = {});
			var evts = e[name];
			var liveEvents = [];

			if (evts && callback) {
				for (var i = 0, len = evts.length; i < len; i++) {
					if (evts[i].fn !== callback && evts[i].fn._ !== callback)
						liveEvents.push(evts[i]);
				}
			}

			// Remove event from queue to prevent memory leak
			// Suggested by https://github.com/lazd
			// Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910

			(liveEvents.length)
				? e[name] = liveEvents
				: delete e[name];

			return this;
		}
	};

	var tinyEmitter = E;

	var lethargy = createCommonjsModule(function (module, exports) {
	// Generated by CoffeeScript 1.9.2
	(function() {
		var root;

		root =  exports !== null ? exports : this;

		root.Lethargy = (function() {
			function Lethargy(stability, sensitivity, tolerance, delay) {
				this.stability = stability != null ? Math.abs(stability) : 8;
				this.sensitivity = sensitivity != null ? 1 + Math.abs(sensitivity) : 100;
				this.tolerance = tolerance != null ? 1 + Math.abs(tolerance) : 1.1;
				this.delay = delay != null ? delay : 150;
				this.lastUpDeltas = (function() {
					var i, ref, results;
					results = [];
					for (i = 1, ref = this.stability * 2; 1 <= ref ? i <= ref : i >= ref; 1 <= ref ? i++ : i--) {
						results.push(null);
					}
					return results;
				}).call(this);
				this.lastDownDeltas = (function() {
					var i, ref, results;
					results = [];
					for (i = 1, ref = this.stability * 2; 1 <= ref ? i <= ref : i >= ref; 1 <= ref ? i++ : i--) {
						results.push(null);
					}
					return results;
				}).call(this);
				this.deltasTimestamp = (function() {
					var i, ref, results;
					results = [];
					for (i = 1, ref = this.stability * 2; 1 <= ref ? i <= ref : i >= ref; 1 <= ref ? i++ : i--) {
						results.push(null);
					}
					return results;
				}).call(this);
			}

			Lethargy.prototype.check = function(e) {
				var lastDelta;
				e = e.originalEvent || e;
				if (e.wheelDelta != null) {
					lastDelta = e.wheelDelta;
				} else if (e.deltaY != null) {
					lastDelta = e.deltaY * -40;
				} else if ((e.detail != null) || e.detail === 0) {
					lastDelta = e.detail * -40;
				}
				this.deltasTimestamp.push(Date.now());
				this.deltasTimestamp.shift();
				if (lastDelta > 0) {
					this.lastUpDeltas.push(lastDelta);
					this.lastUpDeltas.shift();
					return this.isInertia(1);
				} else {
					this.lastDownDeltas.push(lastDelta);
					this.lastDownDeltas.shift();
					return this.isInertia(-1);
				}
			};

			Lethargy.prototype.isInertia = function(direction) {
				var lastDeltas, lastDeltasNew, lastDeltasOld, newAverage, newSum, oldAverage, oldSum;
				lastDeltas = direction === -1 ? this.lastDownDeltas : this.lastUpDeltas;
				if (lastDeltas[0] === null) {
					return direction;
				}
				if (this.deltasTimestamp[(this.stability * 2) - 2] + this.delay > Date.now() && lastDeltas[0] === lastDeltas[(this.stability * 2) - 1]) {
					return false;
				}
				lastDeltasOld = lastDeltas.slice(0, this.stability);
				lastDeltasNew = lastDeltas.slice(this.stability, this.stability * 2);
				oldSum = lastDeltasOld.reduce(function(t, s) {
					return t + s;
				});
				newSum = lastDeltasNew.reduce(function(t, s) {
					return t + s;
				});
				oldAverage = oldSum / lastDeltasOld.length;
				newAverage = newSum / lastDeltasNew.length;
				if (Math.abs(oldAverage) < Math.abs(newAverage * this.tolerance) && (this.sensitivity < Math.abs(newAverage))) {
					return direction;
				} else {
					return false;
				}
			};

			Lethargy.prototype.showLastUpDeltas = function() {
				return this.lastUpDeltas;
			};

			Lethargy.prototype.showLastDownDeltas = function() {
				return this.lastDownDeltas;
			};

			return Lethargy;

		})();

	}).call(commonjsGlobal);
	});

	var support = (function getSupport() {
			return {
					hasWheelEvent: 'onwheel' in document,
					hasMouseWheelEvent: 'onmousewheel' in document,
					hasTouch: ('ontouchstart' in window) || window.TouchEvent || window.DocumentTouch && document instanceof DocumentTouch,
					hasTouchWin: navigator.msMaxTouchPoints && navigator.msMaxTouchPoints > 1,
					hasPointer: !!window.navigator.msPointerEnabled,
					hasKeyDown: 'onkeydown' in document,
					isFirefox: navigator.userAgent.indexOf('Firefox') > -1
			};
	})();

	var toString = Object.prototype.toString,
			hasOwnProperty$1 = Object.prototype.hasOwnProperty;

	var bindallStandalone = function(object) {
			if(!object) return console.warn('bindAll requires at least one argument.');

			var functions = Array.prototype.slice.call(arguments, 1);

			if (functions.length === 0) {

					for (var method in object) {
							if(hasOwnProperty$1.call(object, method)) {
									if(typeof object[method] == 'function' && toString.call(object[method]) == "[object Function]") {
											functions.push(method);
									}
							}
					}
			}

			for(var i = 0; i < functions.length; i++) {
					var f = functions[i];
					object[f] = bind(object[f], object);
			}
	};

	/*
			Faster bind without specific-case checking. (see https://coderwall.com/p/oi3j3w).
			bindAll is only needed for events binding so no need to make slow fixes for constructor
			or partial application.
	*/
	function bind(func, context) {
		return function() {
			return func.apply(context, arguments);
		};
	}

	var Lethargy = lethargy.Lethargy;



	var EVT_ID = 'virtualscroll';

	var src = VirtualScroll;

	var keyCodes = {
			LEFT: 37,
			UP: 38,
			RIGHT: 39,
			DOWN: 40,
			SPACE: 32
	};

	function VirtualScroll(options) {
			bindallStandalone(this, '_onWheel', '_onMouseWheel', '_onTouchStart', '_onTouchMove', '_onKeyDown');

			this.el = window;
			if (options && options.el) {
					this.el = options.el;
					delete options.el;
			}
			this.options = objectAssign({
					mouseMultiplier: 1,
					touchMultiplier: 2,
					firefoxMultiplier: 15,
					keyStep: 120,
					preventTouch: false,
					unpreventTouchClass: 'vs-touchmove-allowed',
					limitInertia: false,
					useKeyboard: true,
					useTouch: true
			}, options);

			if (this.options.limitInertia) this._lethargy = new Lethargy();

			this._emitter = new tinyEmitter();
			this._event = {
					y: 0,
					x: 0,
					deltaX: 0,
					deltaY: 0
			};
			this.touchStartX = null;
			this.touchStartY = null;
			this.bodyTouchAction = null;

			if (this.options.passive !== undefined) {
					this.listenerOptions = {passive: this.options.passive};
			}
	}

	VirtualScroll.prototype._notify = function(e) {
			var evt = this._event;
			evt.x += evt.deltaX;
			evt.y += evt.deltaY;

		 this._emitter.emit(EVT_ID, {
					x: evt.x,
					y: evt.y,
					deltaX: evt.deltaX,
					deltaY: evt.deltaY,
					originalEvent: e
		 });
	};

	VirtualScroll.prototype._onWheel = function(e) {
			var options = this.options;
			if (this._lethargy && this._lethargy.check(e) === false) return;
			var evt = this._event;

			// In Chrome and in Firefox (at least the new one)
			evt.deltaX = e.wheelDeltaX || e.deltaX * -1;
			evt.deltaY = e.wheelDeltaY || e.deltaY * -1;

			// for our purpose deltamode = 1 means user is on a wheel mouse, not touch pad
			// real meaning: https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent#Delta_modes
			if(support.isFirefox && e.deltaMode == 1) {
					evt.deltaX *= options.firefoxMultiplier;
					evt.deltaY *= options.firefoxMultiplier;
			}

			evt.deltaX *= options.mouseMultiplier;
			evt.deltaY *= options.mouseMultiplier;

			this._notify(e);
	};

	VirtualScroll.prototype._onMouseWheel = function(e) {
			if (this.options.limitInertia && this._lethargy.check(e) === false) return;

			var evt = this._event;

			// In Safari, IE and in Chrome if 'wheel' isn't defined
			evt.deltaX = (e.wheelDeltaX) ? e.wheelDeltaX : 0;
			evt.deltaY = (e.wheelDeltaY) ? e.wheelDeltaY : e.wheelDelta;

			this._notify(e);
	};

	VirtualScroll.prototype._onTouchStart = function(e) {
			var t = (e.targetTouches) ? e.targetTouches[0] : e;
			this.touchStartX = t.pageX;
			this.touchStartY = t.pageY;
	};

	VirtualScroll.prototype._onTouchMove = function(e) {
			var options = this.options;
			if(options.preventTouch
					&& !e.target.classList.contains(options.unpreventTouchClass)) {
					e.preventDefault();
			}

			var evt = this._event;

			var t = (e.targetTouches) ? e.targetTouches[0] : e;

			evt.deltaX = (t.pageX - this.touchStartX) * options.touchMultiplier;
			evt.deltaY = (t.pageY - this.touchStartY) * options.touchMultiplier;

			this.touchStartX = t.pageX;
			this.touchStartY = t.pageY;

			this._notify(e);
	};

	VirtualScroll.prototype._onKeyDown = function(e) {
			var evt = this._event;
			evt.deltaX = evt.deltaY = 0;
			var windowHeight = window.innerHeight - 40;

			switch(e.keyCode) {
					case keyCodes.LEFT:
					case keyCodes.UP:
							evt.deltaY = this.options.keyStep;
							break;

					case keyCodes.RIGHT:
					case keyCodes.DOWN:
							evt.deltaY = - this.options.keyStep;
							break;
					case  e.shiftKey:
							evt.deltaY = windowHeight;
							break;
					case keyCodes.SPACE:
							evt.deltaY = - windowHeight;
							break;
					default:
							return;
			}

			this._notify(e);
	};

	VirtualScroll.prototype._bind = function() {
			if(support.hasWheelEvent) this.el.addEventListener('wheel', this._onWheel, this.listenerOptions);
			if(support.hasMouseWheelEvent) this.el.addEventListener('mousewheel', this._onMouseWheel, this.listenerOptions);

			if(support.hasTouch && this.options.useTouch) {
					this.el.addEventListener('touchstart', this._onTouchStart, this.listenerOptions);
					this.el.addEventListener('touchmove', this._onTouchMove, this.listenerOptions);
			}

			if(support.hasPointer && support.hasTouchWin) {
					this.bodyTouchAction = document.body.style.msTouchAction;
					document.body.style.msTouchAction = 'none';
					this.el.addEventListener('MSPointerDown', this._onTouchStart, true);
					this.el.addEventListener('MSPointerMove', this._onTouchMove, true);
			}

			if(support.hasKeyDown && this.options.useKeyboard) document.addEventListener('keydown', this._onKeyDown);
	};

	VirtualScroll.prototype._unbind = function() {
			if(support.hasWheelEvent) this.el.removeEventListener('wheel', this._onWheel);
			if(support.hasMouseWheelEvent) this.el.removeEventListener('mousewheel', this._onMouseWheel);

			if(support.hasTouch) {
					this.el.removeEventListener('touchstart', this._onTouchStart);
					this.el.removeEventListener('touchmove', this._onTouchMove);
			}

			if(support.hasPointer && support.hasTouchWin) {
					document.body.style.msTouchAction = this.bodyTouchAction;
					this.el.removeEventListener('MSPointerDown', this._onTouchStart, true);
					this.el.removeEventListener('MSPointerMove', this._onTouchMove, true);
			}

			if(support.hasKeyDown && this.options.useKeyboard) document.removeEventListener('keydown', this._onKeyDown);
	};

	VirtualScroll.prototype.on = function(cb, ctx) {
		this._emitter.on(EVT_ID, cb, ctx);

		var events = this._emitter.e;
		if (events && events[EVT_ID] && events[EVT_ID].length === 1) this._bind();
	};

	VirtualScroll.prototype.off = function(cb, ctx) {
		this._emitter.off(EVT_ID, cb, ctx);

		var events = this._emitter.e;
		if (!events[EVT_ID] || events[EVT_ID].length <= 0) this._unbind();
	};

	VirtualScroll.prototype.reset = function() {
			var evt = this._event;
			evt.x = 0;
			evt.y = 0;
	};

	VirtualScroll.prototype.destroy = function() {
			this._emitter.off();
			this._unbind();
	};

	function lerp(start, end, amt) {
		return (1 - amt) * start + amt * end;
	}

	function getTranslate(el) {
		var translate = {};
		if (!window.getComputedStyle) return;
		var style = getComputedStyle(el);
		var transform = style.transform || style.webkitTransform || style.mozTransform;
		var mat = transform.match(/^matrix3d\((.+)\)$/);

		if (mat) {
			translate.x = mat ? parseFloat(mat[1].split(', ')[12]) : 0;
			translate.y = mat ? parseFloat(mat[1].split(', ')[13]) : 0;
		} else {
			mat = transform.match(/^matrix\((.+)\)$/);
			translate.x = mat ? parseFloat(mat[1].split(', ')[4]) : 0;
			translate.y = mat ? parseFloat(mat[1].split(', ')[5]) : 0;
		}

		return translate;
	}

	/**
	 * Returns an array containing all the parent nodes of the given node
	 * @param  {object} node
	 * @return {array} parent nodes
	 */
	function getParents(elem) {
		// Set up a parent array
		var parents = []; // Push each parent element to the array

		for (; elem && elem !== document; elem = elem.parentNode) {
			parents.push(elem);
		} // Return our parent array


		return parents;
	} // https://gomakethings.com/how-to-get-the-closest-parent-element-with-a-matching-selector-using-vanilla-javascript/

	/**
	 * https://github.com/gre/bezier-easing
	 * BezierEasing - use bezier curve for transition easing function
	 * by Gaëtan Renaudeau 2014 - 2015 – MIT License
	 */

	// These values are established by empiricism with tests (tradeoff: performance VS precision)
	var NEWTON_ITERATIONS = 4;
	var NEWTON_MIN_SLOPE = 0.001;
	var SUBDIVISION_PRECISION = 0.0000001;
	var SUBDIVISION_MAX_ITERATIONS = 10;

	var kSplineTableSize = 11;
	var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);

	var float32ArraySupported = typeof Float32Array === 'function';

	function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
	function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
	function C (aA1)      { return 3.0 * aA1; }

	// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
	function calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }

	// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
	function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }

	function binarySubdivide (aX, aA, aB, mX1, mX2) {
		var currentX, currentT, i = 0;
		do {
			currentT = aA + (aB - aA) / 2.0;
			currentX = calcBezier(currentT, mX1, mX2) - aX;
			if (currentX > 0.0) {
				aB = currentT;
			} else {
				aA = currentT;
			}
		} while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
		return currentT;
	}

	function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {
	 for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
		 var currentSlope = getSlope(aGuessT, mX1, mX2);
		 if (currentSlope === 0.0) {
			 return aGuessT;
		 }
		 var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
		 aGuessT -= currentX / currentSlope;
	 }
	 return aGuessT;
	}

	function LinearEasing (x) {
		return x;
	}

	var src$1 = function bezier (mX1, mY1, mX2, mY2) {
		if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {
			throw new Error('bezier x values must be in [0, 1] range');
		}

		if (mX1 === mY1 && mX2 === mY2) {
			return LinearEasing;
		}

		// Precompute samples table
		var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
		for (var i = 0; i < kSplineTableSize; ++i) {
			sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
		}

		function getTForX (aX) {
			var intervalStart = 0.0;
			var currentSample = 1;
			var lastSample = kSplineTableSize - 1;

			for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
				intervalStart += kSampleStepSize;
			}
			--currentSample;

			// Interpolate to provide an initial guess for t
			var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
			var guessForT = intervalStart + dist * kSampleStepSize;

			var initialSlope = getSlope(guessForT, mX1, mX2);
			if (initialSlope >= NEWTON_MIN_SLOPE) {
				return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
			} else if (initialSlope === 0.0) {
				return guessForT;
			} else {
				return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
			}
		}

		return function BezierEasing (x) {
			// Because JavaScript number are imprecise, we should guarantee the extremes are right.
			if (x === 0) {
				return 0;
			}
			if (x === 1) {
				return 1;
			}
			return calcBezier(getTForX(x), mY1, mY2);
		};
	};

	var keyCodes$1 = {
		LEFT: 37,
		UP: 38,
		RIGHT: 39,
		DOWN: 40,
		SPACE: 32,
		TAB: 9,
		PAGEUP: 33,
		PAGEDOWN: 34,
		HOME: 36,
		END: 35
	};

	var _default$2 = /*#__PURE__*/function (_Core) {
		_inherits(_default, _Core);

		var _super = _createSuper(_default);

		function _default() {
			var _this;

			var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			_classCallCheck(this, _default);

			if (history.scrollRestoration) {
				history.scrollRestoration = 'manual';
			}

			window.scrollTo(0, 0);
			_this = _super.call(this, options);
			if (_this.inertia) _this.lerp = _this.inertia * 0.1;
			_this.isScrolling = false;
			_this.isDraggingScrollbar = false;
			_this.isTicking = false;
			_this.hasScrollTicking = false;
			_this.parallaxElements = {};
			_this.stop = false;
			_this.scrollbarContainer = options.scrollbarContainer;
			_this.checkKey = _this.checkKey.bind(_assertThisInitialized(_this));
			window.addEventListener('keydown', _this.checkKey, false);
			return _this;
		}

		_createClass(_default, [{
			key: "init",
			value: function init() {
				var _this2 = this;

				this.html.classList.add(this.smoothClass);
				this.html.setAttribute("data-".concat(this.name, "-direction"), this.direction);
				this.instance = _objectSpread2({
					delta: {
						x: 0,
						y: 0
					}
				}, this.instance);
				this.vs = new src({
					el: this.scrollFromAnywhere ? document : this.el,
					mouseMultiplier: navigator.platform.indexOf('Win') > -1 ? 1 : 0.4,
					firefoxMultiplier: this.firefoxMultiplier,
					touchMultiplier: this.touchMultiplier,
					useKeyboard: false,
					passive: true
				});
				this.vs.on(function (e) {
					if (_this2.stop) {
						return;
					}

					if (!_this2.isDraggingScrollbar) {
						requestAnimationFrame(function () {
							_this2.updateDelta(e);

							if (!_this2.isScrolling) _this2.startScrolling();
						});
					}
				});
				this.setScrollLimit();
				this.initScrollBar();
				this.addSections();
				this.addElements();
				this.checkScroll(true);
				this.transformElements(true, true);

				_get(_getPrototypeOf(_default.prototype), "init", this).call(this);
			}
		}, {
			key: "setScrollLimit",
			value: function setScrollLimit() {
				this.instance.limit.y = this.el.offsetHeight - this.windowHeight;

				if (this.direction === 'horizontal') {
					var totalWidth = 0;
					var nodes = this.el.children;

					for (var i = 0; i < nodes.length; i++) {
						totalWidth += nodes[i].offsetWidth;
					}

					this.instance.limit.x = totalWidth - this.windowWidth;
				}
			}
		}, {
			key: "startScrolling",
			value: function startScrolling() {
				this.startScrollTs = Date.now(); // Record timestamp

				this.isScrolling = true;
				this.checkScroll();
				this.html.classList.add(this.scrollingClass);
			}
		}, {
			key: "stopScrolling",
			value: function stopScrolling() {
				cancelAnimationFrame(this.checkScrollRaf); // Prevent checkScroll to continue looping

				if (this.scrollToRaf) {
					cancelAnimationFrame(this.scrollToRaf);
					this.scrollToRaf = null;
				}

				this.isScrolling = false;
				this.instance.scroll.y = Math.round(this.instance.scroll.y);
				this.html.classList.remove(this.scrollingClass);
			}
		}, {
			key: "checkKey",
			value: function checkKey(e) {
				var _this3 = this;

				if (this.stop) {
					// If we are stopped, we don't want any scroll to occur because of a keypress
					// Prevent tab to scroll to activeElement
					if (e.keyCode == keyCodes$1.TAB) {
						requestAnimationFrame(function () {
							// Make sure native scroll is always at top of page
							_this3.html.scrollTop = 0;
							document.body.scrollTop = 0;
							_this3.html.scrollLeft = 0;
							document.body.scrollLeft = 0;
						});
					}

					return;
				}

				switch (e.keyCode) {
					case keyCodes$1.TAB:
						// Do not remove the RAF
						// It allows to override the browser's native scrollTo, which is essential
						requestAnimationFrame(function () {
							// Make sure native scroll is always at top of page
							_this3.html.scrollTop = 0;
							document.body.scrollTop = 0;
							_this3.html.scrollLeft = 0;
							document.body.scrollLeft = 0; // Request scrollTo on the focusedElement, putting it at the center of the screen

							_this3.scrollTo(document.activeElement, {
								offset: -window.innerHeight / 2
							});
						});
						break;

					case keyCodes$1.UP:
						this.instance.delta[this.directionAxis] -= 240;
						break;

					case keyCodes$1.DOWN:
						this.instance.delta[this.directionAxis] += 240;
						break;

					case keyCodes$1.PAGEUP:
						this.instance.delta[this.directionAxis] -= window.innerHeight;
						break;

					case keyCodes$1.PAGEDOWN:
						this.instance.delta[this.directionAxis] += window.innerHeight;
						break;

					case keyCodes$1.HOME:
						this.instance.delta[this.directionAxis] -= this.instance.limit[this.directionAxis];
						break;

					case keyCodes$1.END:
						this.instance.delta[this.directionAxis] += this.instance.limit[this.directionAxis];
						break;

					case keyCodes$1.SPACE:
						if (!(document.activeElement instanceof HTMLInputElement) && !(document.activeElement instanceof HTMLTextAreaElement)) {
							if (e.shiftKey) {
								this.instance.delta[this.directionAxis] -= window.innerHeight;
							} else {
								this.instance.delta[this.directionAxis] += window.innerHeight;
							}
						}

						break;

					default:
						return;
				}

				if (this.instance.delta[this.directionAxis] < 0) this.instance.delta[this.directionAxis] = 0;
				if (this.instance.delta[this.directionAxis] > this.instance.limit[this.directionAxis]) this.instance.delta[this.directionAxis] = this.instance.limit[this.directionAxis];
				this.stopScrolling(); // Stop any movement, allows to kill any other `scrollTo` still happening

				this.isScrolling = true;
				this.checkScroll();
				this.html.classList.add(this.scrollingClass);
			}
		}, {
			key: "checkScroll",
			value: function checkScroll() {
				var _this4 = this;

				var forced = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

				if (forced || this.isScrolling || this.isDraggingScrollbar) {
					if (!this.hasScrollTicking) {
						this.checkScrollRaf = requestAnimationFrame(function () {
							return _this4.checkScroll();
						});
						this.hasScrollTicking = true;
					}

					this.updateScroll();
					var distance = Math.abs(this.instance.delta[this.directionAxis] - this.instance.scroll[this.directionAxis]);
					var timeSinceStart = Date.now() - this.startScrollTs; // Get the time since the scroll was started: the scroll can be stopped again only past 100ms

					if (!this.animatingScroll && timeSinceStart > 100 && (distance < 0.5 && this.instance.delta[this.directionAxis] != 0 || distance < 0.5 && this.instance.delta[this.directionAxis] == 0)) {
						this.stopScrolling();
					}

					Object.entries(this.sections).forEach(function (_ref) {
						var _ref2 = _slicedToArray(_ref, 2),
								i = _ref2[0],
								section = _ref2[1];

						if (section.persistent || _this4.instance.scroll[_this4.directionAxis] > section.offset[_this4.directionAxis] && _this4.instance.scroll[_this4.directionAxis] < section.limit[_this4.directionAxis]) {
							if (_this4.direction === 'horizontal') {
								_this4.transform(section.el, -_this4.instance.scroll[_this4.directionAxis], 0);
							} else {
								_this4.transform(section.el, 0, -_this4.instance.scroll[_this4.directionAxis]);
							}

							if (!section.inView) {
								section.inView = true;
								section.el.style.opacity = 1;
								section.el.style.pointerEvents = 'all';
								section.el.setAttribute("data-".concat(_this4.name, "-section-inview"), '');
							}
						} else {
							if (section.inView) {
								section.inView = false;
								section.el.style.opacity = 0;
								section.el.style.pointerEvents = 'none';
								section.el.removeAttribute("data-".concat(_this4.name, "-section-inview"));
							}

							_this4.transform(section.el, 0, 0);
						}
					});

					if (this.getDirection) {
						this.addDirection();
					}

					if (this.getSpeed) {
						this.addSpeed();
						this.speedTs = Date.now();
					}

					this.detectElements();
					this.transformElements();

					if (this.hasScrollbar) {
						var scrollBarTranslation = this.instance.scroll[this.directionAxis] / this.instance.limit[this.directionAxis] * this.scrollBarLimit[this.directionAxis];

						if (this.direction === 'horizontal') {
							this.transform(this.scrollbarThumb, scrollBarTranslation, 0);
						} else {
							this.transform(this.scrollbarThumb, 0, scrollBarTranslation);
						}
					}

					_get(_getPrototypeOf(_default.prototype), "checkScroll", this).call(this);

					this.hasScrollTicking = false;
				}
			}
		}, {
			key: "resize",
			value: function resize() {
				this.windowHeight = window.innerHeight;
				this.windowWidth = window.innerWidth;
				this.checkContext();
				this.windowMiddle = {
					x: this.windowWidth / 2,
					y: this.windowHeight / 2
				};
				this.update();
			}
		}, {
			key: "updateDelta",
			value: function updateDelta(e) {
				var delta;
				var gestureDirection = this[this.context] && this[this.context].gestureDirection ? this[this.context].gestureDirection : this.gestureDirection;

				if (gestureDirection === 'both') {
					delta = e.deltaX + e.deltaY;
				} else if (gestureDirection === 'vertical') {
					delta = e.deltaY;
				} else if (gestureDirection === 'horizontal') {
					delta = e.deltaX;
				} else {
					delta = e.deltaY;
				}

				this.instance.delta[this.directionAxis] -= delta * this.multiplier;
				if (this.instance.delta[this.directionAxis] < 0) this.instance.delta[this.directionAxis] = 0;
				if (this.instance.delta[this.directionAxis] > this.instance.limit[this.directionAxis]) this.instance.delta[this.directionAxis] = this.instance.limit[this.directionAxis];
			}
		}, {
			key: "updateScroll",
			value: function updateScroll(e) {
				if (this.isScrolling || this.isDraggingScrollbar) {
					this.instance.scroll[this.directionAxis] = lerp(this.instance.scroll[this.directionAxis], this.instance.delta[this.directionAxis], this.lerp);
				} else {
					if (this.instance.scroll[this.directionAxis] > this.instance.limit[this.directionAxis]) {
						this.setScroll(this.instance.scroll[this.directionAxis], this.instance.limit[this.directionAxis]);
					} else if (this.instance.scroll.y < 0) {
						this.setScroll(this.instance.scroll[this.directionAxis], 0);
					} else {
						this.setScroll(this.instance.scroll[this.directionAxis], this.instance.delta[this.directionAxis]);
					}
				}
			}
		}, {
			key: "addDirection",
			value: function addDirection() {
				if (this.instance.delta.y > this.instance.scroll.y) {
					if (this.instance.direction !== 'down') {
						this.instance.direction = 'down';
					}
				} else if (this.instance.delta.y < this.instance.scroll.y) {
					if (this.instance.direction !== 'up') {
						this.instance.direction = 'up';
					}
				}

				if (this.instance.delta.x > this.instance.scroll.x) {
					if (this.instance.direction !== 'right') {
						this.instance.direction = 'right';
					}
				} else if (this.instance.delta.x < this.instance.scroll.x) {
					if (this.instance.direction !== 'left') {
						this.instance.direction = 'left';
					}
				}
			}
		}, {
			key: "addSpeed",
			value: function addSpeed() {
				if (this.instance.delta[this.directionAxis] != this.instance.scroll[this.directionAxis]) {
					this.instance.speed = (this.instance.delta[this.directionAxis] - this.instance.scroll[this.directionAxis]) / Math.max(1, Date.now() - this.speedTs);
				} else {
					this.instance.speed = 0;
				}
			}
		}, {
			key: "initScrollBar",
			value: function initScrollBar() {
				this.scrollbar = document.createElement('span');
				this.scrollbarThumb = document.createElement('span');
				this.scrollbar.classList.add("".concat(this.scrollbarClass));
				this.scrollbarThumb.classList.add("".concat(this.scrollbarClass, "_thumb"));
				this.scrollbar.append(this.scrollbarThumb);

				if (this.scrollbarContainer) {
					this.scrollbarContainer.append(this.scrollbar);
				} else {
					document.body.append(this.scrollbar);
				} // Scrollbar Events


				this.getScrollBar = this.getScrollBar.bind(this);
				this.releaseScrollBar = this.releaseScrollBar.bind(this);
				this.moveScrollBar = this.moveScrollBar.bind(this);
				this.scrollbarThumb.addEventListener('mousedown', this.getScrollBar);
				window.addEventListener('mouseup', this.releaseScrollBar);
				window.addEventListener('mousemove', this.moveScrollBar); // Set scrollbar values

				this.hasScrollbar = false;

				if (this.direction == 'horizontal') {
					if (this.instance.limit.x + this.windowWidth <= this.windowWidth) {
						return;
					}
				} else {
					if (this.instance.limit.y + this.windowHeight <= this.windowHeight) {
						return;
					}
				}

				this.hasScrollbar = true;
				this.scrollbarBCR = this.scrollbar.getBoundingClientRect();
				this.scrollbarHeight = this.scrollbarBCR.height;
				this.scrollbarWidth = this.scrollbarBCR.width;

				if (this.direction === 'horizontal') {
					this.scrollbarThumb.style.width = "".concat(this.scrollbarWidth * this.scrollbarWidth / (this.instance.limit.x + this.scrollbarWidth), "px");
				} else {
					this.scrollbarThumb.style.height = "".concat(this.scrollbarHeight * this.scrollbarHeight / (this.instance.limit.y + this.scrollbarHeight), "px");
				}

				this.scrollbarThumbBCR = this.scrollbarThumb.getBoundingClientRect();
				this.scrollBarLimit = {
					x: this.scrollbarWidth - this.scrollbarThumbBCR.width,
					y: this.scrollbarHeight - this.scrollbarThumbBCR.height
				};
			}
		}, {
			key: "reinitScrollBar",
			value: function reinitScrollBar() {
				this.hasScrollbar = false;

				if (this.direction == 'horizontal') {
					if (this.instance.limit.x + this.windowWidth <= this.windowWidth) {
						return;
					}
				} else {
					if (this.instance.limit.y + this.windowHeight <= this.windowHeight) {
						return;
					}
				}

				this.hasScrollbar = true;
				this.scrollbarBCR = this.scrollbar.getBoundingClientRect();
				this.scrollbarHeight = this.scrollbarBCR.height;
				this.scrollbarWidth = this.scrollbarBCR.width;

				if (this.direction === 'horizontal') {
					this.scrollbarThumb.style.width = "".concat(this.scrollbarWidth * this.scrollbarWidth / (this.instance.limit.x + this.scrollbarWidth), "px");
				} else {
					this.scrollbarThumb.style.height = "".concat(this.scrollbarHeight * this.scrollbarHeight / (this.instance.limit.y + this.scrollbarHeight), "px");
				}

				this.scrollbarThumbBCR = this.scrollbarThumb.getBoundingClientRect();
				this.scrollBarLimit = {
					x: this.scrollbarWidth - this.scrollbarThumbBCR.width,
					y: this.scrollbarHeight - this.scrollbarThumbBCR.height
				};
			}
		}, {
			key: "destroyScrollBar",
			value: function destroyScrollBar() {
				this.scrollbarThumb.removeEventListener('mousedown', this.getScrollBar);
				window.removeEventListener('mouseup', this.releaseScrollBar);
				window.removeEventListener('mousemove', this.moveScrollBar);
				this.scrollbar.remove();
			}
		}, {
			key: "getScrollBar",
			value: function getScrollBar(e) {
				this.isDraggingScrollbar = true;
				this.checkScroll();
				this.html.classList.remove(this.scrollingClass);
				this.html.classList.add(this.draggingClass);
			}
		}, {
			key: "releaseScrollBar",
			value: function releaseScrollBar(e) {
				this.isDraggingScrollbar = false;
				this.html.classList.add(this.scrollingClass);
				this.html.classList.remove(this.draggingClass);
			}
		}, {
			key: "moveScrollBar",
			value: function moveScrollBar(e) {
				var _this5 = this;

				if (this.isDraggingScrollbar) {
					requestAnimationFrame(function () {
						var x = (e.clientX - _this5.scrollbarBCR.left) * 100 / _this5.scrollbarWidth * _this5.instance.limit.x / 100;
						var y = (e.clientY - _this5.scrollbarBCR.top) * 100 / _this5.scrollbarHeight * _this5.instance.limit.y / 100;

						if (y > 0 && y < _this5.instance.limit.y) {
							_this5.instance.delta.y = y;
						}

						if (x > 0 && x < _this5.instance.limit.x) {
							_this5.instance.delta.x = x;
						}
					});
				}
			}
		}, {
			key: "addElements",
			value: function addElements() {
				var _this6 = this;

				this.els = {};
				this.parallaxElements = {}; // this.sections.forEach((section, y) => {

				var els = this.el.querySelectorAll("[data-".concat(this.name, "]"));
				els.forEach(function (el, index) {
					// Try and find the target's parent section
					var targetParents = getParents(el);
					var section = Object.entries(_this6.sections).map(function (_ref3) {
						var _ref4 = _slicedToArray(_ref3, 2),
								key = _ref4[0],
								section = _ref4[1];

						return section;
					}).find(function (section) {
						return targetParents.includes(section.el);
					});
					var cl = el.dataset[_this6.name + 'Class'] || _this6["class"];
					var id = typeof el.dataset[_this6.name + 'Id'] === 'string' ? el.dataset[_this6.name + 'Id'] : 'el' + index;
					var top;
					var left;
					var repeat = el.dataset[_this6.name + 'Repeat'];
					var call = el.dataset[_this6.name + 'Call'];
					var position = el.dataset[_this6.name + 'Position'];
					var delay = el.dataset[_this6.name + 'Delay'];
					var direction = el.dataset[_this6.name + 'Direction'];
					var sticky = typeof el.dataset[_this6.name + 'Sticky'] === 'string';
					var speed = el.dataset[_this6.name + 'Speed'] ? parseFloat(el.dataset[_this6.name + 'Speed']) / 10 : false;
					var offset = typeof el.dataset[_this6.name + 'Offset'] === 'string' ? el.dataset[_this6.name + 'Offset'].split(',') : _this6.offset;
					var target = el.dataset[_this6.name + 'Target'];
					var targetEl;

					if (target !== undefined) {
						targetEl = document.querySelector("".concat(target));
					} else {
						targetEl = el;
					}

					var targetElBCR = targetEl.getBoundingClientRect();

					if (section === null) {
						top = targetElBCR.top + _this6.instance.scroll.y - getTranslate(targetEl).y;
						left = targetElBCR.left + _this6.instance.scroll.x - getTranslate(targetEl).x;
					} else {
						if (!section.inView) {
							top = targetElBCR.top - getTranslate(section.el).y - getTranslate(targetEl).y;
							left = targetElBCR.left - getTranslate(section.el).x - getTranslate(targetEl).x;
						} else {
							top = targetElBCR.top + _this6.instance.scroll.y - getTranslate(targetEl).y;
							left = targetElBCR.left + _this6.instance.scroll.x - getTranslate(targetEl).x;
						}
					}

					var bottom = top + targetEl.offsetHeight;
					var right = left + targetEl.offsetWidth;
					var middle = {
						x: (right - left) / 2 + left,
						y: (bottom - top) / 2 + top
					};

					if (sticky) {
						var elBCR = el.getBoundingClientRect();
						var elTop = elBCR.top;
						var elLeft = elBCR.left;
						var elDistance = {
							x: elLeft - left,
							y: elTop - top
						};
						top += window.innerHeight;
						left += window.innerWidth;
						bottom = elTop + targetEl.offsetHeight - el.offsetHeight - elDistance[_this6.directionAxis];
						right = elLeft + targetEl.offsetWidth - el.offsetWidth - elDistance[_this6.directionAxis];
						middle = {
							x: (right - left) / 2 + left,
							y: (bottom - top) / 2 + top
						};
					}

					if (repeat == 'false') {
						repeat = false;
					} else if (repeat != undefined) {
						repeat = true;
					} else {
						repeat = _this6.repeat;
					}

					var relativeOffset = [0, 0];

					if (offset) {
						if (_this6.direction === 'horizontal') {
							for (var i = 0; i < offset.length; i++) {
								if (typeof offset[i] == 'string') {
									if (offset[i].includes('%')) {
										relativeOffset[i] = parseInt(offset[i].replace('%', '') * _this6.windowWidth / 100);
									} else {
										relativeOffset[i] = parseInt(offset[i]);
									}
								} else {
									relativeOffset[i] = offset[i];
								}
							}

							left = left + relativeOffset[0];
							right = right - relativeOffset[1];
						} else {
							for (var i = 0; i < offset.length; i++) {
								if (typeof offset[i] == 'string') {
									if (offset[i].includes('%')) {
										relativeOffset[i] = parseInt(offset[i].replace('%', '') * _this6.windowHeight / 100);
									} else {
										relativeOffset[i] = parseInt(offset[i]);
									}
								} else {
									relativeOffset[i] = offset[i];
								}
							}

							top = top + relativeOffset[0];
							bottom = bottom - relativeOffset[1];
						}
					}

					var mappedEl = {
						el: el,
						id: id,
						"class": cl,
						section: section,
						top: top,
						middle: middle,
						bottom: bottom,
						left: left,
						right: right,
						offset: offset,
						progress: 0,
						repeat: repeat,
						inView: false,
						call: call,
						speed: speed,
						delay: delay,
						position: position,
						target: targetEl,
						direction: direction,
						sticky: sticky
					};
					_this6.els[id] = mappedEl;

					if (el.classList.contains(cl)) {
						_this6.setInView(_this6.els[id], id);
					}

					if (speed !== false || sticky) {
						_this6.parallaxElements[id] = mappedEl;
					}
				}); // });
			}
		}, {
			key: "addSections",
			value: function addSections() {
				var _this7 = this;

				this.sections = {};
				var sections = this.el.querySelectorAll("[data-".concat(this.name, "-section]"));

				if (sections.length === 0) {
					sections = [this.el];
				}

				sections.forEach(function (section, index) {
					var id = typeof section.dataset[_this7.name + 'Id'] === 'string' ? section.dataset[_this7.name + 'Id'] : 'section' + index;
					var sectionBCR = section.getBoundingClientRect();
					var offset = {
						x: sectionBCR.left - window.innerWidth * 1.5 - getTranslate(section).x,
						y: sectionBCR.top - window.innerHeight * 1.5 - getTranslate(section).y
					};
					var limit = {
						x: offset.x + sectionBCR.width + window.innerWidth * 2,
						y: offset.y + sectionBCR.height + window.innerHeight * 2
					};
					var persistent = typeof section.dataset[_this7.name + 'Persistent'] === 'string';
					section.setAttribute('data-scroll-section-id', id);
					var mappedSection = {
						el: section,
						offset: offset,
						limit: limit,
						inView: false,
						persistent: persistent,
						id: id
					};
					_this7.sections[id] = mappedSection;
				});
			}
		}, {
			key: "transform",
			value: function transform(element, x, y, delay) {
				var transform;

				if (!delay) {
					transform = "matrix3d(1,0,0.00,0,0.00,1,0.00,0,0,0,1,0,".concat(x, ",").concat(y, ",0,1)");
				} else {
					var start = getTranslate(element);
					var lerpX = lerp(start.x, x, delay);
					var lerpY = lerp(start.y, y, delay);
					transform = "matrix3d(1,0,0.00,0,0.00,1,0.00,0,0,0,1,0,".concat(lerpX, ",").concat(lerpY, ",0,1)");
				}

				element.style.webkitTransform = transform;
				element.style.msTransform = transform;
				element.style.transform = transform;
			}
		}, {
			key: "transformElements",
			value: function transformElements(isForced) {
				var _this8 = this;

				var setAllElements = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
				var scrollRight = this.instance.scroll.x + this.windowWidth;
				var scrollBottom = this.instance.scroll.y + this.windowHeight;
				var scrollMiddle = {
					x: this.instance.scroll.x + this.windowMiddle.x,
					y: this.instance.scroll.y + this.windowMiddle.y
				};
				Object.entries(this.parallaxElements).forEach(function (_ref5) {
					var _ref6 = _slicedToArray(_ref5, 2),
							i = _ref6[0],
							current = _ref6[1];

					var transformDistance = false;

					if (isForced) {
						transformDistance = 0;
					}

					if (current.inView || setAllElements) {
						switch (current.position) {
							case 'top':
								transformDistance = _this8.instance.scroll[_this8.directionAxis] * -current.speed;
								break;

							case 'elementTop':
								transformDistance = (scrollBottom - current.top) * -current.speed;
								break;

							case 'bottom':
								transformDistance = (_this8.instance.limit[_this8.directionAxis] - scrollBottom + _this8.windowHeight) * current.speed;
								break;

							case 'left':
								transformDistance = _this8.instance.scroll[_this8.directionAxis] * -current.speed;
								break;

							case 'elementLeft':
								transformDistance = (scrollRight - current.left) * -current.speed;
								break;

							case 'right':
								transformDistance = (_this8.instance.limit[_this8.directionAxis] - scrollRight + _this8.windowHeight) * current.speed;
								break;

							default:
								transformDistance = (scrollMiddle[_this8.directionAxis] - current.middle[_this8.directionAxis]) * -current.speed;
								break;
						}
					}

					if (current.sticky) {
						if (current.inView) {
							if (_this8.direction === 'horizontal') {
								transformDistance = _this8.instance.scroll.x - current.left + window.innerWidth;
							} else {
								transformDistance = _this8.instance.scroll.y - current.top + window.innerHeight;
							}
						} else {
							if (_this8.direction === 'horizontal') {
								if (_this8.instance.scroll.x < current.left - window.innerWidth && _this8.instance.scroll.x < current.left - window.innerWidth / 2) {
									transformDistance = 0;
								} else if (_this8.instance.scroll.x > current.right && _this8.instance.scroll.x > current.right + 100) {
									transformDistance = current.right - current.left + window.innerWidth;
								} else {
									transformDistance = false;
								}
							} else {
								if (_this8.instance.scroll.y < current.top - window.innerHeight && _this8.instance.scroll.y < current.top - window.innerHeight / 2) {
									transformDistance = 0;
								} else if (_this8.instance.scroll.y > current.bottom && _this8.instance.scroll.y > current.bottom + 100) {
									transformDistance = current.bottom - current.top + window.innerHeight;
								} else {
									transformDistance = false;
								}
							}
						}
					}

					if (transformDistance !== false) {
						if (current.direction === 'horizontal' || _this8.direction === 'horizontal' && current.direction !== 'vertical') {
							_this8.transform(current.el, transformDistance, 0, isForced ? false : current.delay);
						} else {
							_this8.transform(current.el, 0, transformDistance, isForced ? false : current.delay);
						}
					}
				});
			}
			/**
			 * Scroll to a desired target.
			 *
			 * @param  Available options :
			 *          target {node, string, "top", "bottom", int} - The DOM element we want to scroll to
			 *          options {object} - Options object for additionnal settings.
			 * @return {void}
			 */

		}, {
			key: "scrollTo",
			value: function scrollTo(target) {
				var _this9 = this;

				var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
				// Parse options
				var offset = parseInt(options.offset) || 0; // An offset to apply on top of given `target` or `sourceElem`'s target

				var duration = options.duration || 1000; // Duration of the scroll animation in milliseconds

				var easing = options.easing || [0.25, 0.0, 0.35, 1.0]; // An array of 4 floats between 0 and 1 defining the bezier curve for the animation's easing. See http://greweb.me/bezier-easing-editor/example/

				var disableLerp = options.disableLerp ? true : false; // Lerp effect won't be applied if set to true

				var callback = options.callback ? options.callback : false; // function called when scrollTo completes (note that it won't wait for lerp to stabilize)

				easing = src$1.apply(void 0, _toConsumableArray(easing));

				if (typeof target === 'string') {
					// Selector or boundaries
					if (target === 'top') {
						target = 0;
					} else if (target === 'bottom') {
						target = this.instance.limit.y;
					} else if (target === 'left') {
						target = 0;
					} else if (target === 'right') {
						target = this.instance.limit.x;
					} else {
						target = document.querySelector(target); // If the query fails, abort

						if (!target) {
							return;
						}
					}
				} else if (typeof target === 'number') {
					// Absolute coordinate
					target = parseInt(target);
				} else if (target && target.tagName) ; else {
					console.warn('`target` parameter is not valid');
					return;
				} // We have a target that is not a coordinate yet, get it


				if (typeof target !== 'number') {
					// Verify the given target belongs to this scroll scope
					var targetInScope = getParents(target).includes(this.el);

					if (!targetInScope) {
						// If the target isn't inside our main element, abort any action
						return;
					} // Get target offset from top


					var targetBCR = target.getBoundingClientRect();
					var offsetTop = targetBCR.top;
					var offsetLeft = targetBCR.left; // Try and find the target's parent section

					var targetParents = getParents(target);
					var parentSection = targetParents.find(function (candidate) {
						return Object.entries(_this9.sections) // Get sections associative array as a regular array
						.map(function (_ref7) {
							var _ref8 = _slicedToArray(_ref7, 2),
									key = _ref8[0],
									section = _ref8[1];

							return section;
						}) // map to section only (we dont need the key here)
						.find(function (section) {
							return section.el == candidate;
						}); // finally find the section that matches the candidate
					});
					var parentSectionOffset = 0;

					if (parentSection) {
						parentSectionOffset = getTranslate(parentSection)[this.directionAxis]; // We got a parent section, store it's current offset to remove it later
					} else {
						// if no parent section is found we need to use instance scroll directly
						parentSectionOffset = -this.instance.scroll[this.directionAxis];
					} // Final value of scroll destination : offsetTop + (optional offset given in options) - (parent's section translate)


					if (this.direction === 'horizontal') {
						offset = offsetLeft + offset - parentSectionOffset;
					} else {
						offset = offsetTop + offset - parentSectionOffset;
					}
				} else {
					offset = target + offset;
				} // Actual scrollto
				// ==========================================================================
				// Setup


				var scrollStart = parseFloat(this.instance.delta[this.directionAxis]);
				var scrollTarget = Math.max(0, Math.min(offset, this.instance.limit[this.directionAxis])); // Make sure our target is in the scroll boundaries

				var scrollDiff = scrollTarget - scrollStart;

				var render = function render(p) {
					if (disableLerp) {
						if (_this9.direction === 'horizontal') {
							_this9.setScroll(scrollStart + scrollDiff * p, _this9.instance.delta.y);
						} else {
							_this9.setScroll(_this9.instance.delta.x, scrollStart + scrollDiff * p);
						}
					} else {
						_this9.instance.delta[_this9.directionAxis] = scrollStart + scrollDiff * p;
					}
				}; // Prepare the scroll


				this.animatingScroll = true; // This boolean allows to prevent `checkScroll()` from calling `stopScrolling` when the animation is slow (i.e. at the beginning of an EaseIn)

				this.stopScrolling(); // Stop any movement, allows to kill any other `scrollTo` still happening

				this.startScrolling(); // Restart the scroll
				// Start the animation loop

				var start = Date.now();

				var loop = function loop() {
					var p = (Date.now() - start) / duration; // Animation progress

					if (p > 1) {
						// Animation ends
						render(1);
						_this9.animatingScroll = false;
						if (duration == 0) _this9.update();
						if (callback) callback();
					} else {
						_this9.scrollToRaf = requestAnimationFrame(loop);
						render(easing(p));
					}
				};

				loop();
			}
		}, {
			key: "update",
			value: function update() {
				this.setScrollLimit();
				this.addSections();
				this.addElements();
				this.detectElements();
				this.updateScroll();
				this.transformElements(true);
				this.reinitScrollBar();
				this.checkScroll(true);
			}
		}, {
			key: "startScroll",
			value: function startScroll() {
				this.stop = false;
			}
		}, {
			key: "stopScroll",
			value: function stopScroll() {
				this.stop = true;
			}
		}, {
			key: "setScroll",
			value: function setScroll(x, y) {
				this.instance = _objectSpread2(_objectSpread2({}, this.instance), {}, {
					scroll: {
						x: x,
						y: y
					},
					delta: {
						x: x,
						y: y
					},
					speed: 0
				});
			}
		}, {
			key: "destroy",
			value: function destroy() {
				_get(_getPrototypeOf(_default.prototype), "destroy", this).call(this);

				this.stopScrolling();
				this.html.classList.remove(this.smoothClass);
				this.vs.destroy();
				this.destroyScrollBar();
				window.removeEventListener('keydown', this.checkKey, false);
			}
		}]);

		return _default;
	}(_default);

	var Smooth = /*#__PURE__*/function () {
		function Smooth() {
			var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			_classCallCheck(this, Smooth);

			this.options = options; // Override default options with given ones

			Object.assign(this, defaults, options);
			this.smartphone = defaults.smartphone;
			if (options.smartphone) Object.assign(this.smartphone, options.smartphone);
			this.tablet = defaults.tablet;
			if (options.tablet) Object.assign(this.tablet, options.tablet);
			if (!this.smooth && this.direction == 'horizontal') console.warn('🚨 `smooth:false` & `horizontal` direction are not yet compatible');
			if (!this.tablet.smooth && this.tablet.direction == 'horizontal') console.warn('🚨 `smooth:false` & `horizontal` direction are not yet compatible (tablet)');
			if (!this.smartphone.smooth && this.smartphone.direction == 'horizontal') console.warn('🚨 `smooth:false` & `horizontal` direction are not yet compatible (smartphone)');
			this.init();
		}

		_createClass(Smooth, [{
			key: "init",
			value: function init() {
				this.options.isMobile = /Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1 || window.innerWidth < this.tablet.breakpoint;
				this.options.isTablet = this.options.isMobile && window.innerWidth >= this.tablet.breakpoint;

				if (this.smooth && !this.options.isMobile || this.tablet.smooth && this.options.isTablet || this.smartphone.smooth && this.options.isMobile && !this.options.isTablet) {
					this.scroll = new _default$2(this.options);
				} else {
					this.scroll = new _default$1(this.options);
				}

				this.scroll.init();

				if (window.location.hash) {
					// Get the hash without the '#' and find the matching element
					var id = window.location.hash.slice(1, window.location.hash.length);
					var target = document.getElementById(id); // If found, scroll to the element

					if (target) this.scroll.scrollTo(target);
				}
			}
		}, {
			key: "update",
			value: function update() {
				this.scroll.update();
			}
		}, {
			key: "start",
			value: function start() {
				this.scroll.startScroll();
			}
		}, {
			key: "stop",
			value: function stop() {
				this.scroll.stopScroll();
			}
		}, {
			key: "scrollTo",
			value: function scrollTo(target, options) {
				this.scroll.scrollTo(target, options);
			}
		}, {
			key: "setScroll",
			value: function setScroll(x, y) {
				this.scroll.setScroll(x, y);
			}
		}, {
			key: "on",
			value: function on(event, func) {
				this.scroll.setEvents(event, func);
			}
		}, {
			key: "off",
			value: function off(event, func) {
				this.scroll.unsetEvents(event, func);
			}
		}, {
			key: "destroy",
			value: function destroy() {
				this.scroll.destroy();
			}
		}]);

		return Smooth;
	}();

	return Smooth;

})));