@alfalab/core-components 28.2.2-beta.0 → 28.2.2

package/scrollbar/modern/Component.js

@@ -1,17 +1,35 @@
 import React, { useRef, useEffect } from 'react';
 import cn from 'classnames';
 import mergeRefs from 'react-merge-refs';
+import 'core-js/modules/es.parse-int.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import throttle from 'lodash.throttle';
 import debounce from 'lodash.debounce';
 import memoize from 'lodash.memoize';
 import { ResizeObserver } from '@juggle/resize-observer';
 import canUseDOM from 'can-use-dom';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.function.name.js';
+import 'core-js/modules/es.string.replace.js';
 
-// Helper function to retrieve options from element attributes
+/**
+ * SimpleBar.js - v5.3.8
+ * Scrollbars, simpler.
+ * https://grsmto.github.io/simplebar/
+ *
+ * Made by Adrien Denat from a fork by Jonathan Nicol
+ * Under MIT License
+ */
 function getElementWindow(element) {
-    if (!element ||
-        !element.ownerDocument ||
-        !element.ownerDocument.defaultView) {
+    if (!element || !element.ownerDocument || !element.ownerDocument.defaultView) {
         return window;
     }
     return element.ownerDocument.defaultView;
@@ -22,11 +40,10 @@ function getElementDocument(element) {
     }
     return element.ownerDocument;
 }
-
-let cachedScrollbarWidth = null;
-let cachedDevicePixelRatio = null;
+var cachedScrollbarWidth = null;
+var cachedDevicePixelRatio = null;
 if (canUseDOM) {
-    window.addEventListener('resize', () => {
+    window.addEventListener('resize', function () {
         if (cachedDevicePixelRatio !== window.devicePixelRatio) {
             cachedDevicePixelRatio = window.devicePixelRatio;
             cachedScrollbarWidth = null;
@@ -35,208 +52,176 @@ if (canUseDOM) {
 }
 function scrollbarWidth(el) {
     if (cachedScrollbarWidth === null) {
-        const document = getElementDocument(el);
+        var document = getElementDocument(el);
         if (typeof document === 'undefined') {
             cachedScrollbarWidth = 0;
             return cachedScrollbarWidth;
         }
-        const body = document.body;
-        const box = document.createElement('div');
+        var body = document.body;
+        var box = document.createElement('div');
         box.classList.add('simplebar-hide-scrollbar');
         body.appendChild(box);
-        const width = box.getBoundingClientRect().right;
+        var width = box.getBoundingClientRect().right;
         body.removeChild(box);
         cachedScrollbarWidth = width;
     }
     return cachedScrollbarWidth;
 }
-
-class SimpleBar {
-    constructor(element, options) {
-        /**
-         * On scroll event handling
-         */
-        this.onScroll = () => {
-            const elWindow = getElementWindow(this.el);
-            if (!this.scrollXTicking) {
-                elWindow.requestAnimationFrame(this.scrollX);
-                this.scrollXTicking = true;
+var SimpleBar = /*#__PURE__*/ function () {
+    function SimpleBar(element, options) {
+        var _this = this;
+        this.onScroll = function () {
+            var elWindow = getElementWindow(_this.el);
+            if (!_this.scrollXTicking) {
+                elWindow.requestAnimationFrame(_this.scrollX);
+                _this.scrollXTicking = true;
             }
-            if (!this.scrollYTicking) {
-                elWindow.requestAnimationFrame(this.scrollY);
-                this.scrollYTicking = true;
+            if (!_this.scrollYTicking) {
+                elWindow.requestAnimationFrame(_this.scrollY);
+                _this.scrollYTicking = true;
             }
         };
-        this.scrollX = () => {
-            if (this.axis.x.isOverflowing) {
-                this.showScrollbar('x');
-                this.positionScrollbar('x');
+        this.scrollX = function () {
+            if (_this.axis.x.isOverflowing) {
+                _this.showScrollbar('x');
+                _this.positionScrollbar('x');
             }
-            this.scrollXTicking = false;
+            _this.scrollXTicking = false;
         };
-        this.scrollY = () => {
-            if (this.axis.y.isOverflowing) {
-                this.showScrollbar('y');
-                this.positionScrollbar('y');
+        this.scrollY = function () {
+            if (_this.axis.y.isOverflowing) {
+                _this.showScrollbar('y');
+                _this.positionScrollbar('y');
             }
-            this.scrollYTicking = false;
+            _this.scrollYTicking = false;
         };
-        this.onMouseEnter = () => {
-            this.showScrollbar('x');
-            this.showScrollbar('y');
+        this.onMouseEnter = function () {
+            _this.showScrollbar('x');
+            _this.showScrollbar('y');
         };
-        this.onMouseMove = e => {
-            this.mouseX = e.clientX;
-            this.mouseY = e.clientY;
-            if (this.axis.x.isOverflowing || this.axis.x.forceVisible) {
-                this.onMouseMoveForAxis('x');
+        this.onMouseMove = function (e) {
+            _this.mouseX = e.clientX;
+            _this.mouseY = e.clientY;
+            if (_this.axis.x.isOverflowing || _this.axis.x.forceVisible) {
+                _this.onMouseMoveForAxis('x');
             }
-            if (this.axis.y.isOverflowing || this.axis.y.forceVisible) {
-                this.onMouseMoveForAxis('y');
+            if (_this.axis.y.isOverflowing || _this.axis.y.forceVisible) {
+                _this.onMouseMoveForAxis('y');
             }
         };
-        this.onMouseLeave = () => {
-            this.onMouseMove.cancel();
-            if (this.axis.x.isOverflowing || this.axis.x.forceVisible) {
-                this.onMouseLeaveForAxis('x');
+        this.onMouseLeave = function () {
+            _this.onMouseMove.cancel();
+            if (_this.axis.x.isOverflowing || _this.axis.x.forceVisible) {
+                _this.onMouseLeaveForAxis('x');
             }
-            if (this.axis.y.isOverflowing || this.axis.y.forceVisible) {
-                this.onMouseLeaveForAxis('y');
+            if (_this.axis.y.isOverflowing || _this.axis.y.forceVisible) {
+                _this.onMouseLeaveForAxis('y');
             }
-            this.mouseX = -1;
-            this.mouseY = -1;
+            _this.mouseX = -1;
+            _this.mouseY = -1;
         };
-        this.onWindowResize = () => {
+        this.onWindowResize = function () {
             // Recalculate scrollbarWidth in case it's a zoom
-            this.scrollbarWidth = this.getScrollbarWidth();
-            this.hideNativeScrollbar();
+            _this.scrollbarWidth = _this.getScrollbarWidth();
+            _this.hideNativeScrollbar();
         };
-        /**
-         * Hide Scrollbar
-         */
-        this.hideScrollbars = () => {
-            this.axis.x.track.rect = this.axis.x.track.el.getBoundingClientRect();
-            this.axis.y.track.rect = this.axis.y.track.el.getBoundingClientRect();
-            if (!this.isWithinBounds(this.axis.y.track.rect)) {
-                this.axis.y.scrollbar.el.classList.remove(this.classNames.visible);
-                this.axis.y.isVisible = false;
+        this.hideScrollbars = function () {
+            _this.axis.x.track.rect = _this.axis.x.track.el.getBoundingClientRect();
+            _this.axis.y.track.rect = _this.axis.y.track.el.getBoundingClientRect();
+            if (!_this.isWithinBounds(_this.axis.y.track.rect)) {
+                _this.axis.y.scrollbar.el.classList.remove(_this.classNames.visible);
+                _this.axis.y.isVisible = false;
             }
-            if (!this.isWithinBounds(this.axis.x.track.rect)) {
-                this.axis.x.scrollbar.el.classList.remove(this.classNames.visible);
-                this.axis.x.isVisible = false;
+            if (!_this.isWithinBounds(_this.axis.x.track.rect)) {
+                _this.axis.x.scrollbar.el.classList.remove(_this.classNames.visible);
+                _this.axis.x.isVisible = false;
             }
         };
-        this.onPointerEvent = e => {
-            let isWithinTrackXBounds, isWithinTrackYBounds;
-            this.axis.x.track.rect = this.axis.x.track.el.getBoundingClientRect();
-            this.axis.y.track.rect = this.axis.y.track.el.getBoundingClientRect();
-            if (this.axis.x.isOverflowing || this.axis.x.forceVisible) {
-                isWithinTrackXBounds = this.isWithinBounds(this.axis.x.track.rect);
-            }
-            if (this.axis.y.isOverflowing || this.axis.y.forceVisible) {
-                isWithinTrackYBounds = this.isWithinBounds(this.axis.y.track.rect);
+        this.onPointerEvent = function (e) {
+            var isWithinTrackXBounds, isWithinTrackYBounds;
+            _this.axis.x.track.rect = _this.axis.x.track.el.getBoundingClientRect();
+            _this.axis.y.track.rect = _this.axis.y.track.el.getBoundingClientRect();
+            if (_this.axis.x.isOverflowing || _this.axis.x.forceVisible) {
+                isWithinTrackXBounds = _this.isWithinBounds(_this.axis.x.track.rect);
             }
-            // If any pointer event is called on the scrollbar
+            if (_this.axis.y.isOverflowing || _this.axis.y.forceVisible) {
+                isWithinTrackYBounds = _this.isWithinBounds(_this.axis.y.track.rect);
+            } // If any pointer event is called on the scrollbar
             if (isWithinTrackXBounds || isWithinTrackYBounds) {
                 // Preventing the event's default action stops text being
                 // selectable during the drag.
-                e.preventDefault();
-                // Prevent event leaking
+                e.preventDefault(); // Prevent event leaking
                 e.stopPropagation();
                 if (e.type === 'mousedown') {
                     if (isWithinTrackXBounds) {
-                        this.axis.x.scrollbar.rect = this.axis.x.scrollbar.el.getBoundingClientRect();
-                        if (this.isWithinBounds(this.axis.x.scrollbar.rect)) {
-                            this.onDragStart(e, 'x');
+                        _this.axis.x.scrollbar.rect = _this.axis.x.scrollbar.el.getBoundingClientRect();
+                        if (_this.isWithinBounds(_this.axis.x.scrollbar.rect)) {
+                            _this.onDragStart(e, 'x');
                         }
                         else {
-                            this.onTrackClick(e, 'x');
+                            _this.onTrackClick(e, 'x');
                         }
                     }
                     if (isWithinTrackYBounds) {
-                        this.axis.y.scrollbar.rect = this.axis.y.scrollbar.el.getBoundingClientRect();
-                        if (this.isWithinBounds(this.axis.y.scrollbar.rect)) {
-                            this.onDragStart(e, 'y');
+                        _this.axis.y.scrollbar.rect = _this.axis.y.scrollbar.el.getBoundingClientRect();
+                        if (_this.isWithinBounds(_this.axis.y.scrollbar.rect)) {
+                            _this.onDragStart(e, 'y');
                         }
                         else {
-                            this.onTrackClick(e, 'y');
+                            _this.onTrackClick(e, 'y');
                         }
                     }
                 }
             }
         };
-        /**
-         * Drag scrollbar handle
-         */
-        this.drag = e => {
-            let eventOffset;
-            const track = this.axis[this.draggedAxis].track;
-            const trackSize = track.rect[this.axis[this.draggedAxis].sizeAttr];
-            const scrollbar = this.axis[this.draggedAxis].scrollbar;
-            const contentSize = this.contentWrapperEl[this.axis[this.draggedAxis].scrollSizeAttr];
-            const hostSize = parseInt(this.elStyles[this.axis[this.draggedAxis].sizeAttr], 10);
+        this.drag = function (e) {
+            var eventOffset;
+            var track = _this.axis[_this.draggedAxis].track;
+            var trackSize = track.rect[_this.axis[_this.draggedAxis].sizeAttr];
+            var scrollbar = _this.axis[_this.draggedAxis].scrollbar;
+            var contentSize = _this.contentWrapperEl[_this.axis[_this.draggedAxis].scrollSizeAttr];
+            var hostSize = parseInt(_this.elStyles[_this.axis[_this.draggedAxis].sizeAttr], 10);
             e.preventDefault();
             e.stopPropagation();
-            if (this.draggedAxis === 'y') {
+            if (_this.draggedAxis === 'y') {
                 eventOffset = e.pageY;
             }
             else {
                 eventOffset = e.pageX;
+            } // Calculate how far the user's mouse is from the top/left of the scrollbar (minus the dragOffset).
+            var dragPos = eventOffset - track.rect[_this.axis[_this.draggedAxis].offsetAttr] - _this.axis[_this.draggedAxis].dragOffset; // Convert the mouse position into a percentage of the scrollbar height/width.
+            var dragPerc = dragPos / (trackSize - scrollbar.size); // Scroll the content by the same percentage.
+            var scrollPos = dragPerc * (contentSize - hostSize); // Fix browsers inconsistency on RTL
+            if (_this.draggedAxis === 'x') {
+                scrollPos = _this.isRtl && SimpleBar.getRtlHelpers().isRtlScrollbarInverted ? scrollPos - (trackSize + scrollbar.size) : scrollPos;
+                scrollPos = _this.isRtl && SimpleBar.getRtlHelpers().isRtlScrollingInverted ? -scrollPos : scrollPos;
             }
-            // Calculate how far the user's mouse is from the top/left of the scrollbar (minus the dragOffset).
-            let dragPos = eventOffset -
-                track.rect[this.axis[this.draggedAxis].offsetAttr] -
-                this.axis[this.draggedAxis].dragOffset;
-            // Convert the mouse position into a percentage of the scrollbar height/width.
-            let dragPerc = dragPos / (trackSize - scrollbar.size);
-            // Scroll the content by the same percentage.
-            let scrollPos = dragPerc * (contentSize - hostSize);
-            // Fix browsers inconsistency on RTL
-            if (this.draggedAxis === 'x') {
-                scrollPos =
-                    this.isRtl && SimpleBar.getRtlHelpers().isRtlScrollbarInverted
-                        ? scrollPos - (trackSize + scrollbar.size)
-                        : scrollPos;
-                scrollPos =
-                    this.isRtl && SimpleBar.getRtlHelpers().isRtlScrollingInverted
-                        ? -scrollPos
-                        : scrollPos;
-            }
-            this.contentWrapperEl[this.axis[this.draggedAxis].scrollOffsetAttr] = scrollPos;
+            _this.contentWrapperEl[_this.axis[_this.draggedAxis].scrollOffsetAttr] = scrollPos;
         };
-        /**
-         * End scroll handle drag
-         */
-        this.onEndDrag = e => {
-            const elDocument = getElementDocument(this.el);
-            const elWindow = getElementWindow(this.el);
+        this.onEndDrag = function (e) {
+            var elDocument = getElementDocument(_this.el);
+            var elWindow = getElementWindow(_this.el);
             e.preventDefault();
             e.stopPropagation();
-            this.el.classList.remove(this.classNames.dragging);
-            elDocument.removeEventListener('mousemove', this.drag, true);
-            elDocument.removeEventListener('mouseup', this.onEndDrag, true);
-            this.removePreventClickId = elWindow.setTimeout(() => {
+            _this.el.classList.remove(_this.classNames.dragging);
+            elDocument.removeEventListener('mousemove', _this.drag, true);
+            elDocument.removeEventListener('mouseup', _this.onEndDrag, true);
+            _this.removePreventClickId = elWindow.setTimeout(function () {
                 // Remove these asynchronously so we still suppress click events
                 // generated simultaneously with mouseup.
-                elDocument.removeEventListener('click', this.preventClick, true);
-                elDocument.removeEventListener('dblclick', this.preventClick, true);
-                this.removePreventClickId = null;
+                elDocument.removeEventListener('click', _this.preventClick, true);
+                elDocument.removeEventListener('dblclick', _this.preventClick, true);
+                _this.removePreventClickId = null;
             });
         };
-        /**
-         * Handler to ignore click events during drag
-         */
-        this.preventClick = e => {
+        this.preventClick = function (e) {
             e.preventDefault();
             e.stopPropagation();
         };
         this.el = element;
         this.minScrollbarWidth = 20;
-        this.options = { ...SimpleBar.defaultOptions, ...options };
-        this.classNames = {
-            ...SimpleBar.defaultOptions.classNames,
-            ...this.options.classNames
-        };
+        this.options = Object.assign({}, SimpleBar.defaultOptions, options);
+        this.classNames = Object.assign({}, SimpleBar.defaultOptions.classNames, this.options.classNames);
         this.axis = {
             x: {
                 scrollOffsetAttr: 'scrollLeft',
@@ -267,8 +252,7 @@ class SimpleBar {
                 scrollbar: {}
             }
         };
-        this.removePreventClickId = null;
-        // Don't re-instantiate over an existing one
+        this.removePreventClickId = null; // Don't re-instantiate over an existing one
         if (SimpleBar.instances.has(this.el)) {
             return;
         }
@@ -290,43 +274,37 @@ class SimpleBar {
      *  - IE11 inverts both scrollbar position and scrolling offset
      * Directly inspired by @KingSora's OverlayScrollbars https://github.com/KingSora/OverlayScrollbars/blob/master/js/OverlayScrollbars.js#L1634
      */
-    static getRtlHelpers() {
-        const dummyDiv = document.createElement('div');
-        dummyDiv.innerHTML =
-            '<div class="hs-dummy-scrollbar-size"><div style="height: 200%; width: 200%; margin: 10px 0;"></div></div>';
-        const scrollbarDummyEl = dummyDiv.firstElementChild;
+    SimpleBar.getRtlHelpers = function getRtlHelpers() {
+        var dummyDiv = document.createElement('div');
+        dummyDiv.innerHTML = '<div class="hs-dummy-scrollbar-size"><div style="height: 200%; width: 200%; margin: 10px 0;"></div></div>';
+        var scrollbarDummyEl = dummyDiv.firstElementChild;
         document.body.appendChild(scrollbarDummyEl);
-        const dummyContainerChild = scrollbarDummyEl.firstElementChild;
+        var dummyContainerChild = scrollbarDummyEl.firstElementChild;
         scrollbarDummyEl.scrollLeft = 0;
-        const dummyContainerOffset = SimpleBar.getOffset(scrollbarDummyEl);
-        const dummyContainerChildOffset = SimpleBar.getOffset(dummyContainerChild);
+        var dummyContainerOffset = SimpleBar.getOffset(scrollbarDummyEl);
+        var dummyContainerChildOffset = SimpleBar.getOffset(dummyContainerChild);
         scrollbarDummyEl.scrollLeft = 999;
-        const dummyContainerScrollOffsetAfterScroll = SimpleBar.getOffset(dummyContainerChild);
+        var dummyContainerScrollOffsetAfterScroll = SimpleBar.getOffset(dummyContainerChild);
         return {
             // determines if the scrolling is responding with negative values
-            isRtlScrollingInverted: dummyContainerOffset.left !== dummyContainerChildOffset.left &&
-                dummyContainerChildOffset.left -
-                    dummyContainerScrollOffsetAfterScroll.left !==
-                    0,
+            isRtlScrollingInverted: dummyContainerOffset.left !== dummyContainerChildOffset.left && dummyContainerChildOffset.left - dummyContainerScrollOffsetAfterScroll.left !== 0,
             // determines if the origin scrollbar position is inverted or not (positioned on left or right)
             isRtlScrollbarInverted: dummyContainerOffset.left !== dummyContainerChildOffset.left
         };
-    }
-    static getOffset(el) {
-        const rect = el.getBoundingClientRect();
-        const elDocument = getElementDocument(el);
-        const elWindow = getElementWindow(el);
+    };
+    SimpleBar.getOffset = function getOffset(el) {
+        var rect = el.getBoundingClientRect();
+        var elDocument = getElementDocument(el);
+        var elWindow = getElementWindow(el);
         return {
-            top: rect.top +
-                (elWindow.pageYOffset || elDocument.documentElement.scrollTop),
-            left: rect.left +
-                (elWindow.pageXOffset || elDocument.documentElement.scrollLeft)
+            top: rect.top + (elWindow.pageYOffset || elDocument.documentElement.scrollTop),
+            left: rect.left + (elWindow.pageXOffset || elDocument.documentElement.scrollLeft)
         };
-    }
-    init() {
+    };
+    var _proto = SimpleBar.prototype;
+    _proto.init = function init() {
         // Save a reference to the instance, so we know this DOM node has already been instancied
-        SimpleBar.instances.set(this.el, this);
-        // We stop here on server-side
+        SimpleBar.instances.set(this.el, this); // We stop here on server-side
         if (canUseDOM) {
             this.initDOM();
             this.setAccessibilityAttributes();
@@ -334,25 +312,24 @@ class SimpleBar {
             this.recalculate();
             this.initListeners();
         }
-    }
-    initDOM() {
+    };
+    _proto.initDOM = function initDOM() {
+        var _this2 = this;
         // make sure this element doesn't have the elements yet
-        if (Array.prototype.filter.call(this.el.children, child => child.classList.contains(this.classNames.wrapper)).length) {
+        if (Array.prototype.filter.call(this.el.children, function (child) {
+            return child.classList.contains(_this2.classNames.wrapper);
+        }).length) {
             // assume that element has his DOM already initiated
-            this.wrapperEl = this.el.querySelector(`.${this.classNames.wrapper}`);
-            this.contentWrapperEl =
-                this.options.scrollableNode ||
-                    this.el.querySelector(`.${this.classNames.contentWrapper}`);
-            this.contentEl =
-                this.options.contentNode ||
-                    this.el.querySelector(`.${this.classNames.contentEl}`);
-            this.offsetEl = this.el.querySelector(`.${this.classNames.offset}`);
-            this.maskEl = this.el.querySelector(`.${this.classNames.mask}`);
-            this.placeholderEl = this.findChild(this.wrapperEl, `.${this.classNames.placeholder}`);
-            this.heightAutoObserverWrapperEl = this.el.querySelector(`.${this.classNames.heightAutoObserverWrapperEl}`);
-            this.heightAutoObserverEl = this.el.querySelector(`.${this.classNames.heightAutoObserverEl}`);
-            this.axis.x.track.el = this.findChild(this.el, `.${this.classNames.track}.${this.classNames.horizontal}`);
-            this.axis.y.track.el = this.findChild(this.el, `.${this.classNames.track}.${this.classNames.vertical}`);
+            this.wrapperEl = this.el.querySelector("." + this.classNames.wrapper);
+            this.contentWrapperEl = this.options.scrollableNode || this.el.querySelector("." + this.classNames.contentWrapper);
+            this.contentEl = this.options.contentNode || this.el.querySelector("." + this.classNames.contentEl);
+            this.offsetEl = this.el.querySelector("." + this.classNames.offset);
+            this.maskEl = this.el.querySelector("." + this.classNames.mask);
+            this.placeholderEl = this.findChild(this.wrapperEl, "." + this.classNames.placeholder);
+            this.heightAutoObserverWrapperEl = this.el.querySelector("." + this.classNames.heightAutoObserverWrapperEl);
+            this.heightAutoObserverEl = this.el.querySelector("." + this.classNames.heightAutoObserverEl);
+            this.axis.x.track.el = this.findChild(this.el, "." + this.classNames.track + "." + this.classNames.horizontal);
+            this.axis.y.track.el = this.findChild(this.el, "." + this.classNames.track + "." + this.classNames.vertical);
         }
         else {
             // Prepare DOM
@@ -385,8 +362,8 @@ class SimpleBar {
             this.el.appendChild(this.wrapperEl);
         }
         if (!this.axis.x.track.el || !this.axis.y.track.el) {
-            const track = document.createElement('div');
-            const scrollbar = document.createElement('div');
+            var track = document.createElement('div');
+            var scrollbar = document.createElement('div');
             track.classList.add(this.classNames.track);
             scrollbar.classList.add(this.classNames.scrollbar);
             track.appendChild(scrollbar);
@@ -397,167 +374,137 @@ class SimpleBar {
             this.el.appendChild(this.axis.x.track.el);
             this.el.appendChild(this.axis.y.track.el);
         }
-        this.axis.x.scrollbar.el = this.axis.x.track.el.querySelector(`.${this.classNames.scrollbar}`);
-        this.axis.y.scrollbar.el = this.axis.y.track.el.querySelector(`.${this.classNames.scrollbar}`);
+        this.axis.x.scrollbar.el = this.axis.x.track.el.querySelector("." + this.classNames.scrollbar);
+        this.axis.y.scrollbar.el = this.axis.y.track.el.querySelector("." + this.classNames.scrollbar);
         if (!this.options.autoHide) {
             this.axis.x.scrollbar.el.classList.add(this.classNames.visible);
             this.axis.y.scrollbar.el.classList.add(this.classNames.visible);
         }
         this.el.setAttribute('data-simplebar', 'init');
-    }
-    setAccessibilityAttributes() {
-        const ariaLabel = this.options.ariaLabel || 'scrollable content';
+    };
+    _proto.setAccessibilityAttributes = function setAccessibilityAttributes() {
+        var ariaLabel = this.options.ariaLabel || 'scrollable content';
         this.contentWrapperEl.setAttribute('tabindex', '0');
         this.contentWrapperEl.setAttribute('role', 'region');
         this.contentWrapperEl.setAttribute('aria-label', ariaLabel);
-    }
-    initListeners() {
-        const elWindow = getElementWindow(this.el);
-        // Event listeners
+    };
+    _proto.initListeners = function initListeners() {
+        var _this3 = this;
+        var elWindow = getElementWindow(this.el); // Event listeners
         if (this.options.autoHide) {
             this.el.addEventListener('mouseenter', this.onMouseEnter);
         }
-        ['mousedown', 'click', 'dblclick'].forEach(e => {
-            this.el.addEventListener(e, this.onPointerEvent, true);
+        ['mousedown', 'click', 'dblclick'].forEach(function (e) {
+            _this3.el.addEventListener(e, _this3.onPointerEvent, true);
         });
-        ['touchstart', 'touchend', 'touchmove'].forEach(e => {
-            this.el.addEventListener(e, this.onPointerEvent, {
+        ['touchstart', 'touchend', 'touchmove'].forEach(function (e) {
+            _this3.el.addEventListener(e, _this3.onPointerEvent, {
                 capture: true,
                 passive: true
             });
         });
         this.el.addEventListener('mousemove', this.onMouseMove);
         this.el.addEventListener('mouseleave', this.onMouseLeave);
-        this.contentWrapperEl.addEventListener('scroll', this.onScroll);
-        // Browser zoom triggers a window resize
-        elWindow.addEventListener('resize', this.onWindowResize);
-        // Hack for https://github.com/WICG/ResizeObserver/issues/38
-        let resizeObserverStarted = false;
-        const resizeObserver = elWindow.ResizeObserver || ResizeObserver;
-        this.resizeObserver = new resizeObserver(() => {
+        this.contentWrapperEl.addEventListener('scroll', this.onScroll); // Browser zoom triggers a window resize
+        elWindow.addEventListener('resize', this.onWindowResize); // Hack for https://github.com/WICG/ResizeObserver/issues/38
+        var resizeObserverStarted = false;
+        var resizeObserver = elWindow.ResizeObserver || ResizeObserver;
+        this.resizeObserver = new resizeObserver(function () {
             if (!resizeObserverStarted)
                 return;
-            this.recalculate();
+            _this3.recalculate();
         });
         this.resizeObserver.observe(this.el);
         this.resizeObserver.observe(this.contentEl);
-        elWindow.requestAnimationFrame(() => {
+        elWindow.requestAnimationFrame(function () {
             resizeObserverStarted = true;
-        });
-        // This is required to detect horizontal scroll. Vertical scroll only needs the resizeObserver.
+        }); // This is required to detect horizontal scroll. Vertical scroll only needs the resizeObserver.
         this.mutationObserver = new elWindow.MutationObserver(this.recalculate);
         this.mutationObserver.observe(this.contentEl, {
             childList: true,
             subtree: true,
             characterData: true
         });
-    }
-    recalculate() {
-        const elWindow = getElementWindow(this.el);
+    };
+    _proto.recalculate = function recalculate() {
+        var elWindow = getElementWindow(this.el);
         this.elStyles = elWindow.getComputedStyle(this.el);
         this.isRtl = this.elStyles.direction === 'rtl';
-        const isHeightAuto = this.heightAutoObserverEl.offsetHeight <= 1;
-        const isWidthAuto = this.heightAutoObserverEl.offsetWidth <= 1;
-        const contentElOffsetWidth = this.contentEl.offsetWidth;
-        const contentWrapperElOffsetWidth = this.contentWrapperEl.offsetWidth;
-        const elOverflowX = this.elStyles.overflowX;
-        const elOverflowY = this.elStyles.overflowY;
-        this.contentEl.style.padding = `${this.elStyles.paddingTop} ${this.elStyles.paddingRight} ${this.elStyles.paddingBottom} ${this.elStyles.paddingLeft}`;
-        this.wrapperEl.style.margin = `-${this.elStyles.paddingTop} -${this.elStyles.paddingRight} -${this.elStyles.paddingBottom} -${this.elStyles.paddingLeft}`;
-        const contentElScrollHeight = this.contentEl.scrollHeight;
-        const contentElScrollWidth = this.contentEl.scrollWidth;
-        this.contentWrapperEl.style.height = isHeightAuto ? 'auto' : '100%';
-        // Determine placeholder size
-        this.placeholderEl.style.width = isWidthAuto
-            ? `${contentElOffsetWidth}px`
-            : 'auto';
-        this.placeholderEl.style.height = `${contentElScrollHeight}px`;
-        const contentWrapperElOffsetHeight = this.contentWrapperEl.offsetHeight;
+        var isHeightAuto = this.heightAutoObserverEl.offsetHeight <= 1;
+        var isWidthAuto = this.heightAutoObserverEl.offsetWidth <= 1;
+        var contentElOffsetWidth = this.contentEl.offsetWidth;
+        var contentWrapperElOffsetWidth = this.contentWrapperEl.offsetWidth;
+        var elOverflowX = this.elStyles.overflowX;
+        var elOverflowY = this.elStyles.overflowY;
+        this.contentEl.style.padding = this.elStyles.paddingTop + " " + this.elStyles.paddingRight + " " + this.elStyles.paddingBottom + " " + this.elStyles.paddingLeft;
+        this.wrapperEl.style.margin = "-" + this.elStyles.paddingTop + " -" + this.elStyles.paddingRight + " -" + this.elStyles.paddingBottom + " -" + this.elStyles.paddingLeft;
+        var contentElScrollHeight = this.contentEl.scrollHeight;
+        var contentElScrollWidth = this.contentEl.scrollWidth;
+        this.contentWrapperEl.style.height = isHeightAuto ? 'auto' : '100%'; // Determine placeholder size
+        this.placeholderEl.style.width = isWidthAuto ? contentElOffsetWidth + "px" : 'auto';
+        this.placeholderEl.style.height = contentElScrollHeight + "px";
+        var contentWrapperElOffsetHeight = this.contentWrapperEl.offsetHeight;
         this.axis.x.isOverflowing = contentElScrollWidth > contentElOffsetWidth;
-        this.axis.y.isOverflowing =
-            contentElScrollHeight > contentWrapperElOffsetHeight;
-        // Set isOverflowing to false if user explicitely set hidden overflow
-        this.axis.x.isOverflowing =
-            elOverflowX === 'hidden' ? false : this.axis.x.isOverflowing;
-        this.axis.y.isOverflowing =
-            elOverflowY === 'hidden' ? false : this.axis.y.isOverflowing;
-        this.axis.x.forceVisible =
-            this.options.forceVisible === 'x' || this.options.forceVisible === true;
-        this.axis.y.forceVisible =
-            this.options.forceVisible === 'y' || this.options.forceVisible === true;
-        this.hideNativeScrollbar();
-        // Set isOverflowing to false if scrollbar is not necessary (content is shorter than offset)
-        let offsetForXScrollbar = this.axis.x.isOverflowing
-            ? this.scrollbarWidth
-            : 0;
-        let offsetForYScrollbar = this.axis.y.isOverflowing
-            ? this.scrollbarWidth
-            : 0;
-        this.axis.x.isOverflowing =
-            this.axis.x.isOverflowing &&
-                contentElScrollWidth > contentWrapperElOffsetWidth - offsetForYScrollbar;
-        this.axis.y.isOverflowing =
-            this.axis.y.isOverflowing &&
-                contentElScrollHeight >
-                    contentWrapperElOffsetHeight - offsetForXScrollbar;
+        this.axis.y.isOverflowing = contentElScrollHeight > contentWrapperElOffsetHeight; // Set isOverflowing to false if user explicitely set hidden overflow
+        this.axis.x.isOverflowing = elOverflowX === 'hidden' ? false : this.axis.x.isOverflowing;
+        this.axis.y.isOverflowing = elOverflowY === 'hidden' ? false : this.axis.y.isOverflowing;
+        this.axis.x.forceVisible = this.options.forceVisible === 'x' || this.options.forceVisible === true;
+        this.axis.y.forceVisible = this.options.forceVisible === 'y' || this.options.forceVisible === true;
+        this.hideNativeScrollbar(); // Set isOverflowing to false if scrollbar is not necessary (content is shorter than offset)
+        var offsetForXScrollbar = this.axis.x.isOverflowing ? this.scrollbarWidth : 0;
+        var offsetForYScrollbar = this.axis.y.isOverflowing ? this.scrollbarWidth : 0;
+        this.axis.x.isOverflowing = this.axis.x.isOverflowing && contentElScrollWidth > contentWrapperElOffsetWidth - offsetForYScrollbar;
+        this.axis.y.isOverflowing = this.axis.y.isOverflowing && contentElScrollHeight > contentWrapperElOffsetHeight - offsetForXScrollbar;
         this.axis.x.scrollbar.size = this.getScrollbarSize('x');
         this.axis.y.scrollbar.size = this.getScrollbarSize('y');
-        this.axis.x.scrollbar.el.style.width = `${this.axis.x.scrollbar.size}px`;
-        this.axis.y.scrollbar.el.style.height = `${this.axis.y.scrollbar.size}px`;
+        this.axis.x.scrollbar.el.style.width = this.axis.x.scrollbar.size + "px";
+        this.axis.y.scrollbar.el.style.height = this.axis.y.scrollbar.size + "px";
         this.positionScrollbar('x');
         this.positionScrollbar('y');
         this.toggleTrackVisibility('x');
         this.toggleTrackVisibility('y');
-    }
-    /**
-     * Calculate scrollbar size
-     */
-    getScrollbarSize(axis = 'y') {
+    };
+    _proto.getScrollbarSize = function getScrollbarSize(axis) {
+        if (axis === void 0) {
+            axis = 'y';
+        }
         if (!this.axis[axis].isOverflowing) {
             return 0;
         }
-        const contentSize = this.contentEl[this.axis[axis].scrollSizeAttr];
-        const trackSize = this.axis[axis].track.el[this.axis[axis].offsetSizeAttr];
-        let scrollbarSize;
-        let scrollbarRatio = trackSize / contentSize;
-        // Calculate new height/position of drag handle.
+        var contentSize = this.contentEl[this.axis[axis].scrollSizeAttr];
+        var trackSize = this.axis[axis].track.el[this.axis[axis].offsetSizeAttr];
+        var scrollbarSize;
+        var scrollbarRatio = trackSize / contentSize; // Calculate new height/position of drag handle.
         scrollbarSize = Math.max(~~(scrollbarRatio * trackSize), this.options.scrollbarMinSize);
         if (this.options.scrollbarMaxSize) {
             scrollbarSize = Math.min(scrollbarSize, this.options.scrollbarMaxSize);
         }
         return scrollbarSize;
-    }
-    positionScrollbar(axis = 'y') {
+    };
+    _proto.positionScrollbar = function positionScrollbar(axis) {
+        if (axis === void 0) {
+            axis = 'y';
+        }
         if (!this.axis[axis].isOverflowing) {
             return;
         }
-        const contentSize = this.contentWrapperEl[this.axis[axis].scrollSizeAttr];
-        const trackSize = this.axis[axis].track.el[this.axis[axis].offsetSizeAttr];
-        const hostSize = parseInt(this.elStyles[this.axis[axis].sizeAttr], 10);
-        const scrollbar = this.axis[axis].scrollbar;
-        let scrollOffset = this.contentWrapperEl[this.axis[axis].scrollOffsetAttr];
-        scrollOffset =
-            axis === 'x' &&
-                this.isRtl &&
-                SimpleBar.getRtlHelpers().isRtlScrollingInverted
-                ? -scrollOffset
-                : scrollOffset;
-        let scrollPourcent = scrollOffset / (contentSize - hostSize);
-        let handleOffset = ~~((trackSize - scrollbar.size) * scrollPourcent);
-        handleOffset =
-            axis === 'x' &&
-                this.isRtl &&
-                SimpleBar.getRtlHelpers().isRtlScrollbarInverted
-                ? handleOffset + (trackSize - scrollbar.size)
-                : handleOffset;
-        scrollbar.el.style.transform =
-            axis === 'x'
-                ? `translate3d(${handleOffset}px, 0, 0)`
-                : `translate3d(0, ${handleOffset}px, 0)`;
-    }
-    toggleTrackVisibility(axis = 'y') {
-        const track = this.axis[axis].track.el;
-        const scrollbar = this.axis[axis].scrollbar.el;
+        var contentSize = this.contentWrapperEl[this.axis[axis].scrollSizeAttr];
+        var trackSize = this.axis[axis].track.el[this.axis[axis].offsetSizeAttr];
+        var hostSize = parseInt(this.elStyles[this.axis[axis].sizeAttr], 10);
+        var scrollbar = this.axis[axis].scrollbar;
+        var scrollOffset = this.contentWrapperEl[this.axis[axis].scrollOffsetAttr];
+        scrollOffset = axis === 'x' && this.isRtl && SimpleBar.getRtlHelpers().isRtlScrollingInverted ? -scrollOffset : scrollOffset;
+        var scrollPourcent = scrollOffset / (contentSize - hostSize);
+        var handleOffset = ~~((trackSize - scrollbar.size) * scrollPourcent);
+        handleOffset = axis === 'x' && this.isRtl && SimpleBar.getRtlHelpers().isRtlScrollbarInverted ? handleOffset + (trackSize - scrollbar.size) : handleOffset;
+        scrollbar.el.style.transform = axis === 'x' ? "translate3d(" + handleOffset + "px, 0, 0)" : "translate3d(0, " + handleOffset + "px, 0)";
+    };
+    _proto.toggleTrackVisibility = function toggleTrackVisibility(axis) {
+        if (axis === void 0) {
+            axis = 'y';
+        }
+        var track = this.axis[axis].track.el;
+        var scrollbar = this.axis[axis].scrollbar.el;
         if (this.axis[axis].isOverflowing || this.axis[axis].forceVisible) {
             track.style.visibility = 'visible';
             this.contentWrapperEl.style[this.axis[axis].overflowAttr] = 'scroll';
@@ -565,29 +512,25 @@ class SimpleBar {
         else {
             track.style.visibility = 'hidden';
             this.contentWrapperEl.style[this.axis[axis].overflowAttr] = 'hidden';
-        }
-        // Even if forceVisible is enabled, scrollbar itself should be hidden
+        } // Even if forceVisible is enabled, scrollbar itself should be hidden
         if (this.axis[axis].isOverflowing) {
             scrollbar.style.display = 'block';
         }
         else {
             scrollbar.style.display = 'none';
         }
-    }
-    hideNativeScrollbar() {
-        this.offsetEl.style[this.isRtl ? 'left' : 'right'] =
-            this.axis.y.isOverflowing || this.axis.y.forceVisible
-                ? `-${this.scrollbarWidth}px`
-                : 0;
-        this.offsetEl.style.bottom =
-            this.axis.x.isOverflowing || this.axis.x.forceVisible
-                ? `-${this.scrollbarWidth}px`
-                : 0;
-    }
-    onMouseMoveForAxis(axis = 'y') {
+    };
+    _proto.hideNativeScrollbar = function hideNativeScrollbar() {
+        this.offsetEl.style[this.isRtl ? 'left' : 'right'] = this.axis.y.isOverflowing || this.axis.y.forceVisible ? "-" + this.scrollbarWidth + "px" : 0;
+        this.offsetEl.style.bottom = this.axis.x.isOverflowing || this.axis.x.forceVisible ? "-" + this.scrollbarWidth + "px" : 0;
+    };
+    _proto.onMouseMoveForAxis = function onMouseMoveForAxis(axis) {
+        if (axis === void 0) {
+            axis = 'y';
+        }
         this.axis[axis].track.rect = this.axis[axis].track.el.getBoundingClientRect();
         this.axis[axis].scrollbar.rect = this.axis[axis].scrollbar.el.getBoundingClientRect();
-        const isWithinScrollbarBoundsX = this.isWithinBounds(this.axis[axis].scrollbar.rect);
+        var isWithinScrollbarBoundsX = this.isWithinBounds(this.axis[axis].scrollbar.rect);
         if (isWithinScrollbarBoundsX) {
             this.axis[axis].scrollbar.el.classList.add(this.classNames.hover);
         }
@@ -601,16 +544,22 @@ class SimpleBar {
         else {
             this.axis[axis].track.el.classList.remove(this.classNames.hover);
         }
-    }
-    onMouseLeaveForAxis(axis = 'y') {
+    };
+    _proto.onMouseLeaveForAxis = function onMouseLeaveForAxis(axis) {
+        if (axis === void 0) {
+            axis = 'y';
+        }
         this.axis[axis].track.el.classList.remove(this.classNames.hover);
         this.axis[axis].scrollbar.el.classList.remove(this.classNames.hover);
-    }
+    };
     /**
      * Show scrollbar
      */
-    showScrollbar(axis = 'y') {
-        let scrollbar = this.axis[axis].scrollbar.el;
+    _proto.showScrollbar = function showScrollbar(axis) {
+        if (axis === void 0) {
+            axis = 'y';
+        }
+        var scrollbar = this.axis[axis].scrollbar.el;
         if (!this.axis[axis].isVisible) {
             scrollbar.classList.add(this.classNames.visible);
             this.axis[axis].isVisible = true;
@@ -618,18 +567,19 @@ class SimpleBar {
         if (this.options.autoHide) {
             this.hideScrollbars();
         }
-    }
+    };
     /**
      * on scrollbar handle drag movement starts
      */
-    onDragStart(e, axis = 'y') {
-        const elDocument = getElementDocument(this.el);
-        const elWindow = getElementWindow(this.el);
-        const scrollbar = this.axis[axis].scrollbar;
-        // Measure how far the user's mouse is from the top of the scrollbar drag handle.
-        const eventOffset = axis === 'y' ? e.pageY : e.pageX;
-        this.axis[axis].dragOffset =
-            eventOffset - scrollbar.rect[this.axis[axis].offsetAttr];
+    _proto.onDragStart = function onDragStart(e, axis) {
+        if (axis === void 0) {
+            axis = 'y';
+        }
+        var elDocument = getElementDocument(this.el);
+        var elWindow = getElementWindow(this.el);
+        var scrollbar = this.axis[axis].scrollbar; // Measure how far the user's mouse is from the top of the scrollbar drag handle.
+        var eventOffset = axis === 'y' ? e.pageY : e.pageX;
+        this.axis[axis].dragOffset = eventOffset - scrollbar.rect[this.axis[axis].offsetAttr];
         this.draggedAxis = axis;
         this.el.classList.add(this.classNames.dragging);
         elDocument.addEventListener('mousemove', this.drag, true);
@@ -642,63 +592,54 @@ class SimpleBar {
             elWindow.clearTimeout(this.removePreventClickId);
             this.removePreventClickId = null;
         }
-    }
-    onTrackClick(e, axis = 'y') {
+    };
+    _proto.onTrackClick = function onTrackClick(e, axis) {
+        var _this4 = this;
+        if (axis === void 0) {
+            axis = 'y';
+        }
         if (!this.options.clickOnTrack)
             return;
-        const elWindow = getElementWindow(this.el);
+        var elWindow = getElementWindow(this.el);
         this.axis[axis].scrollbar.rect = this.axis[axis].scrollbar.el.getBoundingClientRect();
-        const scrollbar = this.axis[axis].scrollbar;
-        const scrollbarOffset = scrollbar.rect[this.axis[axis].offsetAttr];
-        const hostSize = parseInt(this.elStyles[this.axis[axis].sizeAttr], 10);
-        let scrolled = this.contentWrapperEl[this.axis[axis].scrollOffsetAttr];
-        const t = axis === 'y'
-            ? this.mouseY - scrollbarOffset
-            : this.mouseX - scrollbarOffset;
-        const dir = t < 0 ? -1 : 1;
-        const scrollSize = dir === -1 ? scrolled - hostSize : scrolled + hostSize;
-        const scrollTo = () => {
+        var scrollbar = this.axis[axis].scrollbar;
+        var scrollbarOffset = scrollbar.rect[this.axis[axis].offsetAttr];
+        var hostSize = parseInt(this.elStyles[this.axis[axis].sizeAttr], 10);
+        var scrolled = this.contentWrapperEl[this.axis[axis].scrollOffsetAttr];
+        var t = axis === 'y' ? this.mouseY - scrollbarOffset : this.mouseX - scrollbarOffset;
+        var dir = t < 0 ? -1 : 1;
+        var scrollSize = dir === -1 ? scrolled - hostSize : scrolled + hostSize;
+        var scrollTo = function scrollTo() {
             if (dir === -1) {
                 if (scrolled > scrollSize) {
-                    scrolled -= this.options.clickOnTrackSpeed;
-                    this.contentWrapperEl.scrollTo({
-                        [this.axis[axis].offsetAttr]: scrolled
-                    });
+                    var _this4$contentWrapper;
+                    scrolled -= _this4.options.clickOnTrackSpeed;
+                    _this4.contentWrapperEl.scrollTo((_this4$contentWrapper = {}, _this4$contentWrapper[_this4.axis[axis].offsetAttr] = scrolled, _this4$contentWrapper));
                     elWindow.requestAnimationFrame(scrollTo);
                 }
             }
             else {
                 if (scrolled < scrollSize) {
-                    scrolled += this.options.clickOnTrackSpeed;
-                    this.contentWrapperEl.scrollTo({
-                        [this.axis[axis].offsetAttr]: scrolled
-                    });
+                    var _this4$contentWrapper2;
+                    scrolled += _this4.options.clickOnTrackSpeed;
+                    _this4.contentWrapperEl.scrollTo((_this4$contentWrapper2 = {}, _this4$contentWrapper2[_this4.axis[axis].offsetAttr] = scrolled, _this4$contentWrapper2));
                     elWindow.requestAnimationFrame(scrollTo);
                 }
             }
         };
         scrollTo();
-    }
-    /**
-     * Getter for content element
-     */
-    getContentElement() {
+    };
+    _proto.getContentElement = function getContentElement() {
         return this.contentEl;
-    }
-    /**
-     * Getter for original scrolling element
-     */
-    getScrollElement() {
+    };
+    _proto.getScrollElement = function getScrollElement() {
         return this.contentWrapperEl;
-    }
-    getScrollbarWidth() {
+    };
+    _proto.getScrollbarWidth = function getScrollbarWidth() {
         // Try/catch for FF 56 throwing on undefined computedStyles
         try {
             // Detect browsers supporting CSS scrollbar styling and do not calculate
-            if (getComputedStyle(this.contentWrapperEl, '::-webkit-scrollbar')
-                .display === 'none' ||
-                'scrollbarWidth' in document.documentElement.style ||
-                '-ms-overflow-style' in document.documentElement.style) {
+            if (getComputedStyle(this.contentWrapperEl, '::-webkit-scrollbar').display === 'none' || 'scrollbarWidth' in document.documentElement.style || '-ms-overflow-style' in document.documentElement.style) {
                 return 0;
             }
             else {
@@ -708,18 +649,18 @@ class SimpleBar {
         catch (e) {
             return scrollbarWidth(this.el);
         }
-    }
-    removeListeners() {
-        const elWindow = getElementWindow(this.el);
-        // Event listeners
+    };
+    _proto.removeListeners = function removeListeners() {
+        var _this5 = this;
+        var elWindow = getElementWindow(this.el); // Event listeners
         if (this.options.autoHide) {
             this.el.removeEventListener('mouseenter', this.onMouseEnter);
         }
-        ['mousedown', 'click', 'dblclick'].forEach(e => {
-            this.el.removeEventListener(e, this.onPointerEvent, true);
+        ['mousedown', 'click', 'dblclick'].forEach(function (e) {
+            _this5.el.removeEventListener(e, _this5.onPointerEvent, true);
         });
-        ['touchstart', 'touchend', 'touchmove'].forEach(e => {
-            this.el.removeEventListener(e, this.onPointerEvent, {
+        ['touchstart', 'touchend', 'touchmove'].forEach(function (e) {
+            _this5.el.removeEventListener(e, _this5.onPointerEvent, {
                 capture: true,
                 passive: true
             });
@@ -735,40 +676,27 @@ class SimpleBar {
         }
         if (this.resizeObserver) {
             this.resizeObserver.disconnect();
-        }
-        // Cancel all debounced functions
+        } // Cancel all debounced functions
         this.recalculate.cancel();
         this.onMouseMove.cancel();
         this.hideScrollbars.cancel();
         this.onWindowResize.cancel();
-    }
-    /**
-     * UnMount mutation observer and delete SimpleBar instance from DOM element
-     */
-    unMount() {
+    };
+    _proto.unMount = function unMount() {
         this.removeListeners();
         SimpleBar.instances.delete(this.el);
-    }
-    /**
-     * Check if mouse is within bounds
-     */
-    isWithinBounds(bbox) {
-        return (this.mouseX >= bbox.left &&
-            this.mouseX <= bbox.left + bbox.width &&
-            this.mouseY >= bbox.top &&
-            this.mouseY <= bbox.top + bbox.height);
-    }
-    /**
-     * Find element children matches query
-     */
-    findChild(el, query) {
-        const matches = el.matches ||
-            el.webkitMatchesSelector ||
-            el.mozMatchesSelector ||
-            el.msMatchesSelector;
-        return Array.prototype.filter.call(el.children, child => matches.call(child, query))[0];
-    }
-}
+    };
+    _proto.isWithinBounds = function isWithinBounds(bbox) {
+        return this.mouseX >= bbox.left && this.mouseX <= bbox.left + bbox.width && this.mouseY >= bbox.top && this.mouseY <= bbox.top + bbox.height;
+    };
+    _proto.findChild = function findChild(el, query) {
+        var matches = el.matches || el.webkitMatchesSelector || el.mozMatchesSelector || el.msMatchesSelector;
+        return Array.prototype.filter.call(el.children, function (child) {
+            return matches.call(child, query);
+        })[0];
+    };
+    return SimpleBar;
+}();
 SimpleBar.defaultOptions = {
     autoHide: true,
     forceVisible: false,