text: /* locomotive-scroll v3.5.4 | 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 = 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 _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 _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 _toConsumableArray(arr) {
      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
    }
  
    function _arrayWithoutHoles(arr) {
      if (Array.isArray(arr)) {
        for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
  
        return arr2;
      }
    }
  
    function _iterableToArray(iter) {
      if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
    }
  
    function _nonIterableSpread() {
      throw new TypeError("Invalid attempt to spread non-iterable instance");
    }
  
    var defaults = {
      el: document,
      elMobile: document,
      name: "scroll",
      offset: [0, 0],
      repeat: false,
      smooth: false,
      smoothMobile: false,
      direction: "vertical",
      lerp: 0.1,
      "class": "is-inview",
      scrollbarClass: "c-scrollbar",
      scrollingClass: "has-scroll-scrolling",
      draggingClass: "has-scroll-dragging",
      smoothClass: "has-scroll-smooth",
      initClass: "has-scroll-init",
      getSpeed: false,
      getDirection: false,
      multiplier: 1,
      firefoxMultiplier: 50,
      touchMultiplier: 2,
      scrollFromAnywhere: false,
      disableRaf: false
    };
  
    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.namespace = 'locomotive';
        this.html = document.documentElement;
        this.windowHeight = window.innerHeight;
        this.windowMiddle = this.windowHeight / 2;
        this.els = [];
        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: this.html.offsetHeight
        };
  
        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: "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'), 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;
          this.els.forEach(function (el, i) {
            if (el && (!el.inView || hasCallEventSet)) {
              if (scrollBottom >= el.top && scrollTop < el.bottom) {
                _this3.setInView(el, i);
              }
            }
  
            if (el && el.inView) {
              if (scrollBottom < el.top || scrollTop > el.bottom) {
                _this3.setOutOfView(el, i);
              }
            }
          });
          this.els = this.els.filter(function (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"]);
  
          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) {
          if (current.repeat || current.speed !== undefined) {
            this.els[i].inView = false;
          }
  
          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 _this4 = 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(_this4.instance);
  
              case 'call':
                return func(_this4.callValue, _this4.callWay, _this4.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 _this5 = this;
  
          window.removeEventListener('resize', this.checkResize, false);
          Object.keys(this.listeners).forEach(function (event) {
            _this5.el.removeEventListener(_this5.namespace + event, _this5.checkEvent, false);
          });
          this.listeners = {};
          this.scrollToEls.forEach(function (el) {
            el.removeEventListener('click', _this5.setScrollTo, false);
          });
        }
      }]);
  
      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;
  
    function _createSuper(Derived) {
      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;
        }
      }
  
      return function () {
        var Super = _getPrototypeOf(Derived),
            result;
  
        if (isNativeReflectConstruct()) {
          var NewTarget = _getPrototypeOf(this).constructor;
  
          result = Reflect.construct(Super, arguments, NewTarget);
        } else {
          result = Super.apply(this, arguments);
        }
  
        return _possibleConstructorReturn(this, result);
      };
    }
  
    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);
        window.addEventListener('scroll', _this.checkScroll, false);
        smoothscroll.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.timestamp = Date.now();
          }
  
          this.instance.scroll.y = window.pageYOffset;
  
          if (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) / (Date.now() - this.timestamp);
          } else {
            this.instance.speed = 0;
          }
        }
      }, {
        key: "resize",
        value: function resize() {
          if (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, id) {
            var cl = el.dataset[_this3.name + 'Class'] || _this3["class"];
  
            var top = el.getBoundingClientRect().top + _this3.instance.scroll.y;
  
            var bottom = top + el.offsetHeight;
            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'];
  
            if (repeat == 'false') {
              repeat = false;
            } else if (repeat != undefined) {
              repeat = true;
            } else {
              repeat = _this3.repeat;
            }
  
            var relativeOffset = _this3.getRelativeOffset(offset);
  
            var mappedEl = {
              el: el,
              id: id,
              "class": cl,
              top: top + relativeOffset[0],
              bottom: bottom - relativeOffset[1],
              offset: offset,
              repeat: repeat,
              inView: el.classList.contains(cl) ? true : false,
              call: call
            };
  
            _this3.els.push(mappedEl);
          });
        }
      }, {
        key: "updateElements",
        value: function updateElements() {
          var _this4 = this;
  
          this.els.forEach(function (el, i) {
            var top = el.el.getBoundingClientRect().top + _this4.instance.scroll.y;
  
            var bottom = top + el.el.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 :
         *          targetOption {node, string, "top", "bottom", int} - The DOM element we want to scroll to
         *          offsetOption {int} - An absolute vertical scroll value to reach, or an offset to apply on top of given `target` or `sourceElem`'s target
         * @return {void}
         */
  
      }, {
        key: "scrollTo",
        value: function scrollTo(targetOption, offsetOption, duration, easing, disableLerp, callback) {
          // TODO - In next breaking update, use an object as 2nd parameter for options (offset, duration, easing, disableLerp, callback)
          var target;
          var offset = offsetOption ? parseInt(offsetOption) : 0;
  
          if (typeof targetOption === 'string') {
            // Selector or boundaries
            if (targetOption === 'top') {
              target = this.html;
            } else if (targetOption === 'bottom') {
              target = this.html.offsetHeight - window.innerHeight;
            } else {
              target = document.querySelector(targetOption); // If the query fails, abort
  
              if (!target) {
                return;
              }
            }
          } else if (typeof targetOption === 'number') {
            // Absolute coordinate
            target = parseInt(targetOption);
          } else if (targetOption && targetOption.tagName) {
            // DOM Element
            target = targetOption;
          } else {
            console.warn('`targetOption` 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);
      };
    };
  
    function _createSuper$1(Derived) {
      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;
        }
      }
  
      return function () {
        var Super = _getPrototypeOf(Derived),
            result;
  
        if (isNativeReflectConstruct()) {
          var NewTarget = _getPrototypeOf(this).constructor;
  
          result = Reflect.construct(Super, arguments, NewTarget);
        } else {
          result = Super.apply(this, arguments);
        }
  
        return _possibleConstructorReturn(this, result);
      };
    }
    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$1(_default);
  
      function _default() {
        var _this;
  
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  
        _classCallCheck(this, _default);
  
        window.scrollTo(0, 0);
        history.scrollRestoration = "manual";
        _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.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.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.isTicking && !_this2.isDraggingScrollbar) {
              requestAnimationFrame(function () {
                _this2.updateDelta(e);
  
                if (!_this2.isScrolling) _this2.startScrolling();
              });
              _this2.isTicking = true;
            }
  
            _this2.isTicking = false;
          });
          this.setScrollLimit();
          this.initScrollBar();
          this.addSections();
          this.addElements();
          this.detectElements();
          this.transformElements(true, true);
          this.checkScroll(true);
  
          _get(_getPrototypeOf(_default.prototype), "init", this).call(this);
        }
      }, {
        key: "setScrollLimit",
        value: function setScrollLimit() {
          this.instance.limit = this.el.offsetHeight - this.windowHeight;
        }
      }, {
        key: "startScrolling",
        value: function startScrolling() {
          this.isScrolling = true;
          this.checkScroll();
          this.html.classList.add(this.scrollingClass);
        }
      }, {
        key: "stopScrolling",
        value: function stopScrolling() {
          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;
              });
            }
  
            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; // Request scrollTo on the focusedElement, putting it at the center of the screen
  
                _this3.scrollTo(document.activeElement, -window.innerHeight / 2);
              });
              break;
  
            case keyCodes$1.UP:
              this.instance.delta.y -= 240;
              break;
  
            case keyCodes$1.DOWN:
              this.instance.delta.y += 240;
              break;
  
            case keyCodes$1.PAGEUP:
              this.instance.delta.y -= window.innerHeight;
              break;
  
            case keyCodes$1.PAGEDOWN:
              this.instance.delta.y += window.innerHeight;
              break;
  
            case keyCodes$1.HOME:
              this.instance.delta.y -= this.instance.limit;
              break;
  
            case keyCodes$1.END:
              this.instance.delta.y += this.instance.limit;
              break;
  
            case keyCodes$1.SPACE:
              if (!(document.activeElement instanceof HTMLInputElement) && !(document.activeElement instanceof HTMLTextAreaElement)) {
                if (e.shiftKey) {
                  this.instance.delta.y -= window.innerHeight;
                } else {
                  this.instance.delta.y += window.innerHeight;
                }
              }
  
              break;
  
            default:
              return;
          }
  
          if (this.instance.delta.y < 0) this.instance.delta.y = 0;
          if (this.instance.delta.y > this.instance.limit) this.instance.delta.y = this.instance.limit;
          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;
          var updateScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
  
          if (forced || this.isScrolling || this.isDraggingScrollbar) {
            if (!this.hasScrollTicking && !this.disableRaf) {
              requestAnimationFrame(function () {
                return _this4.checkScroll();
              });
              this.hasScrollTicking = true;
            }
  
            if (updateScroll) this.updateScroll();
            var distance = Math.abs(this.instance.delta.y - this.instance.scroll.y);
  
            if (!this.animatingScroll && (distance < 0.5 && this.instance.delta.y != 0 || distance < 0.5 && this.instance.delta.y == 0)) {
              this.stopScrolling();
            }
  
            for (var i = this.sections.length - 1; i >= 0; i--) {
              if (this.sections[i].persistent || this.instance.scroll.y > this.sections[i].offset && this.instance.scroll.y < this.sections[i].limit) {
                this.transform(this.sections[i].el, 0, -this.instance.scroll.y);
  
                if (!this.sections[i].inView) {
                  this.sections[i].inView = true;
                  this.sections[i].el.style.opacity = 1;
                  this.sections[i].el.style.pointerEvents = "all";
                  this.sections[i].el.setAttribute("data-".concat(this.name, "-section-inview"), "");
                }
              } else {
                if (this.sections[i].inView) {
                  this.sections[i].inView = false;
                  this.sections[i].el.style.opacity = 0;
                  this.sections[i].el.style.pointerEvents = "none";
                  this.sections[i].el.removeAttribute("data-".concat(this.name, "-section-inview"));
                }
  
                this.transform(this.sections[i].el, 0, 0);
              }
            }
  
            if (this.getDirection) {
              this.addDirection();
            }
  
            if (this.getSpeed) {
              this.addSpeed();
              this.timestamp = Date.now();
            }
  
            this.detectElements();
            this.transformElements();
            var scrollBarTranslation = this.instance.scroll.y / this.instance.limit * this.scrollBarLimit;
            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.windowMiddle = this.windowHeight / 2;
          this.update();
        }
      }, {
        key: "updateDelta",
        value: function updateDelta(e) {
          this.instance.delta.y -= e.deltaY * this.multiplier;
          if (this.instance.delta.y < 0) this.instance.delta.y = 0;
          if (this.instance.delta.y > this.instance.limit) this.instance.delta.y = this.instance.limit;
        }
      }, {
        key: "updateScroll",
        value: function updateScroll(e) {
          if (this.isScrolling || this.isDraggingScrollbar) {
            this.instance.scroll.y = lerp(this.instance.scroll.y, this.instance.delta.y, this.lerp);
          } else {
            if (this.instance.scroll.y > this.instance.limit) {
              this.setScroll(this.instance.scroll.x, this.instance.limit);
            } else if (this.instance.scroll.y < 0) {
              this.setScroll(this.instance.scroll.x, 0);
            } else {
              this.setScroll(this.instance.scroll.x, this.instance.delta.y);
            }
          }
        }
      }, {
        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";
            }
          }
        }
      }, {
        key: "addSpeed",
        value: function addSpeed() {
          if (this.instance.delta.y != this.instance.scroll.y) {
            this.instance.speed = (this.instance.delta.y - this.instance.scroll.y) / Math.max(1, Date.now() - this.timestamp);
          } 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);
          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
  
          if (this.instance.limit + this.windowHeight <= this.windowHeight) {
            return;
          }
  
          this.scrollbarHeight = this.scrollbar.getBoundingClientRect().height;
          this.scrollbarThumb.style.height = "".concat(this.scrollbarHeight * this.scrollbarHeight / (this.instance.limit + this.scrollbarHeight), "px");
          this.scrollBarLimit = this.scrollbarHeight - this.scrollbarThumb.getBoundingClientRect().height;
        }
      }, {
        key: "reinitScrollBar",
        value: function reinitScrollBar() {
          if (this.instance.limit + this.windowHeight <= this.windowHeight) {
            return;
          }
  
          this.scrollbarHeight = this.scrollbar.getBoundingClientRect().height;
          this.scrollbarThumb.style.height = "".concat(this.scrollbarHeight * this.scrollbarHeight / (this.instance.limit + this.scrollbarHeight), "px");
          this.scrollBarLimit = this.scrollbarHeight - this.scrollbarThumb.getBoundingClientRect().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.isTicking && this.isDraggingScrollbar) {
            requestAnimationFrame(function () {
              var y = e.clientY * 100 / _this5.scrollbarHeight * _this5.instance.limit / 100;
  
              if (y > 0 && y < _this5.instance.limit) {
                _this5.instance.delta.y = y;
              }
            });
            this.isTicking = true;
          }
  
          this.isTicking = false;
        }
      }, {
        key: "addElements",
        value: function addElements() {
          var _this6 = this;
  
          this.els = [];
          this.parallaxElements = [];
          this.sections.forEach(function (section, y) {
            var els = _this6.sections[y].el.querySelectorAll("[data-".concat(_this6.name, "]"));
  
            els.forEach(function (el, id) {
              var cl = el.dataset[_this6.name + "Class"] || _this6["class"];
              var top;
              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;
              }
  
              if (!_this6.sections[y].inView) {
                top = targetEl.getBoundingClientRect().top - getTranslate(_this6.sections[y].el).y - getTranslate(targetEl).y;
              } else {
                top = targetEl.getBoundingClientRect().top + _this6.instance.scroll.y - getTranslate(targetEl).y;
              }
  
              var bottom = top + targetEl.offsetHeight;
              var middle = (bottom - top) / 2 + top;
  
              if (sticky) {
                var elTop = el.getBoundingClientRect().top;
                var elDistance = elTop - top;
                top += window.innerHeight;
                bottom = elTop + targetEl.offsetHeight - el.offsetHeight - elDistance;
                middle = (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) {
                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];
                  }
                }
              }
  
              var mappedEl = {
                el: el,
                id: id,
                "class": cl,
                top: top + relativeOffset[0],
                middle: middle,
                bottom: bottom - relativeOffset[1],
                offset: offset,
                repeat: repeat,
                inView: el.classList.contains(cl) ? true : false,
                call: call,
                speed: speed,
                delay: delay,
                position: position,
                target: targetEl,
                direction: direction,
                sticky: sticky
              };
  
              _this6.els.push(mappedEl);
  
              if (speed !== false || sticky) {
                _this6.parallaxElements.push(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, i) {
            var offset = section.getBoundingClientRect().top - window.innerHeight * 1.5 - getTranslate(section).y;
            var limit = offset + section.getBoundingClientRect().height + window.innerHeight * 2;
            var persistent = typeof section.dataset[_this7.name + "Persistent"] === "string";
            var mappedSection = {
              el: section,
              offset: offset,
              limit: limit,
              inView: false,
              persistent: persistent
            };
            _this7.sections[i] = 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 scrollBottom = this.instance.scroll.y + this.windowHeight;
          var scrollMiddle = this.instance.scroll.y + this.windowMiddle;
          this.parallaxElements.forEach(function (current, i) {
            var transformDistance = false;
  
            if (isForced) {
              transformDistance = 0;
            }
  
            if (current.inView || setAllElements) {
              switch (current.position) {
                case "top":
                  transformDistance = _this8.instance.scroll.y * -current.speed;
                  break;
  
                case "elementTop":
                  transformDistance = (scrollBottom - current.top) * -current.speed;
                  break;
  
                case "bottom":
                  transformDistance = (_this8.instance.limit - scrollBottom + _this8.windowHeight) * current.speed;
                  break;
  
                default:
                  transformDistance = (scrollMiddle - current.middle) * -current.speed;
                  break;
              }
            }
  
            if (current.sticky) {
              if (current.inView) {
                transformDistance = _this8.instance.scroll.y - current.top + window.innerHeight;
              } 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.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 :
         *          targetOption {node, string, "top", "bottom", int} - The DOM element we want to scroll to
         *          offsetOption {int} - An offset to apply on top of given `target` or `sourceElem`'s target
         *          duration {int} - Duration of the scroll animation in milliseconds
         *          easing {array} - 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/
         * @return {void}
         */
  
      }, {
        key: "scrollTo",
        value: function scrollTo(targetOption, offsetOption) {
          var _this9 = this;
  
          var duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;
          var easing = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [0.25, 0.0, 0.35, 1.0];
          var disableLerp = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
          var callback = arguments.length > 5 ? arguments[5] : undefined;
          // TODO - In next breaking update, use an object as 2nd parameter for options (offset, duration, easing, disableLerp, callback)
          var target;
          var offset = offsetOption ? parseInt(offsetOption) : 0;
          easing = src$1.apply(void 0, _toConsumableArray(easing));
  
          if (typeof targetOption === "string") {
            // Selector or boundaries
            if (targetOption === "top") {
              target = 0;
            } else if (targetOption === "bottom") {
              target = this.instance.limit;
            } else {
              target = document.querySelector(targetOption); // If the query fails, abort
  
              if (!target) {
                return;
              }
            }
          } else if (typeof targetOption === "number") {
            // Absolute coordinate
            target = parseInt(targetOption);
          } else if (targetOption && targetOption.tagName) {
            // DOM Element
            target = targetOption;
          } else {
            console.warn("`targetOption` 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; // Try and find the target's parent section
  
            var targetParents = getParents(target);
            var parentSection = targetParents.find(function (candidate) {
              return _this9.sections.find(function (section) {
                return section.el == candidate;
              });
            });
            var parentSectionOffset = 0;
  
            if (parentSection) {
              parentSectionOffset = getTranslate(parentSection).y; // We got a parent section, store it's current offset to remove it later
            } // Final value of scroll destination : offsetTop + (optional offset given in options) - (parent's section translate)
  
  
            offset = offsetTop + offset - parentSectionOffset;
          } else {
            offset = target + offset;
          } // Actual scrollto
          // ==========================================================================
          // Setup
  
  
          var scrollStart = parseFloat(this.instance.delta.y);
          var scrollTarget = Math.max(0, Math.min(offset, this.instance.limit)); // Make sure our target is in the scroll boundaries
  
          var scrollDiff = scrollTarget - scrollStart;
  
          var render = function render(p) {
            if (disableLerp) _this9.setScroll(_this9.instance.delta.x, scrollStart + scrollDiff * p);else _this9.instance.delta.y = 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 _default$3 = /*#__PURE__*/function () {
      function _default() {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  
        _classCallCheck(this, _default);
  
        this.options = options;
        Object.assign(this, defaults, options);
        this.init();
      }
  
      _createClass(_default, [{
        key: "init",
        value: function init() {
          if (!this.smoothMobile) {
            this.isMobile = /Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
          }
  
          if (this.smooth === true && !this.isMobile) {
            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, offset, duration, easing, disableLerp, callback) {
          // TODO - In next breaking update, use an object as 2nd parameter for options (offset, duration, easing, disableLerp, callback)
          this.scroll.scrollTo(target, offset, duration, easing, disableLerp, callback);
        }
      }, {
        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 _default;
    }();
  
    return _default$3;
  
  })));
  