{"version":3,"sources":["webpack:///./src/components/ScrollableOverflow.js","webpack:///./node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack:///./node_modules/smoothscroll-polyfill/dist/smoothscroll.js","webpack:///./node_modules/core-js/modules/es.array.find-index.js"],"names":["OverflowContainer","styled","div","p","disableScroll","centered","css","rightGutter","leftGutter","hideScrollbars","DraggableContent","ScrollableOverflow","props","state","boundary","left","top","hasOverflow","handleResize","bind","handleScrollDebounce","_handleScrollDebounce","childRefs","componentDidMount","smoothscroll","polyfill","ResizeObserver","this","resizeObserver","observe","contentRef","overflowRef","addEventListener","componentWillUnmount","unobserve","removeEventListener","scrollDeounce","clearTimeout","_getLeftGutter","bleedLeft","gutterWidth","_getRightGutter","bleedRight","setTimeout","_handleScroll","_isAtBoundaryStart","isAtStart","isAfterStart","_isAtBoundaryEnd","isAtEnd","isBeforeEnd","onActiveIndexChange","activeIndex","_getActiveIndex","a","_updateBoundary","setState","onHasOverflow","scrollToIndex","i","position","smooth","element","scrollToElement","elementOffset","offsetLeft","elementWidth","offsetWidth","visibleWidth","_getVisibleWidth","offset","updatedX","scrollTo","behavior","_getLeftPosition","scrollLeft","_getCenterPosition","Promise","resolve","_getBoundary","Math","ceil","min","_getTotalWidth","scrollWidth","length","findIndex","ref","leftOffset","rightOffset","render","children","map","child","index","React","cloneElement","r","testingRef","Component","MapShim","Map","getIndex","arr","key","result","some","entry","class_1","__entries__","Object","defineProperty","prototype","get","enumerable","configurable","set","value","push","delete","entries","splice","has","clear","forEach","callback","ctx","_i","_a","call","isBrowser","window","document","global$1","global","self","Function","requestAnimationFrame$1","requestAnimationFrame","Date","now","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","delay","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","throttle","addObserver","observer","indexOf","connect_","removeObserver","observers","disconnect_","updateObservers_","activeObservers","filter","gatherActive","hasActive","broadcastActive","attributes","childList","characterData","subtree","disconnect","_b","propertyName","getInstance","instance_","defineConfigurable","target","keys","writable","getWindowOf","ownerDocument","defaultView","emptyRect","createRectInit","toFloat","parseFloat","getBordersSize","styles","positions","arguments","reduce","size","getHTMLElementContentRect","clientWidth","clientHeight","getComputedStyle","paddings","positions_1","getPaddings","horizPad","right","vertPad","bottom","width","height","boxSizing","round","documentElement","isDocumentElement","vertScrollbar","horizScrollbar","abs","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","getBBox","getContentRect","bbox","getSVGContentRect","x","y","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","isActive","rect","broadcastRect","ResizeObserverEntry","rectInit","Constr","contentRect","DOMRectReadOnly","create","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","TypeError","callback_","controller_","callbackCtx_","Element","observations","clearActive","_this","observation","WeakMap","method","apply","module","exports","w","d","style","__forceSmoothScrollPolyfill__","userAgent","HTMLElement","original","scroll","scrollBy","elementScroll","scrollElement","scrollIntoView","performance","ROUNDING_TOLERANCE","navigator","RegExp","join","test","undefined","shouldBailOut","smoothScroll","body","scrollX","pageXOffset","scrollY","pageYOffset","scrollTop","SyntaxError","scrollableParent","findScrollableParent","parentRects","getBoundingClientRect","clientRects","firstArg","hasScrollableSpace","el","axis","scrollHeight","canOverflow","overflowValue","isScrollable","isScrollableY","isScrollableX","parentNode","host","step","context","currentX","currentY","k","elapsed","startTime","cos","PI","startX","startY","scrollable","$","$findIndex","addToUnscopables","arrayMethodUsesToLength","SKIPS_HOLES","USES_TO_LENGTH","Array","proto","forced","callbackfn"],"mappings":"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","file":"055ca895f51fff4563937c5ccf9b1009bef7de31-9760a2b27800d61fc240.js","sourcesContent":["import React from \"react\";\nimport styled, { css } from \"styled-components\";\nimport smoothscroll from \"smoothscroll-polyfill\";\nimport ResizeObserver from \"resize-observer-polyfill\";\n\nimport { hideScrollbars } from \"../utils/style\";\n\n/**\n * A utility component for creating a element that can be scrolled within a\n * container without displaying a scrollbar for the content's overflow.\n * This utility component currently only supports horizontal scrolling.\n *  *\n * This component can have any number of children. If the total width of the\n * children exceeds the width/height of the parent, the component will be\n * scrollable.\n *\n * @param {Boolean} bleedLeft Whether content that overflows to the left of the\n * container should bleed to the left edge of the window.\n * @param {Boolean} bleedRight Whether content that overflows to the right of\n * the container should bleed to the right edge of the window.\n * @param {Boolean} disableScroll Whether the container should be scrollable.\n * If false, the container can still be moved programatically by the\n * scrollToElement and scrollToIndex functions.\n *\n * Note: For the bleedLeft and bleedRight properties to work as intended, any\n * container wrapping this component must not have the overflow: hidden\n * property.\n */\n\nconst OverflowContainer = styled.div`\n  overflow-x: ${p => (p.disableScroll ? \"hidden\" : \"scroll\")};\n  font-size: 0;\n\n  ${p =>\n    p.centered\n      ? css`\n          margin: auto;\n        `\n      : css`\n          margin: 0 -${p.rightGutter}px 0 -${p.leftGutter}px;\n          scroll-padding: 0 ${p.rightGutter}px 0 ${p.leftGutter}px;\n        `}\n\n  ${hideScrollbars}\n\n  scroll-snap-type: x mandatory;\n`;\n\nconst DraggableContent = styled.div`\n  display: inline-flex;\n  white-space: nowrap;\n\n  ${p =>\n    p.centered ? \"\" : `padding: 0 ${p.rightGutter}px 0 ${p.leftGutter}px`};\n\n  & > * {\n    flex-shrink: 0;\n  }\n`;\n\nexport default class ScrollableOverflow extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      boundary: { left: 0, top: 0 },\n      hasOverflow: false,\n    };\n    this.handleResize = this.handleResize.bind(this);\n    this.handleScrollDebounce = this._handleScrollDebounce.bind(this);\n\n    this.childRefs = [];\n  }\n\n  componentDidMount() {\n    smoothscroll.polyfill();\n    // Observe changes in size for the overflowRef and the contentRef. The\n    // overflowRef can change in size when the width of the parent of this\n    // component changes. The contentRef can change in size when the width\n    // of the children changes (i.e. images are loaded).\n    if (ResizeObserver) {\n      this.resizeObserver = new ResizeObserver(this.handleResize);\n      this.resizeObserver.observe(this.contentRef);\n      this.resizeObserver.observe(this.overflowRef);\n    }\n\n    this.overflowRef.addEventListener(\"scroll\", this.handleScrollDebounce);\n\n    this.handleResize();\n  }\n\n  componentWillUnmount() {\n    this.resizeObserver && this.resizeObserver.unobserve(this.contentRef);\n    this.resizeObserver && this.resizeObserver.unobserve(this.overflowRef);\n\n    this.overflowRef.removeEventListener(\"scroll\", this.handleScrollDebounce);\n    this.scrollDeounce && clearTimeout(this.scrollDeounce);\n  }\n\n  _getLeftGutter() {\n    if (!this.props.bleedLeft) return 0;\n    return this.props.gutterWidth || 1000;\n  }\n\n  _getRightGutter() {\n    if (!this.props.bleedRight) return 0;\n    return this.props.gutterWidth || 1000;\n  }\n\n  _handleScrollDebounce() {\n    // Clear the existing timeout if one exists.\n    this.scrollDeounce && clearTimeout(this.scrollDeounce);\n    this.scrollDeounce = setTimeout(() => {\n      this._handleScroll();\n    }, 100);\n  }\n\n  _handleScroll() {\n    if (this._isAtBoundaryStart()) {\n      this.props.isAtStart && this.props.isAtStart();\n    } else {\n      this.props.isAfterStart && this.props.isAfterStart();\n    }\n\n    if (this._isAtBoundaryEnd()) {\n      this.props.isAtEnd && this.props.isAtEnd();\n    } else {\n      this.props.isBeforeEnd && this.props.isBeforeEnd();\n    }\n\n    if (this.props.onActiveIndexChange) {\n      const activeIndex = this._getActiveIndex();\n      this.props.onActiveIndexChange(activeIndex);\n    }\n  }\n\n  async handleResize() {\n    await this._updateBoundary();\n\n    const hasOverflow = this.state.boundary.left < 0;\n    this.setState({\n      hasOverflow,\n    });\n\n    this._handleScroll();\n\n    if (this.props.onHasOverflow) {\n      this.props.onHasOverflow(hasOverflow);\n    }\n  }\n\n  scrollToIndex(i, position = \"center\", smooth = true) {\n    const element = this.childRefs[i];\n    if (!element) return;\n\n    return this.scrollToElement(element, position, smooth);\n  }\n\n  scrollToElement(element, position = \"center\", smooth = true) {\n    const elementOffset = element.offsetLeft - this.overflowRef.offsetLeft;\n    const elementWidth = element.offsetWidth;\n    const visibleWidth = this._getVisibleWidth();\n\n    // The distance from the left of the overflowRef required to center the\n    // current element horizontally. This does not include the element's margin.\n    let offset = visibleWidth / 2 - elementWidth / 2;\n\n    if (position === \"left\") {\n      offset = this._getLeftGutter();\n    } else if (position === \"right\") {\n      offset = visibleWidth - this._getRightGutter();\n    }\n\n    let updatedX = elementOffset - offset;\n\n    if (!this.overflowRef.scrollTo) {\n      // This should only occur during testing.\n      return;\n    }\n\n    this.overflowRef.scrollTo({\n      left: updatedX,\n      behavior: smooth ? \"smooth\" : \"auto\",\n    });\n  }\n\n  _getLeftPosition() {\n    return this.overflowRef ? this.overflowRef.scrollLeft * -1 : 0;\n  }\n\n  _getCenterPosition() {\n    if (!this.overflowRef) return 0;\n    const left = this._getLeftPosition();\n    const width = this._getVisibleWidth();\n    return width / 2 + left * -1;\n  }\n\n  _updateBoundary() {\n    return new Promise(resolve => {\n      let { left, top } = this._getBoundary();\n\n      left = Math.ceil(left);\n      top = Math.ceil(top);\n\n      this.setState(\n        {\n          boundary: { left, top },\n        },\n        resolve,\n      );\n    });\n  }\n\n  _getBoundary() {\n    const left = Math.min(this._getVisibleWidth() - this._getTotalWidth(), 0);\n    return { left, top: 0 };\n  }\n\n  _getVisibleWidth() {\n    return this.overflowRef ? this.overflowRef.offsetWidth : 0;\n  }\n\n  _getTotalWidth() {\n    return this.overflowRef ? this.overflowRef.scrollWidth : 0;\n  }\n\n  _isAtBoundaryStart() {\n    return this._getLeftPosition() >= 0;\n  }\n\n  _isAtBoundaryEnd() {\n    return this._getLeftPosition() <= this.state.boundary.left;\n  }\n\n  _getActiveIndex() {\n    if (!this.childRefs.length) {\n      return -1;\n    } else if (this._isAtBoundaryStart()) {\n      return 0;\n    } else if (this._isAtBoundaryEnd()) {\n      return this.childRefs.length - 1;\n    }\n\n    const position = this._getCenterPosition();\n\n    const index = this.childRefs.findIndex(ref => {\n      const leftOffset = ref.offsetLeft - this.overflowRef.offsetLeft;\n      const rightOffset = leftOffset + ref.offsetWidth;\n      return position >= leftOffset && position < rightOffset;\n    });\n    return index;\n  }\n\n  render() {\n    const { disableScroll, centered = true } = this.props;\n    const { hasOverflow } = this.state;\n\n    const leftGutter = this._getLeftGutter();\n    const rightGutter = this._getRightGutter();\n\n    let children = this.props.children;\n\n    // If the passed through children props is an array, assign a ref to each\n    // element.\n    if (this.props.childRefs) {\n      this.childRefs = this.props.childRefs;\n    } else {\n      if (children && children.length) {\n        children = this.props.children.map((child, index) => {\n          return React.cloneElement(child, {\n            ref: r => {\n              this.childRefs[index] = r;\n            },\n          });\n        });\n      }\n    }\n\n    return (\n      <OverflowContainer\n        centered={centered && !hasOverflow}\n        leftGutter={leftGutter}\n        rightGutter={rightGutter}\n        disableScroll={disableScroll}\n        ref={r => {\n          if (this.props.testingRef) {\n            // Should only be used for testing.\n            this.overflowRef = this.props.testingRef;\n          } else {\n            this.overflowRef = r;\n          }\n        }}\n      >\n        <DraggableContent\n          centered={centered && !hasOverflow}\n          leftGutter={leftGutter}\n          rightGutter={rightGutter}\n          ref={r => {\n            this.contentRef = r;\n          }}\n        >\n          {children}\n        </DraggableContent>\n      </OverflowContainer>\n    );\n  }\n}\n","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\n\n/* eslint-disable require-jsdoc, valid-jsdoc */\nvar MapShim = function () {\n  if (typeof Map !== 'undefined') {\n    return Map;\n  }\n  /**\r\n   * Returns index in provided array that matches the specified key.\r\n   *\r\n   * @param {Array<Array>} arr\r\n   * @param {*} key\r\n   * @returns {number}\r\n   */\n\n\n  function getIndex(arr, key) {\n    var result = -1;\n    arr.some(function (entry, index) {\n      if (entry[0] === key) {\n        result = index;\n        return true;\n      }\n\n      return false;\n    });\n    return result;\n  }\n\n  return (\n    /** @class */\n    function () {\n      function class_1() {\n        this.__entries__ = [];\n      }\n\n      Object.defineProperty(class_1.prototype, \"size\", {\n        /**\r\n         * @returns {boolean}\r\n         */\n        get: function get() {\n          return this.__entries__.length;\n        },\n        enumerable: true,\n        configurable: true\n      });\n      /**\r\n       * @param {*} key\r\n       * @returns {*}\r\n       */\n\n      class_1.prototype.get = function (key) {\n        var index = getIndex(this.__entries__, key);\n        var entry = this.__entries__[index];\n        return entry && entry[1];\n      };\n      /**\r\n       * @param {*} key\r\n       * @param {*} value\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.set = function (key, value) {\n        var index = getIndex(this.__entries__, key);\n\n        if (~index) {\n          this.__entries__[index][1] = value;\n        } else {\n          this.__entries__.push([key, value]);\n        }\n      };\n      /**\r\n       * @param {*} key\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.delete = function (key) {\n        var entries = this.__entries__;\n        var index = getIndex(entries, key);\n\n        if (~index) {\n          entries.splice(index, 1);\n        }\n      };\n      /**\r\n       * @param {*} key\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.has = function (key) {\n        return !!~getIndex(this.__entries__, key);\n      };\n      /**\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.clear = function () {\n        this.__entries__.splice(0);\n      };\n      /**\r\n       * @param {Function} callback\r\n       * @param {*} [ctx=null]\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.forEach = function (callback, ctx) {\n        if (ctx === void 0) {\n          ctx = null;\n        }\n\n        for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\n          var entry = _a[_i];\n          callback.call(ctx, entry[1], entry[0]);\n        }\n      };\n\n      return class_1;\n    }()\n  );\n}();\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\n\n\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document; // Returns global object of a current environment.\n\nvar global$1 = function () {\n  if (typeof global !== 'undefined' && global.Math === Math) {\n    return global;\n  }\n\n  if (typeof self !== 'undefined' && self.Math === Math) {\n    return self;\n  }\n\n  if (typeof window !== 'undefined' && window.Math === Math) {\n    return window;\n  } // eslint-disable-next-line no-new-func\n\n\n  return Function('return this')();\n}();\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\n\n\nvar requestAnimationFrame$1 = function () {\n  if (typeof requestAnimationFrame === 'function') {\n    // It's required to use a bounded function because IE sometimes throws\n    // an \"Invalid calling object\" error if rAF is invoked without the global\n    // object on the left hand side.\n    return requestAnimationFrame.bind(global$1);\n  }\n\n  return function (callback) {\n    return setTimeout(function () {\n      return callback(Date.now());\n    }, 1000 / 60);\n  };\n}(); // Defines minimum timeout before adding a trailing call.\n\n\nvar trailingTimeout = 2;\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\n\nfunction throttle(callback, delay) {\n  var leadingCall = false,\n      trailingCall = false,\n      lastCallTime = 0;\n  /**\r\n   * Invokes the original callback function and schedules new invocation if\r\n   * the \"proxy\" was called during current request.\r\n   *\r\n   * @returns {void}\r\n   */\n\n  function resolvePending() {\n    if (leadingCall) {\n      leadingCall = false;\n      callback();\n    }\n\n    if (trailingCall) {\n      proxy();\n    }\n  }\n  /**\r\n   * Callback invoked after the specified delay. It will further postpone\r\n   * invocation of the original function delegating it to the\r\n   * requestAnimationFrame.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  function timeoutCallback() {\n    requestAnimationFrame$1(resolvePending);\n  }\n  /**\r\n   * Schedules invocation of the original function.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  function proxy() {\n    var timeStamp = Date.now();\n\n    if (leadingCall) {\n      // Reject immediately following calls.\n      if (timeStamp - lastCallTime < trailingTimeout) {\n        return;\n      } // Schedule new call to be in invoked when the pending one is resolved.\n      // This is important for \"transitions\" which never actually start\n      // immediately so there is a chance that we might miss one if change\n      // happens amids the pending invocation.\n\n\n      trailingCall = true;\n    } else {\n      leadingCall = true;\n      trailingCall = false;\n      setTimeout(timeoutCallback, delay);\n    }\n\n    lastCallTime = timeStamp;\n  }\n\n  return proxy;\n} // Minimum delay before invoking the update of observers.\n\n\nvar REFRESH_DELAY = 20; // A list of substrings of CSS properties used to find transition events that\n// might affect dimensions of observed elements.\n\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight']; // Check if MutationObserver is available.\n\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\n\nvar ResizeObserverController =\n/** @class */\nfunction () {\n  /**\r\n   * Creates a new instance of ResizeObserverController.\r\n   *\r\n   * @private\r\n   */\n  function ResizeObserverController() {\n    /**\r\n     * Indicates whether DOM listeners have been added.\r\n     *\r\n     * @private {boolean}\r\n     */\n    this.connected_ = false;\n    /**\r\n     * Tells that controller has subscribed for Mutation Events.\r\n     *\r\n     * @private {boolean}\r\n     */\n\n    this.mutationEventsAdded_ = false;\n    /**\r\n     * Keeps reference to the instance of MutationObserver.\r\n     *\r\n     * @private {MutationObserver}\r\n     */\n\n    this.mutationsObserver_ = null;\n    /**\r\n     * A list of connected observers.\r\n     *\r\n     * @private {Array<ResizeObserverSPI>}\r\n     */\n\n    this.observers_ = [];\n    this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\n    this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\n  }\n  /**\r\n   * Adds observer to observers list.\r\n   *\r\n   * @param {ResizeObserverSPI} observer - Observer to be added.\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.addObserver = function (observer) {\n    if (!~this.observers_.indexOf(observer)) {\n      this.observers_.push(observer);\n    } // Add listeners if they haven't been added yet.\n\n\n    if (!this.connected_) {\n      this.connect_();\n    }\n  };\n  /**\r\n   * Removes observer from observers list.\r\n   *\r\n   * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.removeObserver = function (observer) {\n    var observers = this.observers_;\n    var index = observers.indexOf(observer); // Remove observer if it's present in registry.\n\n    if (~index) {\n      observers.splice(index, 1);\n    } // Remove listeners if controller has no connected observers.\n\n\n    if (!observers.length && this.connected_) {\n      this.disconnect_();\n    }\n  };\n  /**\r\n   * Invokes the update of observers. It will continue running updates insofar\r\n   * it detects changes.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.refresh = function () {\n    var changesDetected = this.updateObservers_(); // Continue running updates if changes have been detected as there might\n    // be future ones caused by CSS transitions.\n\n    if (changesDetected) {\n      this.refresh();\n    }\n  };\n  /**\r\n   * Updates every observer from observers list and notifies them of queued\r\n   * entries.\r\n   *\r\n   * @private\r\n   * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n   *      dimensions of it's elements.\r\n   */\n\n\n  ResizeObserverController.prototype.updateObservers_ = function () {\n    // Collect observers that have active observations.\n    var activeObservers = this.observers_.filter(function (observer) {\n      return observer.gatherActive(), observer.hasActive();\n    }); // Deliver notifications in a separate cycle in order to avoid any\n    // collisions between observers, e.g. when multiple instances of\n    // ResizeObserver are tracking the same element and the callback of one\n    // of them changes content dimensions of the observed target. Sometimes\n    // this may result in notifications being blocked for the rest of observers.\n\n    activeObservers.forEach(function (observer) {\n      return observer.broadcastActive();\n    });\n    return activeObservers.length > 0;\n  };\n  /**\r\n   * Initializes DOM listeners.\r\n   *\r\n   * @private\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.connect_ = function () {\n    // Do nothing if running in a non-browser environment or if listeners\n    // have been already added.\n    if (!isBrowser || this.connected_) {\n      return;\n    } // Subscription to the \"Transitionend\" event is used as a workaround for\n    // delayed transitions. This way it's possible to capture at least the\n    // final state of an element.\n\n\n    document.addEventListener('transitionend', this.onTransitionEnd_);\n    window.addEventListener('resize', this.refresh);\n\n    if (mutationObserverSupported) {\n      this.mutationsObserver_ = new MutationObserver(this.refresh);\n      this.mutationsObserver_.observe(document, {\n        attributes: true,\n        childList: true,\n        characterData: true,\n        subtree: true\n      });\n    } else {\n      document.addEventListener('DOMSubtreeModified', this.refresh);\n      this.mutationEventsAdded_ = true;\n    }\n\n    this.connected_ = true;\n  };\n  /**\r\n   * Removes DOM listeners.\r\n   *\r\n   * @private\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.disconnect_ = function () {\n    // Do nothing if running in a non-browser environment or if listeners\n    // have been already removed.\n    if (!isBrowser || !this.connected_) {\n      return;\n    }\n\n    document.removeEventListener('transitionend', this.onTransitionEnd_);\n    window.removeEventListener('resize', this.refresh);\n\n    if (this.mutationsObserver_) {\n      this.mutationsObserver_.disconnect();\n    }\n\n    if (this.mutationEventsAdded_) {\n      document.removeEventListener('DOMSubtreeModified', this.refresh);\n    }\n\n    this.mutationsObserver_ = null;\n    this.mutationEventsAdded_ = false;\n    this.connected_ = false;\n  };\n  /**\r\n   * \"Transitionend\" event handler.\r\n   *\r\n   * @private\r\n   * @param {TransitionEvent} event\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\n    var _b = _a.propertyName,\n        propertyName = _b === void 0 ? '' : _b; // Detect whether transition may affect dimensions of an element.\n\n    var isReflowProperty = transitionKeys.some(function (key) {\n      return !!~propertyName.indexOf(key);\n    });\n\n    if (isReflowProperty) {\n      this.refresh();\n    }\n  };\n  /**\r\n   * Returns instance of the ResizeObserverController.\r\n   *\r\n   * @returns {ResizeObserverController}\r\n   */\n\n\n  ResizeObserverController.getInstance = function () {\n    if (!this.instance_) {\n      this.instance_ = new ResizeObserverController();\n    }\n\n    return this.instance_;\n  };\n  /**\r\n   * Holds reference to the controller's instance.\r\n   *\r\n   * @private {ResizeObserverController}\r\n   */\n\n\n  ResizeObserverController.instance_ = null;\n  return ResizeObserverController;\n}();\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\n\n\nvar defineConfigurable = function defineConfigurable(target, props) {\n  for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\n    var key = _a[_i];\n    Object.defineProperty(target, key, {\n      value: props[key],\n      enumerable: false,\n      writable: false,\n      configurable: true\n    });\n  }\n\n  return target;\n};\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\n\n\nvar getWindowOf = function getWindowOf(target) {\n  // Assume that the element is an instance of Node, which means that it\n  // has the \"ownerDocument\" property from which we can retrieve a\n  // corresponding global object.\n  var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView; // Return the local global object if it's not possible extract one from\n  // provided element.\n\n  return ownerGlobal || global$1;\n}; // Placeholder of an empty content rectangle.\n\n\nvar emptyRect = createRectInit(0, 0, 0, 0);\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\n\nfunction toFloat(value) {\n  return parseFloat(value) || 0;\n}\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\n\n\nfunction getBordersSize(styles) {\n  var positions = [];\n\n  for (var _i = 1; _i < arguments.length; _i++) {\n    positions[_i - 1] = arguments[_i];\n  }\n\n  return positions.reduce(function (size, position) {\n    var value = styles['border-' + position + '-width'];\n    return size + toFloat(value);\n  }, 0);\n}\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\n\n\nfunction getPaddings(styles) {\n  var positions = ['top', 'right', 'bottom', 'left'];\n  var paddings = {};\n\n  for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\n    var position = positions_1[_i];\n    var value = styles['padding-' + position];\n    paddings[position] = toFloat(value);\n  }\n\n  return paddings;\n}\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\n\n\nfunction getSVGContentRect(target) {\n  var bbox = target.getBBox();\n  return createRectInit(0, 0, bbox.width, bbox.height);\n}\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\n\n\nfunction getHTMLElementContentRect(target) {\n  // Client width & height properties can't be\n  // used exclusively as they provide rounded values.\n  var clientWidth = target.clientWidth,\n      clientHeight = target.clientHeight; // By this condition we can catch all non-replaced inline, hidden and\n  // detached elements. Though elements with width & height properties less\n  // than 0.5 will be discarded as well.\n  //\n  // Without it we would need to implement separate methods for each of\n  // those cases and it's not possible to perform a precise and performance\n  // effective test for hidden elements. E.g. even jQuery's ':visible' filter\n  // gives wrong results for elements with width & height less than 0.5.\n\n  if (!clientWidth && !clientHeight) {\n    return emptyRect;\n  }\n\n  var styles = getWindowOf(target).getComputedStyle(target);\n  var paddings = getPaddings(styles);\n  var horizPad = paddings.left + paddings.right;\n  var vertPad = paddings.top + paddings.bottom; // Computed styles of width & height are being used because they are the\n  // only dimensions available to JS that contain non-rounded values. It could\n  // be possible to utilize the getBoundingClientRect if only it's data wasn't\n  // affected by CSS transformations let alone paddings, borders and scroll bars.\n\n  var width = toFloat(styles.width),\n      height = toFloat(styles.height); // Width & height include paddings and borders when the 'border-box' box\n  // model is applied (except for IE).\n\n  if (styles.boxSizing === 'border-box') {\n    // Following conditions are required to handle Internet Explorer which\n    // doesn't include paddings and borders to computed CSS dimensions.\n    //\n    // We can say that if CSS dimensions + paddings are equal to the \"client\"\n    // properties then it's either IE, and thus we don't need to subtract\n    // anything, or an element merely doesn't have paddings/borders styles.\n    if (Math.round(width + horizPad) !== clientWidth) {\n      width -= getBordersSize(styles, 'left', 'right') + horizPad;\n    }\n\n    if (Math.round(height + vertPad) !== clientHeight) {\n      height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\n    }\n  } // Following steps can't be applied to the document's root element as its\n  // client[Width/Height] properties represent viewport area of the window.\n  // Besides, it's as well not necessary as the <html> itself neither has\n  // rendered scroll bars nor it can be clipped.\n\n\n  if (!isDocumentElement(target)) {\n    // In some browsers (only in Firefox, actually) CSS width & height\n    // include scroll bars size which can be removed at this step as scroll\n    // bars are the only difference between rounded dimensions + paddings\n    // and \"client\" properties, though that is not always true in Chrome.\n    var vertScrollbar = Math.round(width + horizPad) - clientWidth;\n    var horizScrollbar = Math.round(height + vertPad) - clientHeight; // Chrome has a rather weird rounding of \"client\" properties.\n    // E.g. for an element with content width of 314.2px it sometimes gives\n    // the client width of 315px and for the width of 314.7px it may give\n    // 314px. And it doesn't happen all the time. So just ignore this delta\n    // as a non-relevant.\n\n    if (Math.abs(vertScrollbar) !== 1) {\n      width -= vertScrollbar;\n    }\n\n    if (Math.abs(horizScrollbar) !== 1) {\n      height -= horizScrollbar;\n    }\n  }\n\n  return createRectInit(paddings.left, paddings.top, width, height);\n}\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\n\n\nvar isSVGGraphicsElement = function () {\n  // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\n  // interface.\n  if (typeof SVGGraphicsElement !== 'undefined') {\n    return function (target) {\n      return target instanceof getWindowOf(target).SVGGraphicsElement;\n    };\n  } // If it's so, then check that element is at least an instance of the\n  // SVGElement and that it has the \"getBBox\" method.\n  // eslint-disable-next-line no-extra-parens\n\n\n  return function (target) {\n    return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === 'function';\n  };\n}();\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\n\n\nfunction isDocumentElement(target) {\n  return target === getWindowOf(target).document.documentElement;\n}\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\n\n\nfunction getContentRect(target) {\n  if (!isBrowser) {\n    return emptyRect;\n  }\n\n  if (isSVGGraphicsElement(target)) {\n    return getSVGContentRect(target);\n  }\n\n  return getHTMLElementContentRect(target);\n}\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\n\n\nfunction createReadOnlyRect(_a) {\n  var x = _a.x,\n      y = _a.y,\n      width = _a.width,\n      height = _a.height; // If DOMRectReadOnly is available use it as a prototype for the rectangle.\n\n  var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\n  var rect = Object.create(Constr.prototype); // Rectangle's properties are not writable and non-enumerable.\n\n  defineConfigurable(rect, {\n    x: x,\n    y: y,\n    width: width,\n    height: height,\n    top: y,\n    right: x + width,\n    bottom: height + y,\n    left: x\n  });\n  return rect;\n}\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\n\n\nfunction createRectInit(x, y, width, height) {\n  return {\n    x: x,\n    y: y,\n    width: width,\n    height: height\n  };\n}\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\n\n\nvar ResizeObservation =\n/** @class */\nfunction () {\n  /**\r\n   * Creates an instance of ResizeObservation.\r\n   *\r\n   * @param {Element} target - Element to be observed.\r\n   */\n  function ResizeObservation(target) {\n    /**\r\n     * Broadcasted width of content rectangle.\r\n     *\r\n     * @type {number}\r\n     */\n    this.broadcastWidth = 0;\n    /**\r\n     * Broadcasted height of content rectangle.\r\n     *\r\n     * @type {number}\r\n     */\n\n    this.broadcastHeight = 0;\n    /**\r\n     * Reference to the last observed content rectangle.\r\n     *\r\n     * @private {DOMRectInit}\r\n     */\n\n    this.contentRect_ = createRectInit(0, 0, 0, 0);\n    this.target = target;\n  }\n  /**\r\n   * Updates content rectangle and tells whether it's width or height properties\r\n   * have changed since the last broadcast.\r\n   *\r\n   * @returns {boolean}\r\n   */\n\n\n  ResizeObservation.prototype.isActive = function () {\n    var rect = getContentRect(this.target);\n    this.contentRect_ = rect;\n    return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;\n  };\n  /**\r\n   * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n   * from the corresponding properties of the last observed content rectangle.\r\n   *\r\n   * @returns {DOMRectInit} Last observed content rectangle.\r\n   */\n\n\n  ResizeObservation.prototype.broadcastRect = function () {\n    var rect = this.contentRect_;\n    this.broadcastWidth = rect.width;\n    this.broadcastHeight = rect.height;\n    return rect;\n  };\n\n  return ResizeObservation;\n}();\n\nvar ResizeObserverEntry =\n/** @class */\nfunction () {\n  /**\r\n   * Creates an instance of ResizeObserverEntry.\r\n   *\r\n   * @param {Element} target - Element that is being observed.\r\n   * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n   */\n  function ResizeObserverEntry(target, rectInit) {\n    var contentRect = createReadOnlyRect(rectInit); // According to the specification following properties are not writable\n    // and are also not enumerable in the native implementation.\n    //\n    // Property accessors are not being used as they'd require to define a\n    // private WeakMap storage which may cause memory leaks in browsers that\n    // don't support this type of collections.\n\n    defineConfigurable(this, {\n      target: target,\n      contentRect: contentRect\n    });\n  }\n\n  return ResizeObserverEntry;\n}();\n\nvar ResizeObserverSPI =\n/** @class */\nfunction () {\n  /**\r\n   * Creates a new instance of ResizeObserver.\r\n   *\r\n   * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n   *      when one of the observed elements changes it's content dimensions.\r\n   * @param {ResizeObserverController} controller - Controller instance which\r\n   *      is responsible for the updates of observer.\r\n   * @param {ResizeObserver} callbackCtx - Reference to the public\r\n   *      ResizeObserver instance which will be passed to callback function.\r\n   */\n  function ResizeObserverSPI(callback, controller, callbackCtx) {\n    /**\r\n     * Collection of resize observations that have detected changes in dimensions\r\n     * of elements.\r\n     *\r\n     * @private {Array<ResizeObservation>}\r\n     */\n    this.activeObservations_ = [];\n    /**\r\n     * Registry of the ResizeObservation instances.\r\n     *\r\n     * @private {Map<Element, ResizeObservation>}\r\n     */\n\n    this.observations_ = new MapShim();\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('The callback provided as parameter 1 is not a function.');\n    }\n\n    this.callback_ = callback;\n    this.controller_ = controller;\n    this.callbackCtx_ = callbackCtx;\n  }\n  /**\r\n   * Starts observing provided element.\r\n   *\r\n   * @param {Element} target - Element to be observed.\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.observe = function (target) {\n    if (!arguments.length) {\n      throw new TypeError('1 argument required, but only 0 present.');\n    } // Do nothing if current environment doesn't have the Element interface.\n\n\n    if (typeof Element === 'undefined' || !(Element instanceof Object)) {\n      return;\n    }\n\n    if (!(target instanceof getWindowOf(target).Element)) {\n      throw new TypeError('parameter 1 is not of type \"Element\".');\n    }\n\n    var observations = this.observations_; // Do nothing if element is already being observed.\n\n    if (observations.has(target)) {\n      return;\n    }\n\n    observations.set(target, new ResizeObservation(target));\n    this.controller_.addObserver(this); // Force the update of observations.\n\n    this.controller_.refresh();\n  };\n  /**\r\n   * Stops observing provided element.\r\n   *\r\n   * @param {Element} target - Element to stop observing.\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.unobserve = function (target) {\n    if (!arguments.length) {\n      throw new TypeError('1 argument required, but only 0 present.');\n    } // Do nothing if current environment doesn't have the Element interface.\n\n\n    if (typeof Element === 'undefined' || !(Element instanceof Object)) {\n      return;\n    }\n\n    if (!(target instanceof getWindowOf(target).Element)) {\n      throw new TypeError('parameter 1 is not of type \"Element\".');\n    }\n\n    var observations = this.observations_; // Do nothing if element is not being observed.\n\n    if (!observations.has(target)) {\n      return;\n    }\n\n    observations.delete(target);\n\n    if (!observations.size) {\n      this.controller_.removeObserver(this);\n    }\n  };\n  /**\r\n   * Stops observing all elements.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.disconnect = function () {\n    this.clearActive();\n    this.observations_.clear();\n    this.controller_.removeObserver(this);\n  };\n  /**\r\n   * Collects observation instances the associated element of which has changed\r\n   * it's content rectangle.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.gatherActive = function () {\n    var _this = this;\n\n    this.clearActive();\n    this.observations_.forEach(function (observation) {\n      if (observation.isActive()) {\n        _this.activeObservations_.push(observation);\n      }\n    });\n  };\n  /**\r\n   * Invokes initial callback function with a list of ResizeObserverEntry\r\n   * instances collected from active resize observations.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.broadcastActive = function () {\n    // Do nothing if observer doesn't have active observations.\n    if (!this.hasActive()) {\n      return;\n    }\n\n    var ctx = this.callbackCtx_; // Create ResizeObserverEntry instance for every active observation.\n\n    var entries = this.activeObservations_.map(function (observation) {\n      return new ResizeObserverEntry(observation.target, observation.broadcastRect());\n    });\n    this.callback_.call(ctx, entries, ctx);\n    this.clearActive();\n  };\n  /**\r\n   * Clears the collection of active observations.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.clearActive = function () {\n    this.activeObservations_.splice(0);\n  };\n  /**\r\n   * Tells whether observer has active observations.\r\n   *\r\n   * @returns {boolean}\r\n   */\n\n\n  ResizeObserverSPI.prototype.hasActive = function () {\n    return this.activeObservations_.length > 0;\n  };\n\n  return ResizeObserverSPI;\n}(); // Registry of internal observers. If WeakMap is not available use current shim\n// for the Map collection as it has all required methods and because WeakMap\n// can't be fully polyfilled anyway.\n\n\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\n\nvar ResizeObserver =\n/** @class */\nfunction () {\n  /**\r\n   * Creates a new instance of ResizeObserver.\r\n   *\r\n   * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n   *      dimensions of the observed elements change.\r\n   */\n  function ResizeObserver(callback) {\n    if (!(this instanceof ResizeObserver)) {\n      throw new TypeError('Cannot call a class as a function.');\n    }\n\n    if (!arguments.length) {\n      throw new TypeError('1 argument required, but only 0 present.');\n    }\n\n    var controller = ResizeObserverController.getInstance();\n    var observer = new ResizeObserverSPI(callback, controller, this);\n    observers.set(this, observer);\n  }\n\n  return ResizeObserver;\n}(); // Expose public methods of ResizeObserver.\n\n\n['observe', 'unobserve', 'disconnect'].forEach(function (method) {\n  ResizeObserver.prototype[method] = function () {\n    var _a;\n\n    return (_a = observers.get(this))[method].apply(_a, arguments);\n  };\n});\n\nvar index = function () {\n  // Export existing implementation if available.\n  if (typeof global$1.ResizeObserver !== 'undefined') {\n    return global$1.ResizeObserver;\n  }\n\n  return ResizeObserver;\n}();\n\nexport default index;","/* smoothscroll v0.4.4 - 2019 - Dustan Kasten, Jeremias Menichelli - MIT License */\n(function () {\n  'use strict'; // polyfill\n\n  function polyfill() {\n    // aliases\n    var w = window;\n    var d = document; // return if scroll behavior is supported and polyfill is not forced\n\n    if ('scrollBehavior' in d.documentElement.style && w.__forceSmoothScrollPolyfill__ !== true) {\n      return;\n    } // globals\n\n\n    var Element = w.HTMLElement || w.Element;\n    var SCROLL_TIME = 468; // object gathering original scroll methods\n\n    var original = {\n      scroll: w.scroll || w.scrollTo,\n      scrollBy: w.scrollBy,\n      elementScroll: Element.prototype.scroll || scrollElement,\n      scrollIntoView: Element.prototype.scrollIntoView\n    }; // define timing method\n\n    var now = w.performance && w.performance.now ? w.performance.now.bind(w.performance) : Date.now;\n    /**\n     * indicates if a the current browser is made by Microsoft\n     * @method isMicrosoftBrowser\n     * @param {String} userAgent\n     * @returns {Boolean}\n     */\n\n    function isMicrosoftBrowser(userAgent) {\n      var userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];\n      return new RegExp(userAgentPatterns.join('|')).test(userAgent);\n    }\n    /*\n     * IE has rounding bug rounding down clientHeight and clientWidth and\n     * rounding up scrollHeight and scrollWidth causing false positives\n     * on hasScrollableSpace\n     */\n\n\n    var ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;\n    /**\n     * changes scroll position inside an element\n     * @method scrollElement\n     * @param {Number} x\n     * @param {Number} y\n     * @returns {undefined}\n     */\n\n    function scrollElement(x, y) {\n      this.scrollLeft = x;\n      this.scrollTop = y;\n    }\n    /**\n     * returns result of applying ease math function to a number\n     * @method ease\n     * @param {Number} k\n     * @returns {Number}\n     */\n\n\n    function ease(k) {\n      return 0.5 * (1 - Math.cos(Math.PI * k));\n    }\n    /**\n     * indicates if a smooth behavior should be applied\n     * @method shouldBailOut\n     * @param {Number|Object} firstArg\n     * @returns {Boolean}\n     */\n\n\n    function shouldBailOut(firstArg) {\n      if (firstArg === null || typeof firstArg !== 'object' || firstArg.behavior === undefined || firstArg.behavior === 'auto' || firstArg.behavior === 'instant') {\n        // first argument is not an object/null\n        // or behavior is auto, instant or undefined\n        return true;\n      }\n\n      if (typeof firstArg === 'object' && firstArg.behavior === 'smooth') {\n        // first argument is an object and behavior is smooth\n        return false;\n      } // throw error when behavior is not supported\n\n\n      throw new TypeError('behavior member of ScrollOptions ' + firstArg.behavior + ' is not a valid value for enumeration ScrollBehavior.');\n    }\n    /**\n     * indicates if an element has scrollable space in the provided axis\n     * @method hasScrollableSpace\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n\n\n    function hasScrollableSpace(el, axis) {\n      if (axis === 'Y') {\n        return el.clientHeight + ROUNDING_TOLERANCE < el.scrollHeight;\n      }\n\n      if (axis === 'X') {\n        return el.clientWidth + ROUNDING_TOLERANCE < el.scrollWidth;\n      }\n    }\n    /**\n     * indicates if an element has a scrollable overflow property in the axis\n     * @method canOverflow\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n\n\n    function canOverflow(el, axis) {\n      var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];\n      return overflowValue === 'auto' || overflowValue === 'scroll';\n    }\n    /**\n     * indicates if an element can be scrolled in either axis\n     * @method isScrollable\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n\n\n    function isScrollable(el) {\n      var isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');\n      var isScrollableX = hasScrollableSpace(el, 'X') && canOverflow(el, 'X');\n      return isScrollableY || isScrollableX;\n    }\n    /**\n     * finds scrollable parent of an element\n     * @method findScrollableParent\n     * @param {Node} el\n     * @returns {Node} el\n     */\n\n\n    function findScrollableParent(el) {\n      while (el !== d.body && isScrollable(el) === false) {\n        el = el.parentNode || el.host;\n      }\n\n      return el;\n    }\n    /**\n     * self invoked function that, given a context, steps through scrolling\n     * @method step\n     * @param {Object} context\n     * @returns {undefined}\n     */\n\n\n    function step(context) {\n      var time = now();\n      var value;\n      var currentX;\n      var currentY;\n      var elapsed = (time - context.startTime) / SCROLL_TIME; // avoid elapsed times higher than one\n\n      elapsed = elapsed > 1 ? 1 : elapsed; // apply easing to elapsed time\n\n      value = ease(elapsed);\n      currentX = context.startX + (context.x - context.startX) * value;\n      currentY = context.startY + (context.y - context.startY) * value;\n      context.method.call(context.scrollable, currentX, currentY); // scroll more if we have not reached our destination\n\n      if (currentX !== context.x || currentY !== context.y) {\n        w.requestAnimationFrame(step.bind(w, context));\n      }\n    }\n    /**\n     * scrolls window or element with a smooth behavior\n     * @method smoothScroll\n     * @param {Object|Node} el\n     * @param {Number} x\n     * @param {Number} y\n     * @returns {undefined}\n     */\n\n\n    function smoothScroll(el, x, y) {\n      var scrollable;\n      var startX;\n      var startY;\n      var method;\n      var startTime = now(); // define scroll context\n\n      if (el === d.body) {\n        scrollable = w;\n        startX = w.scrollX || w.pageXOffset;\n        startY = w.scrollY || w.pageYOffset;\n        method = original.scroll;\n      } else {\n        scrollable = el;\n        startX = el.scrollLeft;\n        startY = el.scrollTop;\n        method = scrollElement;\n      } // scroll looping over a frame\n\n\n      step({\n        scrollable: scrollable,\n        method: method,\n        startTime: startTime,\n        startX: startX,\n        startY: startY,\n        x: x,\n        y: y\n      });\n    } // ORIGINAL METHODS OVERRIDES\n    // w.scroll and w.scrollTo\n\n\n    w.scroll = w.scrollTo = function () {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      } // avoid smooth behavior if not required\n\n\n      if (shouldBailOut(arguments[0]) === true) {\n        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\n        arguments[0].top !== undefined ? arguments[0].top : arguments[1] !== undefined ? arguments[1] : w.scrollY || w.pageYOffset);\n        return;\n      } // LET THE SMOOTHNESS BEGIN!\n\n\n      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);\n    }; // w.scrollBy\n\n\n    w.scrollBy = function () {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      } // avoid smooth behavior if not required\n\n\n      if (shouldBailOut(arguments[0])) {\n        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);\n        return;\n      } // LET THE SMOOTHNESS BEGIN!\n\n\n      smoothScroll.call(w, d.body, ~~arguments[0].left + (w.scrollX || w.pageXOffset), ~~arguments[0].top + (w.scrollY || w.pageYOffset));\n    }; // Element.prototype.scroll and Element.prototype.scrollTo\n\n\n    Element.prototype.scroll = Element.prototype.scrollTo = function () {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      } // avoid smooth behavior if not required\n\n\n      if (shouldBailOut(arguments[0]) === true) {\n        // if one number is passed, throw error to match Firefox implementation\n        if (typeof arguments[0] === 'number' && arguments[1] === undefined) {\n          throw new SyntaxError('Value could not be converted');\n        }\n\n        original.elementScroll.call(this, // use left prop, first number argument or fallback to scrollLeft\n        arguments[0].left !== undefined ? ~~arguments[0].left : typeof arguments[0] !== 'object' ? ~~arguments[0] : this.scrollLeft, // use top prop, second argument or fallback to scrollTop\n        arguments[0].top !== undefined ? ~~arguments[0].top : arguments[1] !== undefined ? ~~arguments[1] : this.scrollTop);\n        return;\n      }\n\n      var left = arguments[0].left;\n      var top = arguments[0].top; // LET THE SMOOTHNESS BEGIN!\n\n      smoothScroll.call(this, this, typeof left === 'undefined' ? this.scrollLeft : ~~left, typeof top === 'undefined' ? this.scrollTop : ~~top);\n    }; // Element.prototype.scrollBy\n\n\n    Element.prototype.scrollBy = function () {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      } // avoid smooth behavior if not required\n\n\n      if (shouldBailOut(arguments[0]) === true) {\n        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);\n        return;\n      }\n\n      this.scroll({\n        left: ~~arguments[0].left + this.scrollLeft,\n        top: ~~arguments[0].top + this.scrollTop,\n        behavior: arguments[0].behavior\n      });\n    }; // Element.prototype.scrollIntoView\n\n\n    Element.prototype.scrollIntoView = function () {\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        original.scrollIntoView.call(this, arguments[0] === undefined ? true : arguments[0]);\n        return;\n      } // LET THE SMOOTHNESS BEGIN!\n\n\n      var scrollableParent = findScrollableParent(this);\n      var parentRects = scrollableParent.getBoundingClientRect();\n      var clientRects = this.getBoundingClientRect();\n\n      if (scrollableParent !== d.body) {\n        // reveal element inside parent\n        smoothScroll.call(this, scrollableParent, scrollableParent.scrollLeft + clientRects.left - parentRects.left, scrollableParent.scrollTop + clientRects.top - parentRects.top); // reveal parent in viewport unless is fixed\n\n        if (w.getComputedStyle(scrollableParent).position !== 'fixed') {\n          w.scrollBy({\n            left: parentRects.left,\n            top: parentRects.top,\n            behavior: 'smooth'\n          });\n        }\n      } else {\n        // reveal element in viewport\n        w.scrollBy({\n          left: clientRects.left,\n          top: clientRects.top,\n          behavior: 'smooth'\n        });\n      }\n    };\n  }\n\n  if (typeof exports === 'object' && typeof module !== 'undefined') {\n    // commonjs\n    module.exports = {\n      polyfill: polyfill\n    };\n  } else {\n    // global\n    polyfill();\n  }\n})();","'use strict';\nvar $ = require('../internals/export');\nvar $findIndex = require('../internals/array-iteration').findIndex;\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar arrayMethodUsesToLength = require('../internals/array-method-uses-to-length');\n\nvar FIND_INDEX = 'findIndex';\nvar SKIPS_HOLES = true;\n\nvar USES_TO_LENGTH = arrayMethodUsesToLength(FIND_INDEX);\n\n// Shouldn't skip holes\nif (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; });\n\n// `Array.prototype.findIndex` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.findindex\n$({ target: 'Array', proto: true, forced: SKIPS_HOLES || !USES_TO_LENGTH }, {\n  findIndex: function findIndex(callbackfn /* , that = undefined */) {\n    return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables(FIND_INDEX);\n"],"sourceRoot":""}