/* perfect-scrollbar v0.6.10 */
(function e(t, n, r) {
  function s(o, u) {
    if (!n[o]) {
      if (!t[o]) {
        var a = typeof require == "function" && require;
        if (!u && a) return a(o, !0);
        if (i) return i(o, !0);
        var f = new Error("Cannot find module '" + o + "'");
        throw ((f.code = "MODULE_NOT_FOUND"), f);
      }
      var l = (n[o] = { exports: {} });
      t[o][0].call(
        l.exports,
        function (e) {
          var n = t[o][1][e];
          return s(n ? n : e);
        },
        l,
        l.exports,
        e,
        t,
        n,
        r
      );
    }
    return n[o].exports;
  }
  var i = typeof require == "function" && require;
  for (var o = 0; o < r.length; o++) s(r[o]);
  return s;
})(
  {
    1: [
      function (require, module, exports) {
        "use strict";

        var ps = require("../main"),
          psInstances = require("../plugin/instances");

        function mountJQuery(jQuery) {
          jQuery.fn.perfectScrollbar = function (settingOrCommand) {
            return this.each(function () {
              if (
                typeof settingOrCommand === "object" ||
                typeof settingOrCommand === "undefined"
              ) {
                // If it's an object or none, initialize.
                var settings = settingOrCommand;

                if (!psInstances.get(this)) {
                  ps.initialize(this, settings);
                }
              } else {
                // Unless, it may be a command.
                var command = settingOrCommand;

                if (command === "update") {
                  ps.update(this);
                } else if (command === "destroy") {
                  ps.destroy(this);
                }
              }

              return jQuery(this);
            });
          };
        }

        if (typeof define === "function" && define.amd) {
          // AMD. Register as an anonymous module.
          define(["jquery"], mountJQuery);
        } else {
          var jq = window.jQuery ? window.jQuery : window.$;
          if (typeof jq !== "undefined") {
            mountJQuery(jq);
          }
        }

        module.exports = mountJQuery;
      },
      { "../main": 7, "../plugin/instances": 18 },
    ],
    2: [
      function (require, module, exports) {
        "use strict";

        function oldAdd(element, className) {
          var classes = element.className.split(" ");
          if (classes.indexOf(className) < 0) {
            classes.push(className);
          }
          element.className = classes.join(" ");
        }

        function oldRemove(element, className) {
          var classes = element.className.split(" ");
          var idx = classes.indexOf(className);
          if (idx >= 0) {
            classes.splice(idx, 1);
          }
          element.className = classes.join(" ");
        }

        exports.add = function (element, className) {
          if (element.classList) {
            element.classList.add(className);
          } else {
            oldAdd(element, className);
          }
        };

        exports.remove = function (element, className) {
          if (element.classList) {
            element.classList.remove(className);
          } else {
            oldRemove(element, className);
          }
        };

        exports.list = function (element) {
          if (element.classList) {
            return Array.prototype.slice.apply(element.classList);
          } else {
            return element.className.split(" ");
          }
        };
      },
      {},
    ],
    3: [
      function (require, module, exports) {
        "use strict";

        var DOM = {};

        DOM.e = function (tagName, className) {
          var element = document.createElement(tagName);
          element.className = className;
          return element;
        };

        DOM.appendTo = function (child, parent) {
          parent.appendChild(child);
          return child;
        };

        function cssGet(element, styleName) {
          return window.getComputedStyle(element)[styleName];
        }

        function cssSet(element, styleName, styleValue) {
          if (typeof styleValue === "number") {
            styleValue = styleValue.toString() + "px";
          }
          element.style[styleName] = styleValue;
          return element;
        }

        function cssMultiSet(element, obj) {
          for (var key in obj) {
            var val = obj[key];
            if (typeof val === "number") {
              val = val.toString() + "px";
            }
            element.style[key] = val;
          }
          return element;
        }

        DOM.css = function (element, styleNameOrObject, styleValue) {
          if (typeof styleNameOrObject === "object") {
            // multiple set with object
            return cssMultiSet(element, styleNameOrObject);
          } else {
            if (typeof styleValue === "undefined") {
              return cssGet(element, styleNameOrObject);
            } else {
              return cssSet(element, styleNameOrObject, styleValue);
            }
          }
        };

        DOM.matches = function (element, query) {
          if (typeof element.matches !== "undefined") {
            return element.matches(query);
          } else {
            if (typeof element.matchesSelector !== "undefined") {
              return element.matchesSelector(query);
            } else if (typeof element.webkitMatchesSelector !== "undefined") {
              return element.webkitMatchesSelector(query);
            } else if (typeof element.mozMatchesSelector !== "undefined") {
              return element.mozMatchesSelector(query);
            } else if (typeof element.msMatchesSelector !== "undefined") {
              return element.msMatchesSelector(query);
            }
          }
        };

        DOM.remove = function (element) {
          if (typeof element.remove !== "undefined") {
            element.remove();
          } else {
            if (element.parentNode) {
              element.parentNode.removeChild(element);
            }
          }
        };

        DOM.queryChildren = function (element, selector) {
          return Array.prototype.filter.call(
            element.childNodes,
            function (child) {
              return DOM.matches(child, selector);
            }
          );
        };

        module.exports = DOM;
      },
      {},
    ],
    4: [
      function (require, module, exports) {
        "use strict";

        var EventElement = function (element) {
          this.element = element;
          this.events = {};
        };

        EventElement.prototype.bind = function (eventName, handler) {
          if (typeof this.events[eventName] === "undefined") {
            this.events[eventName] = [];
          }
          this.events[eventName].push(handler);
          this.element.addEventListener(eventName, handler, false);
        };

        EventElement.prototype.unbind = function (eventName, handler) {
          var isHandlerProvided = typeof handler !== "undefined";
          this.events[eventName] = this.events[eventName].filter(function (
            hdlr
          ) {
            if (isHandlerProvided && hdlr !== handler) {
              return true;
            }
            this.element.removeEventListener(eventName, hdlr, false);
            return false;
          },
          this);
        };

        EventElement.prototype.unbindAll = function () {
          for (var name in this.events) {
            this.unbind(name);
          }
        };

        var EventManager = function () {
          this.eventElements = [];
        };

        EventManager.prototype.eventElement = function (element) {
          var ee = this.eventElements.filter(function (eventElement) {
            return eventElement.element === element;
          })[0];
          if (typeof ee === "undefined") {
            ee = new EventElement(element);
            this.eventElements.push(ee);
          }
          return ee;
        };

        EventManager.prototype.bind = function (element, eventName, handler) {
          this.eventElement(element).bind(eventName, handler);
        };

        EventManager.prototype.unbind = function (element, eventName, handler) {
          this.eventElement(element).unbind(eventName, handler);
        };

        EventManager.prototype.unbindAll = function () {
          for (var i = 0; i < this.eventElements.length; i++) {
            this.eventElements[i].unbindAll();
          }
        };

        EventManager.prototype.once = function (element, eventName, handler) {
          var ee = this.eventElement(element);
          var onceHandler = function (e) {
            ee.unbind(eventName, onceHandler);
            handler(e);
          };
          ee.bind(eventName, onceHandler);
        };

        module.exports = EventManager;
      },
      {},
    ],
    5: [
      function (require, module, exports) {
        "use strict";

        module.exports = (function () {
          function s4() {
            return Math.floor((1 + Math.random()) * 0x10000)
              .toString(16)
              .substring(1);
          }
          return function () {
            return (
              s4() +
              s4() +
              "-" +
              s4() +
              "-" +
              s4() +
              "-" +
              s4() +
              "-" +
              s4() +
              s4() +
              s4()
            );
          };
        })();
      },
      {},
    ],
    6: [
      function (require, module, exports) {
        "use strict";

        var cls = require("./class"),
          d = require("./dom");

        exports.toInt = function (x) {
          return parseInt(x, 10) || 0;
        };

        exports.clone = function (obj) {
          if (obj === null) {
            return null;
          } else if (typeof obj === "object") {
            var result = {};
            for (var key in obj) {
              result[key] = this.clone(obj[key]);
            }
            return result;
          } else {
            return obj;
          }
        };

        exports.extend = function (original, source) {
          var result = this.clone(original);
          for (var key in source) {
            result[key] = this.clone(source[key]);
          }
          return result;
        };

        exports.isEditable = function (el) {
          return (
            d.matches(el, "input,[contenteditable]") ||
            d.matches(el, "select,[contenteditable]") ||
            d.matches(el, "textarea,[contenteditable]") ||
            d.matches(el, "button,[contenteditable]")
          );
        };

        exports.removePsClasses = function (element) {
          var clsList = cls.list(element);
          for (var i = 0; i < clsList.length; i++) {
            var className = clsList[i];
            if (className.indexOf("ps-") === 0) {
              cls.remove(element, className);
            }
          }
        };

        exports.outerWidth = function (element) {
          return (
            this.toInt(d.css(element, "width")) +
            this.toInt(d.css(element, "paddingLeft")) +
            this.toInt(d.css(element, "paddingRight")) +
            this.toInt(d.css(element, "borderLeftWidth")) +
            this.toInt(d.css(element, "borderRightWidth"))
          );
        };

        exports.startScrolling = function (element, axis) {
          cls.add(element, "ps-in-scrolling");
          if (typeof axis !== "undefined") {
            cls.add(element, "ps-" + axis);
          } else {
            cls.add(element, "ps-x");
            cls.add(element, "ps-y");
          }
        };

        exports.stopScrolling = function (element, axis) {
          cls.remove(element, "ps-in-scrolling");
          if (typeof axis !== "undefined") {
            cls.remove(element, "ps-" + axis);
          } else {
            cls.remove(element, "ps-x");
            cls.remove(element, "ps-y");
          }
        };

        exports.env = {
          isWebKit: "WebkitAppearance" in document.documentElement.style,
          supportsTouch:
            "ontouchstart" in window ||
            (window.DocumentTouch && document instanceof window.DocumentTouch),
          supportsIePointer: window.navigator.msMaxTouchPoints !== null,
        };
      },
      { "./class": 2, "./dom": 3 },
    ],
    7: [
      function (require, module, exports) {
        "use strict";

        var destroy = require("./plugin/destroy"),
          initialize = require("./plugin/initialize"),
          update = require("./plugin/update");

        module.exports = {
          initialize: initialize,
          update: update,
          destroy: destroy,
        };
      },
      {
        "./plugin/destroy": 9,
        "./plugin/initialize": 17,
        "./plugin/update": 21,
      },
    ],
    8: [
      function (require, module, exports) {
        "use strict";

        module.exports = {
          maxScrollbarLength: null,
          minScrollbarLength: null,
          scrollXMarginOffset: 0,
          scrollYMarginOffset: 0,
          stopPropagationOnClick: true,
          suppressScrollX: false,
          suppressScrollY: false,
          swipePropagation: true,
          useBothWheelAxes: false,
          useKeyboard: true,
          useSelectionScroll: false,
          wheelPropagation: false,
          wheelSpeed: 1,
          theme: "default",
        };
      },
      {},
    ],
    9: [
      function (require, module, exports) {
        "use strict";

        var d = require("../lib/dom"),
          h = require("../lib/helper"),
          instances = require("./instances");

        module.exports = function (element) {
          var i = instances.get(element);

          if (!i) {
            return;
          }

          i.event.unbindAll();
          d.remove(i.scrollbarX);
          d.remove(i.scrollbarY);
          d.remove(i.scrollbarXRail);
          d.remove(i.scrollbarYRail);
          h.removePsClasses(element);

          instances.remove(element);
        };
      },
      { "../lib/dom": 3, "../lib/helper": 6, "./instances": 18 },
    ],
    10: [
      function (require, module, exports) {
        "use strict";

        var h = require("../../lib/helper"),
          instances = require("../instances"),
          updateGeometry = require("../update-geometry"),
          updateScroll = require("../update-scroll");

        function bindClickRailHandler(element, i) {
          function pageOffset(el) {
            return el.getBoundingClientRect();
          }
          var stopPropagation = window.Event.prototype.stopPropagation.bind;

          if (i.settings.stopPropagationOnClick) {
            i.event.bind(i.scrollbarY, "click", stopPropagation);
          }
          i.event.bind(i.scrollbarYRail, "click", function (e) {
            var halfOfScrollbarLength = h.toInt(i.scrollbarYHeight / 2);
            var positionTop =
              i.railYRatio *
              (e.pageY -
                window.pageYOffset -
                pageOffset(i.scrollbarYRail).top -
                halfOfScrollbarLength);
            var maxPositionTop =
              i.railYRatio * (i.railYHeight - i.scrollbarYHeight);
            var positionRatio = positionTop / maxPositionTop;

            if (positionRatio < 0) {
              positionRatio = 0;
            } else if (positionRatio > 1) {
              positionRatio = 1;
            }

            updateScroll(
              element,
              "top",
              (i.contentHeight - i.containerHeight) * positionRatio
            );
            updateGeometry(element);

            e.stopPropagation();
          });

          if (i.settings.stopPropagationOnClick) {
            i.event.bind(i.scrollbarX, "click", stopPropagation);
          }
          i.event.bind(i.scrollbarXRail, "click", function (e) {
            var halfOfScrollbarLength = h.toInt(i.scrollbarXWidth / 2);
            var positionLeft =
              i.railXRatio *
              (e.pageX -
                window.pageXOffset -
                pageOffset(i.scrollbarXRail).left -
                halfOfScrollbarLength);
            var maxPositionLeft =
              i.railXRatio * (i.railXWidth - i.scrollbarXWidth);
            var positionRatio = positionLeft / maxPositionLeft;

            if (positionRatio < 0) {
              positionRatio = 0;
            } else if (positionRatio > 1) {
              positionRatio = 1;
            }

            updateScroll(
              element,
              "left",
              (i.contentWidth - i.containerWidth) * positionRatio -
                i.negativeScrollAdjustment
            );
            updateGeometry(element);

            e.stopPropagation();
          });
        }

        module.exports = function (element) {
          var i = instances.get(element);
          bindClickRailHandler(element, i);
        };
      },
      {
        "../../lib/helper": 6,
        "../instances": 18,
        "../update-geometry": 19,
        "../update-scroll": 20,
      },
    ],
    11: [
      function (require, module, exports) {
        "use strict";

        var d = require("../../lib/dom"),
          h = require("../../lib/helper"),
          instances = require("../instances"),
          updateGeometry = require("../update-geometry"),
          updateScroll = require("../update-scroll");

        function bindMouseScrollXHandler(element, i) {
          var currentLeft = null;
          var currentPageX = null;

          function updateScrollLeft(deltaX) {
            var newLeft = currentLeft + deltaX * i.railXRatio;
            var maxLeft =
              Math.max(0, i.scrollbarXRail.getBoundingClientRect().left) +
              i.railXRatio * (i.railXWidth - i.scrollbarXWidth);

            if (newLeft < 0) {
              i.scrollbarXLeft = 0;
            } else if (newLeft > maxLeft) {
              i.scrollbarXLeft = maxLeft;
            } else {
              i.scrollbarXLeft = newLeft;
            }

            var scrollLeft =
              h.toInt(
                (i.scrollbarXLeft * (i.contentWidth - i.containerWidth)) /
                  (i.containerWidth - i.railXRatio * i.scrollbarXWidth)
              ) - i.negativeScrollAdjustment;
            updateScroll(element, "left", scrollLeft);
          }

          var mouseMoveHandler = function (e) {
            updateScrollLeft(e.pageX - currentPageX);
            updateGeometry(element);
            e.stopPropagation();
            e.preventDefault();
          };

          var mouseUpHandler = function () {
            h.stopScrolling(element, "x");
            i.event.unbind(i.ownerDocument, "mousemove", mouseMoveHandler);
          };

          i.event.bind(i.scrollbarX, "mousedown", function (e) {
            currentPageX = e.pageX;
            currentLeft = h.toInt(d.css(i.scrollbarX, "left")) * i.railXRatio;
            h.startScrolling(element, "x");

            i.event.bind(i.ownerDocument, "mousemove", mouseMoveHandler);
            i.event.once(i.ownerDocument, "mouseup", mouseUpHandler);

            e.stopPropagation();
            e.preventDefault();
          });
        }

        function bindMouseScrollYHandler(element, i) {
          var currentTop = null;
          var currentPageY = null;

          function updateScrollTop(deltaY) {
            var newTop = currentTop + deltaY * i.railYRatio;
            var maxTop =
              Math.max(0, i.scrollbarYRail.getBoundingClientRect().top) +
              i.railYRatio * (i.railYHeight - i.scrollbarYHeight);

            if (newTop < 0) {
              i.scrollbarYTop = 0;
            } else if (newTop > maxTop) {
              i.scrollbarYTop = maxTop;
            } else {
              i.scrollbarYTop = newTop;
            }

            var scrollTop = h.toInt(
              (i.scrollbarYTop * (i.contentHeight - i.containerHeight)) /
                (i.containerHeight - i.railYRatio * i.scrollbarYHeight)
            );
            updateScroll(element, "top", scrollTop);
          }

          var mouseMoveHandler = function (e) {
            updateScrollTop(e.pageY - currentPageY);
            updateGeometry(element);
            e.stopPropagation();
            e.preventDefault();
          };

          var mouseUpHandler = function () {
            h.stopScrolling(element, "y");
            i.event.unbind(i.ownerDocument, "mousemove", mouseMoveHandler);
          };

          i.event.bind(i.scrollbarY, "mousedown", function (e) {
            currentPageY = e.pageY;
            currentTop = h.toInt(d.css(i.scrollbarY, "top")) * i.railYRatio;
            h.startScrolling(element, "y");

            i.event.bind(i.ownerDocument, "mousemove", mouseMoveHandler);
            i.event.once(i.ownerDocument, "mouseup", mouseUpHandler);

            e.stopPropagation();
            e.preventDefault();
          });
        }

        module.exports = function (element) {
          var i = instances.get(element);
          bindMouseScrollXHandler(element, i);
          bindMouseScrollYHandler(element, i);
        };
      },
      {
        "../../lib/dom": 3,
        "../../lib/helper": 6,
        "../instances": 18,
        "../update-geometry": 19,
        "../update-scroll": 20,
      },
    ],
    12: [
      function (require, module, exports) {
        "use strict";

        var h = require("../../lib/helper"),
          d = require("../../lib/dom"),
          instances = require("../instances"),
          updateGeometry = require("../update-geometry"),
          updateScroll = require("../update-scroll");

        function bindKeyboardHandler(element, i) {
          var hovered = false;
          i.event.bind(element, "mouseenter", function () {
            hovered = true;
          });
          i.event.bind(element, "mouseleave", function () {
            hovered = false;
          });

          var shouldPrevent = false;
          function shouldPreventDefault(deltaX, deltaY) {
            var scrollTop = element.scrollTop;
            if (deltaX === 0) {
              if (!i.scrollbarYActive) {
                return false;
              }
              if (
                (scrollTop === 0 && deltaY > 0) ||
                (scrollTop >= i.contentHeight - i.containerHeight && deltaY < 0)
              ) {
                return !i.settings.wheelPropagation;
              }
            }

            var scrollLeft = element.scrollLeft;
            if (deltaY === 0) {
              if (!i.scrollbarXActive) {
                return false;
              }
              if (
                (scrollLeft === 0 && deltaX < 0) ||
                (scrollLeft >= i.contentWidth - i.containerWidth && deltaX > 0)
              ) {
                return !i.settings.wheelPropagation;
              }
            }
            return true;
          }

          i.event.bind(i.ownerDocument, "keydown", function (e) {
            if (e.isDefaultPrevented && e.isDefaultPrevented()) {
              return;
            }

            var focused =
              d.matches(i.scrollbarX, ":focus") ||
              d.matches(i.scrollbarY, ":focus");

            if (!hovered && !focused) {
              return;
            }

            var activeElement = document.activeElement
              ? document.activeElement
              : i.ownerDocument.activeElement;
            if (activeElement) {
              // go deeper if element is a webcomponent
              while (activeElement.shadowRoot) {
                activeElement = activeElement.shadowRoot.activeElement;
              }
              if (h.isEditable(activeElement)) {
                return;
              }
            }

            var deltaX = 0;
            var deltaY = 0;

            switch (e.which) {
              case 37: // left
                deltaX = -30;
                break;
              case 38: // up
                deltaY = 30;
                break;
              case 39: // right
                deltaX = 30;
                break;
              case 40: // down
                deltaY = -30;
                break;
              case 33: // page up
                deltaY = 90;
                break;
              case 32: // space bar
                if (e.shiftKey) {
                  deltaY = 90;
                } else {
                  deltaY = -90;
                }
                break;
              case 34: // page down
                deltaY = -90;
                break;
              case 35: // end
                if (e.ctrlKey) {
                  deltaY = -i.contentHeight;
                } else {
                  deltaY = -i.containerHeight;
                }
                break;
              case 36: // home
                if (e.ctrlKey) {
                  deltaY = element.scrollTop;
                } else {
                  deltaY = i.containerHeight;
                }
                break;
              default:
                return;
            }

            updateScroll(element, "top", element.scrollTop - deltaY);
            updateScroll(element, "left", element.scrollLeft + deltaX);
            updateGeometry(element);

            shouldPrevent = shouldPreventDefault(deltaX, deltaY);
            if (shouldPrevent) {
              e.preventDefault();
            }
          });
        }

        module.exports = function (element) {
          var i = instances.get(element);
          bindKeyboardHandler(element, i);
        };
      },
      {
        "../../lib/dom": 3,
        "../../lib/helper": 6,
        "../instances": 18,
        "../update-geometry": 19,
        "../update-scroll": 20,
      },
    ],
    13: [
      function (require, module, exports) {
        "use strict";

        var instances = require("../instances"),
          updateGeometry = require("../update-geometry"),
          updateScroll = require("../update-scroll");

        function bindMouseWheelHandler(element, i) {
          var shouldPrevent = false;

          function shouldPreventDefault(deltaX, deltaY) {
            var scrollTop = element.scrollTop;
            if (deltaX === 0) {
              if (!i.scrollbarYActive) {
                return false;
              }
              if (
                (scrollTop === 0 && deltaY > 0) ||
                (scrollTop >= i.contentHeight - i.containerHeight && deltaY < 0)
              ) {
                return !i.settings.wheelPropagation;
              }
            }

            var scrollLeft = element.scrollLeft;
            if (deltaY === 0) {
              if (!i.scrollbarXActive) {
                return false;
              }
              if (
                (scrollLeft === 0 && deltaX < 0) ||
                (scrollLeft >= i.contentWidth - i.containerWidth && deltaX > 0)
              ) {
                return !i.settings.wheelPropagation;
              }
            }
            return true;
          }

          function getDeltaFromEvent(e) {
            var deltaX = e.deltaX;
            var deltaY = -1 * e.deltaY;

            if (
              typeof deltaX === "undefined" ||
              typeof deltaY === "undefined"
            ) {
              // OS X Safari
              deltaX = (-1 * e.wheelDeltaX) / 6;
              deltaY = e.wheelDeltaY / 6;
            }

            if (e.deltaMode && e.deltaMode === 1) {
              // Firefox in deltaMode 1: Line scrolling
              deltaX *= 10;
              deltaY *= 10;
            }

            if (deltaX !== deltaX && deltaY !== deltaY /* NaN checks */) {
              // IE in some mouse drivers
              deltaX = 0;
              deltaY = e.wheelDelta;
            }

            return [deltaX, deltaY];
          }

          function shouldBeConsumedByTextarea(deltaX, deltaY) {
            var hoveredTextarea = element.querySelector("textarea:hover");
            if (hoveredTextarea) {
              var maxScrollTop =
                hoveredTextarea.scrollHeight - hoveredTextarea.clientHeight;
              if (maxScrollTop > 0) {
                if (
                  !(hoveredTextarea.scrollTop === 0 && deltaY > 0) &&
                  !(hoveredTextarea.scrollTop === maxScrollTop && deltaY < 0)
                ) {
                  return true;
                }
              }
              var maxScrollLeft =
                hoveredTextarea.scrollLeft - hoveredTextarea.clientWidth;
              if (maxScrollLeft > 0) {
                if (
                  !(hoveredTextarea.scrollLeft === 0 && deltaX < 0) &&
                  !(hoveredTextarea.scrollLeft === maxScrollLeft && deltaX > 0)
                ) {
                  return true;
                }
              }
            }
            return false;
          }

          function mousewheelHandler(e) {
            var delta = getDeltaFromEvent(e);

            var deltaX = delta[0];
            var deltaY = delta[1];

            if (shouldBeConsumedByTextarea(deltaX, deltaY)) {
              return;
            }

            shouldPrevent = false;
            if (!i.settings.useBothWheelAxes) {
              // deltaX will only be used for horizontal scrolling and deltaY will
              // only be used for vertical scrolling - this is the default
              updateScroll(
                element,
                "top",
                element.scrollTop - deltaY * i.settings.wheelSpeed
              );
              updateScroll(
                element,
                "left",
                element.scrollLeft + deltaX * i.settings.wheelSpeed
              );
            } else if (i.scrollbarYActive && !i.scrollbarXActive) {
              // only vertical scrollbar is active and useBothWheelAxes option is
              // active, so let's scroll vertical bar using both mouse wheel axes
              if (deltaY) {
                updateScroll(
                  element,
                  "top",
                  element.scrollTop - deltaY * i.settings.wheelSpeed
                );
              } else {
                updateScroll(
                  element,
                  "top",
                  element.scrollTop + deltaX * i.settings.wheelSpeed
                );
              }
              shouldPrevent = true;
            } else if (i.scrollbarXActive && !i.scrollbarYActive) {
              // useBothWheelAxes and only horizontal bar is active, so use both
              // wheel axes for horizontal bar
              if (deltaX) {
                updateScroll(
                  element,
                  "left",
                  element.scrollLeft + deltaX * i.settings.wheelSpeed
                );
              } else {
                updateScroll(
                  element,
                  "left",
                  element.scrollLeft - deltaY * i.settings.wheelSpeed
                );
              }
              shouldPrevent = true;
            }

            updateGeometry(element);

            shouldPrevent =
              shouldPrevent || shouldPreventDefault(deltaX, deltaY);
            if (shouldPrevent) {
              e.stopPropagation();
              e.preventDefault();
            }
          }

          if (typeof window.onwheel !== "undefined") {
            i.event.bind(element, "wheel", mousewheelHandler);
          } else if (typeof window.onmousewheel !== "undefined") {
            i.event.bind(element, "mousewheel", mousewheelHandler);
          }
        }

        module.exports = function (element) {
          var i = instances.get(element);
          bindMouseWheelHandler(element, i);
        };
      },
      { "../instances": 18, "../update-geometry": 19, "../update-scroll": 20 },
    ],
    14: [
      function (require, module, exports) {
        "use strict";

        var instances = require("../instances"),
          updateGeometry = require("../update-geometry");

        function bindNativeScrollHandler(element, i) {
          i.event.bind(element, "scroll", function () {
            updateGeometry(element);
          });
        }

        module.exports = function (element) {
          var i = instances.get(element);
          bindNativeScrollHandler(element, i);
        };
      },
      { "../instances": 18, "../update-geometry": 19 },
    ],
    15: [
      function (require, module, exports) {
        "use strict";

        var h = require("../../lib/helper"),
          instances = require("../instances"),
          updateGeometry = require("../update-geometry"),
          updateScroll = require("../update-scroll");

        function bindSelectionHandler(element, i) {
          function getRangeNode() {
            var selection = window.getSelection
              ? window.getSelection()
              : document.getSelection
              ? document.getSelection()
              : "";
            if (selection.toString().length === 0) {
              return null;
            } else {
              return selection.getRangeAt(0).commonAncestorContainer;
            }
          }

          var scrollingLoop = null;
          var scrollDiff = { top: 0, left: 0 };
          function startScrolling() {
            if (!scrollingLoop) {
              scrollingLoop = setInterval(function () {
                if (!instances.get(element)) {
                  clearInterval(scrollingLoop);
                  return;
                }

                updateScroll(
                  element,
                  "top",
                  element.scrollTop + scrollDiff.top
                );
                updateScroll(
                  element,
                  "left",
                  element.scrollLeft + scrollDiff.left
                );
                updateGeometry(element);
              }, 50); // every .1 sec
            }
          }
          function stopScrolling() {
            if (scrollingLoop) {
              clearInterval(scrollingLoop);
              scrollingLoop = null;
            }
            h.stopScrolling(element);
          }

          var isSelected = false;
          i.event.bind(i.ownerDocument, "selectionchange", function () {
            if (element.contains(getRangeNode())) {
              isSelected = true;
            } else {
              isSelected = false;
              stopScrolling();
            }
          });
          i.event.bind(window, "mouseup", function () {
            if (isSelected) {
              isSelected = false;
              stopScrolling();
            }
          });

          i.event.bind(window, "mousemove", function (e) {
            if (isSelected) {
              var mousePosition = { x: e.pageX, y: e.pageY };
              var containerGeometry = {
                left: element.offsetLeft,
                right: element.offsetLeft + element.offsetWidth,
                top: element.offsetTop,
                bottom: element.offsetTop + element.offsetHeight,
              };

              if (mousePosition.x < containerGeometry.left + 3) {
                scrollDiff.left = -5;
                h.startScrolling(element, "x");
              } else if (mousePosition.x > containerGeometry.right - 3) {
                scrollDiff.left = 5;
                h.startScrolling(element, "x");
              } else {
                scrollDiff.left = 0;
              }

              if (mousePosition.y < containerGeometry.top + 3) {
                if (containerGeometry.top + 3 - mousePosition.y < 5) {
                  scrollDiff.top = -5;
                } else {
                  scrollDiff.top = -20;
                }
                h.startScrolling(element, "y");
              } else if (mousePosition.y > containerGeometry.bottom - 3) {
                if (mousePosition.y - containerGeometry.bottom + 3 < 5) {
                  scrollDiff.top = 5;
                } else {
                  scrollDiff.top = 20;
                }
                h.startScrolling(element, "y");
              } else {
                scrollDiff.top = 0;
              }

              if (scrollDiff.top === 0 && scrollDiff.left === 0) {
                stopScrolling();
              } else {
                startScrolling();
              }
            }
          });
        }

        module.exports = function (element) {
          var i = instances.get(element);
          bindSelectionHandler(element, i);
        };
      },
      {
        "../../lib/helper": 6,
        "../instances": 18,
        "../update-geometry": 19,
        "../update-scroll": 20,
      },
    ],
    16: [
      function (require, module, exports) {
        "use strict";

        var instances = require("../instances"),
          updateGeometry = require("../update-geometry"),
          updateScroll = require("../update-scroll");

        function bindTouchHandler(
          element,
          i,
          supportsTouch,
          supportsIePointer
        ) {
          function shouldPreventDefault(deltaX, deltaY) {
            var scrollTop = element.scrollTop;
            var scrollLeft = element.scrollLeft;
            var magnitudeX = Math.abs(deltaX);
            var magnitudeY = Math.abs(deltaY);

            if (magnitudeY > magnitudeX) {
              // user is perhaps trying to swipe up/down the page

              if (
                (deltaY < 0 &&
                  scrollTop === i.contentHeight - i.containerHeight) ||
                (deltaY > 0 && scrollTop === 0)
              ) {
                return !i.settings.swipePropagation;
              }
            } else if (magnitudeX > magnitudeY) {
              // user is perhaps trying to swipe left/right across the page

              if (
                (deltaX < 0 &&
                  scrollLeft === i.contentWidth - i.containerWidth) ||
                (deltaX > 0 && scrollLeft === 0)
              ) {
                return !i.settings.swipePropagation;
              }
            }

            return true;
          }

          function applyTouchMove(differenceX, differenceY) {
            updateScroll(element, "top", element.scrollTop - differenceY);
            updateScroll(element, "left", element.scrollLeft - differenceX);

            updateGeometry(element);
          }

          var startOffset = {};
          var startTime = 0;
          var speed = {};
          var easingLoop = null;
          var inGlobalTouch = false;
          var inLocalTouch = false;

          function globalTouchStart() {
            inGlobalTouch = true;
          }
          function globalTouchEnd() {
            inGlobalTouch = false;
          }

          function getTouch(e) {
            if (e.targetTouches) {
              return e.targetTouches[0];
            } else {
              // Maybe IE pointer
              return e;
            }
          }
          function shouldHandle(e) {
            if (e.targetTouches && e.targetTouches.length === 1) {
              return true;
            }
            if (
              e.pointerType &&
              e.pointerType !== "mouse" &&
              e.pointerType !== e.MSPOINTER_TYPE_MOUSE
            ) {
              return true;
            }
            return false;
          }
          function touchStart(e) {
            if (shouldHandle(e)) {
              inLocalTouch = true;

              var touch = getTouch(e);

              startOffset.pageX = touch.pageX;
              startOffset.pageY = touch.pageY;

              startTime = new Date().getTime();

              if (easingLoop !== null) {
                clearInterval(easingLoop);
              }

              e.stopPropagation();
            }
          }
          function touchMove(e) {
            if (!inGlobalTouch && inLocalTouch && shouldHandle(e)) {
              var touch = getTouch(e);

              var currentOffset = { pageX: touch.pageX, pageY: touch.pageY };

              var differenceX = currentOffset.pageX - startOffset.pageX;
              var differenceY = currentOffset.pageY - startOffset.pageY;

              applyTouchMove(differenceX, differenceY);
              startOffset = currentOffset;

              var currentTime = new Date().getTime();

              var timeGap = currentTime - startTime;
              if (timeGap > 0) {
                speed.x = differenceX / timeGap;
                speed.y = differenceY / timeGap;
                startTime = currentTime;
              }

              if (shouldPreventDefault(differenceX, differenceY)) {
                e.stopPropagation();
                e.preventDefault();
              }
            }
          }
          function touchEnd() {
            if (!inGlobalTouch && inLocalTouch) {
              inLocalTouch = false;

              clearInterval(easingLoop);
              easingLoop = setInterval(function () {
                if (!instances.get(element)) {
                  clearInterval(easingLoop);
                  return;
                }

                if (Math.abs(speed.x) < 0.01 && Math.abs(speed.y) < 0.01) {
                  clearInterval(easingLoop);
                  return;
                }

                applyTouchMove(speed.x * 30, speed.y * 30);

                speed.x *= 0.8;
                speed.y *= 0.8;
              }, 10);
            }
          }

          if (supportsTouch) {
            i.event.bind(window, "touchstart", globalTouchStart);
            i.event.bind(window, "touchend", globalTouchEnd);
            i.event.bind(element, "touchstart", touchStart);
            i.event.bind(element, "touchmove", touchMove);
            i.event.bind(element, "touchend", touchEnd);
          }

          if (supportsIePointer) {
            if (window.PointerEvent) {
              i.event.bind(window, "pointerdown", globalTouchStart);
              i.event.bind(window, "pointerup", globalTouchEnd);
              i.event.bind(element, "pointerdown", touchStart);
              i.event.bind(element, "pointermove", touchMove);
              i.event.bind(element, "pointerup", touchEnd);
            } else if (window.MSPointerEvent) {
              i.event.bind(window, "MSPointerDown", globalTouchStart);
              i.event.bind(window, "MSPointerUp", globalTouchEnd);
              i.event.bind(element, "MSPointerDown", touchStart);
              i.event.bind(element, "MSPointerMove", touchMove);
              i.event.bind(element, "MSPointerUp", touchEnd);
            }
          }
        }

        module.exports = function (element, supportsTouch, supportsIePointer) {
          var i = instances.get(element);
          bindTouchHandler(element, i, supportsTouch, supportsIePointer);
        };
      },
      { "../instances": 18, "../update-geometry": 19, "../update-scroll": 20 },
    ],
    17: [
      function (require, module, exports) {
        "use strict";

        var cls = require("../lib/class"),
          h = require("../lib/helper"),
          instances = require("./instances"),
          updateGeometry = require("./update-geometry");

        // Handlers
        var clickRailHandler = require("./handler/click-rail"),
          dragScrollbarHandler = require("./handler/drag-scrollbar"),
          keyboardHandler = require("./handler/keyboard"),
          mouseWheelHandler = require("./handler/mouse-wheel"),
          nativeScrollHandler = require("./handler/native-scroll"),
          selectionHandler = require("./handler/selection"),
          touchHandler = require("./handler/touch");

        module.exports = function (element, userSettings) {
          userSettings = typeof userSettings === "object" ? userSettings : {};

          cls.add(element, "ps-container");

          // Create a plugin instance.
          var i = instances.add(element);

          i.settings = h.extend(i.settings, userSettings);
          cls.add(element, "ps-theme-" + i.settings.theme);

          clickRailHandler(element);
          dragScrollbarHandler(element);
          mouseWheelHandler(element);
          nativeScrollHandler(element);

          if (i.settings.useSelectionScroll) {
            selectionHandler(element);
          }

          if (h.env.supportsTouch || h.env.supportsIePointer) {
            touchHandler(element, h.env.supportsTouch, h.env.supportsIePointer);
          }
          if (i.settings.useKeyboard) {
            keyboardHandler(element);
          }

          updateGeometry(element);
        };
      },
      {
        "../lib/class": 2,
        "../lib/helper": 6,
        "./handler/click-rail": 10,
        "./handler/drag-scrollbar": 11,
        "./handler/keyboard": 12,
        "./handler/mouse-wheel": 13,
        "./handler/native-scroll": 14,
        "./handler/selection": 15,
        "./handler/touch": 16,
        "./instances": 18,
        "./update-geometry": 19,
      },
    ],
    18: [
      function (require, module, exports) {
        "use strict";

        var cls = require("../lib/class"),
          d = require("../lib/dom"),
          defaultSettings = require("./default-setting"),
          EventManager = require("../lib/event-manager"),
          guid = require("../lib/guid"),
          h = require("../lib/helper");

        var instances = {};

        function Instance(element) {
          var i = this;

          i.settings = h.clone(defaultSettings);
          i.containerWidth = null;
          i.containerHeight = null;
          i.contentWidth = null;
          i.contentHeight = null;

          i.isRtl = d.css(element, "direction") === "rtl";
          i.isNegativeScroll = (function () {
            var originalScrollLeft = element.scrollLeft;
            var result = null;
            element.scrollLeft = -1;
            result = element.scrollLeft < 0;
            element.scrollLeft = originalScrollLeft;
            return result;
          })();
          i.negativeScrollAdjustment = i.isNegativeScroll
            ? element.scrollWidth - element.clientWidth
            : 0;
          i.event = new EventManager();
          i.ownerDocument = element.ownerDocument || document;

          function focus() {
            cls.add(element, "ps-focus");
          }

          function blur() {
            cls.remove(element, "ps-focus");
          }

          i.scrollbarXRail = d.appendTo(
            d.e("div", "ps-scrollbar-x-rail"),
            element
          );
          i.scrollbarX = d.appendTo(
            d.e("div", "ps-scrollbar-x"),
            i.scrollbarXRail
          );
          i.scrollbarX.setAttribute("tabindex", 0);
          i.event.bind(i.scrollbarX, "focus", focus);
          i.event.bind(i.scrollbarX, "blur", blur);
          i.scrollbarXActive = null;
          i.scrollbarXWidth = null;
          i.scrollbarXLeft = null;
          i.scrollbarXBottom = h.toInt(d.css(i.scrollbarXRail, "bottom"));
          i.isScrollbarXUsingBottom = i.scrollbarXBottom === i.scrollbarXBottom; // !isNaN
          i.scrollbarXTop = i.isScrollbarXUsingBottom
            ? null
            : h.toInt(d.css(i.scrollbarXRail, "top"));
          i.railBorderXWidth =
            h.toInt(d.css(i.scrollbarXRail, "borderLeftWidth")) +
            h.toInt(d.css(i.scrollbarXRail, "borderRightWidth"));
          // Set rail to display:block to calculate margins
          d.css(i.scrollbarXRail, "display", "block");
          i.railXMarginWidth =
            h.toInt(d.css(i.scrollbarXRail, "marginLeft")) +
            h.toInt(d.css(i.scrollbarXRail, "marginRight"));
          d.css(i.scrollbarXRail, "display", "");
          i.railXWidth = null;
          i.railXRatio = null;

          i.scrollbarYRail = d.appendTo(
            d.e("div", "ps-scrollbar-y-rail"),
            element
          );
          i.scrollbarY = d.appendTo(
            d.e("div", "ps-scrollbar-y"),
            i.scrollbarYRail
          );
          i.scrollbarY.setAttribute("tabindex", 0);
          i.event.bind(i.scrollbarY, "focus", focus);
          i.event.bind(i.scrollbarY, "blur", blur);
          i.scrollbarYActive = null;
          i.scrollbarYHeight = null;
          i.scrollbarYTop = null;
          i.scrollbarYRight = h.toInt(d.css(i.scrollbarYRail, "right"));
          i.isScrollbarYUsingRight = i.scrollbarYRight === i.scrollbarYRight; // !isNaN
          i.scrollbarYLeft = i.isScrollbarYUsingRight
            ? null
            : h.toInt(d.css(i.scrollbarYRail, "left"));
          i.scrollbarYOuterWidth = i.isRtl ? h.outerWidth(i.scrollbarY) : null;
          i.railBorderYWidth =
            h.toInt(d.css(i.scrollbarYRail, "borderTopWidth")) +
            h.toInt(d.css(i.scrollbarYRail, "borderBottomWidth"));
          d.css(i.scrollbarYRail, "display", "block");
          i.railYMarginHeight =
            h.toInt(d.css(i.scrollbarYRail, "marginTop")) +
            h.toInt(d.css(i.scrollbarYRail, "marginBottom"));
          d.css(i.scrollbarYRail, "display", "");
          i.railYHeight = null;
          i.railYRatio = null;
        }

        function getId(element) {
          if (typeof element.dataset === "undefined") {
            return element.getAttribute("data-ps-id");
          } else {
            return element.dataset.psId;
          }
        }

        function setId(element, id) {
          if (typeof element.dataset === "undefined") {
            element.setAttribute("data-ps-id", id);
          } else {
            element.dataset.psId = id;
          }
        }

        function removeId(element) {
          if (typeof element.dataset === "undefined") {
            element.removeAttribute("data-ps-id");
          } else {
            delete element.dataset.psId;
          }
        }

        exports.add = function (element) {
          var newId = guid();
          setId(element, newId);
          instances[newId] = new Instance(element);
          return instances[newId];
        };

        exports.remove = function (element) {
          delete instances[getId(element)];
          removeId(element);
        };

        exports.get = function (element) {
          return instances[getId(element)];
        };
      },
      {
        "../lib/class": 2,
        "../lib/dom": 3,
        "../lib/event-manager": 4,
        "../lib/guid": 5,
        "../lib/helper": 6,
        "./default-setting": 8,
      },
    ],
    19: [
      function (require, module, exports) {
        "use strict";

        var cls = require("../lib/class"),
          d = require("../lib/dom"),
          h = require("../lib/helper"),
          instances = require("./instances"),
          updateScroll = require("./update-scroll");

        function getThumbSize(i, thumbSize) {
          if (i.settings.minScrollbarLength) {
            thumbSize = Math.max(thumbSize, i.settings.minScrollbarLength);
          }
          if (i.settings.maxScrollbarLength) {
            thumbSize = Math.min(thumbSize, i.settings.maxScrollbarLength);
          }
          return thumbSize;
        }

        function updateCss(element, i) {
          var xRailOffset = { width: i.railXWidth };
          if (i.isRtl) {
            xRailOffset.left =
              i.negativeScrollAdjustment +
              element.scrollLeft +
              i.containerWidth -
              i.contentWidth;
          } else {
            xRailOffset.left = element.scrollLeft;
          }
          if (i.isScrollbarXUsingBottom) {
            xRailOffset.bottom = i.scrollbarXBottom - element.scrollTop;
          } else {
            xRailOffset.top = i.scrollbarXTop + element.scrollTop;
          }
          d.css(i.scrollbarXRail, xRailOffset);

          var yRailOffset = { top: element.scrollTop, height: i.railYHeight };
          if (i.isScrollbarYUsingRight) {
            if (i.isRtl) {
              yRailOffset.right =
                i.contentWidth -
                (i.negativeScrollAdjustment + element.scrollLeft) -
                i.scrollbarYRight -
                i.scrollbarYOuterWidth;
            } else {
              yRailOffset.right = i.scrollbarYRight - element.scrollLeft;
            }
          } else {
            if (i.isRtl) {
              yRailOffset.left =
                i.negativeScrollAdjustment +
                element.scrollLeft +
                i.containerWidth * 2 -
                i.contentWidth -
                i.scrollbarYLeft -
                i.scrollbarYOuterWidth;
            } else {
              yRailOffset.left = i.scrollbarYLeft + element.scrollLeft;
            }
          }
          d.css(i.scrollbarYRail, yRailOffset);

          d.css(i.scrollbarX, {
            left: i.scrollbarXLeft,
            width: i.scrollbarXWidth - i.railBorderXWidth,
          });
          d.css(i.scrollbarY, {
            top: i.scrollbarYTop,
            height: i.scrollbarYHeight - i.railBorderYWidth,
          });
        }

        module.exports = function (element) {
          var i = instances.get(element);

          i.containerWidth = element.clientWidth;
          i.containerHeight = element.clientHeight;
          i.contentWidth = element.scrollWidth;
          i.contentHeight = element.scrollHeight;

          var existingRails;
          if (!element.contains(i.scrollbarXRail)) {
            existingRails = d.queryChildren(element, ".ps-scrollbar-x-rail");
            if (existingRails.length > 0) {
              existingRails.forEach(function (rail) {
                d.remove(rail);
              });
            }
            d.appendTo(i.scrollbarXRail, element);
          }
          if (!element.contains(i.scrollbarYRail)) {
            existingRails = d.queryChildren(element, ".ps-scrollbar-y-rail");
            if (existingRails.length > 0) {
              existingRails.forEach(function (rail) {
                d.remove(rail);
              });
            }
            d.appendTo(i.scrollbarYRail, element);
          }

          if (
            !i.settings.suppressScrollX &&
            i.containerWidth + i.settings.scrollXMarginOffset < i.contentWidth
          ) {
            i.scrollbarXActive = true;
            i.railXWidth = i.containerWidth - i.railXMarginWidth;
            i.railXRatio = i.containerWidth / i.railXWidth;
            i.scrollbarXWidth = getThumbSize(
              i,
              h.toInt((i.railXWidth * i.containerWidth) / i.contentWidth)
            );
            i.scrollbarXLeft = h.toInt(
              ((i.negativeScrollAdjustment + element.scrollLeft) *
                (i.railXWidth - i.scrollbarXWidth)) /
                (i.contentWidth - i.containerWidth)
            );
          } else {
            i.scrollbarXActive = false;
          }

          if (
            !i.settings.suppressScrollY &&
            i.containerHeight + i.settings.scrollYMarginOffset < i.contentHeight
          ) {
            i.scrollbarYActive = true;
            i.railYHeight = i.containerHeight - i.railYMarginHeight;
            i.railYRatio = i.containerHeight / i.railYHeight;
            i.scrollbarYHeight = getThumbSize(
              i,
              h.toInt((i.railYHeight * i.containerHeight) / i.contentHeight)
            );
            i.scrollbarYTop = h.toInt(
              (element.scrollTop * (i.railYHeight - i.scrollbarYHeight)) /
                (i.contentHeight - i.containerHeight)
            );
          } else {
            i.scrollbarYActive = false;
          }

          if (i.scrollbarXLeft >= i.railXWidth - i.scrollbarXWidth) {
            i.scrollbarXLeft = i.railXWidth - i.scrollbarXWidth;
          }
          if (i.scrollbarYTop >= i.railYHeight - i.scrollbarYHeight) {
            i.scrollbarYTop = i.railYHeight - i.scrollbarYHeight;
          }

          updateCss(element, i);

          if (i.scrollbarXActive) {
            cls.add(element, "ps-active-x");
          } else {
            cls.remove(element, "ps-active-x");
            i.scrollbarXWidth = 0;
            i.scrollbarXLeft = 0;
            updateScroll(element, "left", 0);
          }
          if (i.scrollbarYActive) {
            cls.add(element, "ps-active-y");
          } else {
            cls.remove(element, "ps-active-y");
            i.scrollbarYHeight = 0;
            i.scrollbarYTop = 0;
            updateScroll(element, "top", 0);
          }
        };
      },
      {
        "../lib/class": 2,
        "../lib/dom": 3,
        "../lib/helper": 6,
        "./instances": 18,
        "./update-scroll": 20,
      },
    ],
    20: [
      function (require, module, exports) {
        "use strict";

        var instances = require("./instances");

        var upEvent = document.createEvent("Event"),
          downEvent = document.createEvent("Event"),
          leftEvent = document.createEvent("Event"),
          rightEvent = document.createEvent("Event"),
          yEvent = document.createEvent("Event"),
          xEvent = document.createEvent("Event"),
          xStartEvent = document.createEvent("Event"),
          xEndEvent = document.createEvent("Event"),
          yStartEvent = document.createEvent("Event"),
          yEndEvent = document.createEvent("Event"),
          lastTop,
          lastLeft;

        upEvent.initEvent("ps-scroll-up", true, true);
        downEvent.initEvent("ps-scroll-down", true, true);
        leftEvent.initEvent("ps-scroll-left", true, true);
        rightEvent.initEvent("ps-scroll-right", true, true);
        yEvent.initEvent("ps-scroll-y", true, true);
        xEvent.initEvent("ps-scroll-x", true, true);
        xStartEvent.initEvent("ps-x-reach-start", true, true);
        xEndEvent.initEvent("ps-x-reach-end", true, true);
        yStartEvent.initEvent("ps-y-reach-start", true, true);
        yEndEvent.initEvent("ps-y-reach-end", true, true);

        module.exports = function (element, axis, value) {
          if (typeof element === "undefined") {
            throw "You must provide an element to the update-scroll function";
          }

          if (typeof axis === "undefined") {
            throw "You must provide an axis to the update-scroll function";
          }

          if (typeof value === "undefined") {
            throw "You must provide a value to the update-scroll function";
          }

          if (axis === "top" && value <= 0) {
            element.scrollTop = value = 0; // don't allow negative scroll
            element.dispatchEvent(yStartEvent);
          }

          if (axis === "left" && value <= 0) {
            element.scrollLeft = value = 0; // don't allow negative scroll
            element.dispatchEvent(xStartEvent);
          }

          var i = instances.get(element);

          if (axis === "top" && value >= i.contentHeight - i.containerHeight) {
            element.scrollTop = value = i.contentHeight - i.containerHeight; // don't allow scroll past container
            element.dispatchEvent(yEndEvent);
          }

          if (axis === "left" && value >= i.contentWidth - i.containerWidth) {
            element.scrollLeft = value = i.contentWidth - i.containerWidth; // don't allow scroll past container
            element.dispatchEvent(xEndEvent);
          }

          if (!lastTop) {
            lastTop = element.scrollTop;
          }

          if (!lastLeft) {
            lastLeft = element.scrollLeft;
          }

          if (axis === "top" && value < lastTop) {
            element.dispatchEvent(upEvent);
          }

          if (axis === "top" && value > lastTop) {
            element.dispatchEvent(downEvent);
          }

          if (axis === "left" && value < lastLeft) {
            element.dispatchEvent(leftEvent);
          }

          if (axis === "left" && value > lastLeft) {
            element.dispatchEvent(rightEvent);
          }

          if (axis === "top") {
            element.scrollTop = lastTop = value;
            element.dispatchEvent(yEvent);
          }

          if (axis === "left") {
            element.scrollLeft = lastLeft = value;
            element.dispatchEvent(xEvent);
          }
        };
      },
      { "./instances": 18 },
    ],
    21: [
      function (require, module, exports) {
        "use strict";

        var d = require("../lib/dom"),
          h = require("../lib/helper"),
          instances = require("./instances"),
          updateGeometry = require("./update-geometry"),
          updateScroll = require("./update-scroll");

        module.exports = function (element) {
          var i = instances.get(element);

          if (!i) {
            return;
          }

          // Recalcuate negative scrollLeft adjustment
          i.negativeScrollAdjustment = i.isNegativeScroll
            ? element.scrollWidth - element.clientWidth
            : 0;

          // Recalculate rail margins
          d.css(i.scrollbarXRail, "display", "block");
          d.css(i.scrollbarYRail, "display", "block");
          i.railXMarginWidth =
            h.toInt(d.css(i.scrollbarXRail, "marginLeft")) +
            h.toInt(d.css(i.scrollbarXRail, "marginRight"));
          i.railYMarginHeight =
            h.toInt(d.css(i.scrollbarYRail, "marginTop")) +
            h.toInt(d.css(i.scrollbarYRail, "marginBottom"));

          // Hide scrollbars not to affect scrollWidth and scrollHeight
          d.css(i.scrollbarXRail, "display", "none");
          d.css(i.scrollbarYRail, "display", "none");

          updateGeometry(element);

          // Update top/left scroll to trigger events
          updateScroll(element, "top", element.scrollTop);
          updateScroll(element, "left", element.scrollLeft);

          d.css(i.scrollbarXRail, "display", "");
          d.css(i.scrollbarYRail, "display", "");
        };
      },
      {
        "../lib/dom": 3,
        "../lib/helper": 6,
        "./instances": 18,
        "./update-geometry": 19,
        "./update-scroll": 20,
      },
    ],
  },
  {},
  [1]
);