bkui-vue 2.0.1-beta.70.search.1 → 2.0.1-beta.71

package/lib/scrollbar/index.js

@@ -0,0 +1,1661 @@
+import "../styles/reset.css";
+/******/ // The require scope
+/******/ var __webpack_require__ = {};
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+var __webpack_exports__ = {};
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  IScrollbarSize: () => (/* binding */ IScrollbarSize),
+  VirtualElement: () => (/* binding */ VirtualElement),
+  "default": () => (/* binding */ BkScrollbar)
+});
+
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/classCallCheck.js
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+
+function toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+
+
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : String(i);
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/createClass.js
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+
+function _defineProperty(obj, key, value) {
+  key = toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/helper/dom.ts
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台 (BlueKing PaaS):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+function div(className) {
+  var div = document.createElement('div');
+  div.className = className;
+  return div;
+}
+var elMatches = typeof Element !== 'undefined' && Element.prototype.matches;
+function matches(el, query) {
+  var element = getElement(el);
+  if (!elMatches) {
+    throw new Error('No element matching method supported');
+  }
+  return elMatches.call(element, query);
+}
+function remove(el) {
+  var element = getElement(el);
+  if (element.remove) {
+    element.remove();
+  } else {
+    if (element.parentNode) {
+      element.parentNode.removeChild(element);
+    }
+  }
+}
+function queryChildren(element, selector) {
+  return Array.prototype.filter.call(element.children, function (child) {
+    return matches(child, selector);
+  });
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/helper/util.ts
+var _navigator;
+
+
+function toInt(x) {
+  return parseInt(x, 10) || 0;
+}
+function isEditable(el) {
+  return matches(el, 'input,[contenteditable]') || matches(el, 'select,[contenteditable]') || matches(el, 'textarea,[contenteditable]') || matches(el, 'button,[contenteditable]');
+}
+function util_outerWidth(element) {
+  var styles = get(element);
+  return toInt(styles.width) + toInt(styles.paddingLeft) + toInt(styles.paddingRight) + toInt(styles.borderLeftWidth) + toInt(styles.borderRightWidth);
+}
+var env = {
+  isWebKit: typeof document !== 'undefined' && 'WebkitAppearance' in document.documentElement.style,
+  supportsTouch: typeof window !== 'undefined' && ('ontouchstart' in window || 'maxTouchPoints' in window.navigator && window.navigator.maxTouchPoints > 0 ||
+  // @ts-ignore
+  window.DocumentTouch && document instanceof window.DocumentTouch),
+  // @ts-ignore
+  supportsIePointer: typeof navigator !== 'undefined' && navigator.msMaxTouchPoints,
+  isChrome: typeof navigator !== 'undefined' && /Chrome/i.test((_navigator = navigator) === null || _navigator === void 0 ? void 0 : _navigator.userAgent)
+};
+var getElement = function getElement(element) {
+  return element.isVirtualElement ? element.delegateElement : element;
+};
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/helper/css.ts
+
+function get(element) {
+  return getComputedStyle(getElement(element));
+}
+function set(element, obj) {
+  for (var key in obj) {
+    var val = obj[key];
+    if (typeof val === 'number') {
+      val = "".concat(val, "px");
+    }
+    element.style[key] = val;
+  }
+  return element;
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/update-geometry.ts
+
+
+
+/* harmony default export */ function update_geometry(i) {
+  var element = i.element;
+  var roundedScrollTop = Math.floor(element.scrollTop);
+  var rect = element.getBoundingClientRect();
+  i.containerWidth = Math.round(rect.width);
+  i.containerHeight = Math.round(rect.height);
+  i.contentWidth = element.scrollWidth;
+  i.contentHeight = element.scrollHeight;
+  if (!element.contains(i.scrollbarXRail)) {
+    // clean up and append
+    queryChildren(element, i.cls.element.rail('x')).forEach(function (el) {
+      return remove(el);
+    });
+    element.appendChild(i.scrollbarXRail);
+  }
+  if (!element.contains(i.scrollbarYRail)) {
+    // clean up and append
+    queryChildren(element, i.cls.element.rail('y')).forEach(function (el) {
+      return remove(el);
+    });
+    element.appendChild(i.scrollbarYRail);
+  }
+  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, toInt(i.railXWidth * i.containerWidth / i.contentWidth));
+    i.scrollbarXLeft = 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, toInt(i.railYHeight * i.containerHeight / i.contentHeight));
+    i.scrollbarYTop = i.element.isVirtualElement ? getThumbTop(i) : toInt(roundedScrollTop * (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) {
+    element.classList.add(i.cls.state.active('x'));
+  } else {
+    element.classList.remove(i.cls.state.active('x'));
+    i.scrollbarXWidth = 0;
+    i.scrollbarXLeft = 0;
+    element.scrollLeft = i.isRtl === true ? i.contentWidth : 0;
+  }
+  if (i.scrollbarYActive) {
+    element.classList.add(i.cls.state.active('y'));
+  } else {
+    element.classList.remove(i.cls.state.active('y'));
+    i.scrollbarYHeight = 0;
+    i.scrollbarYTop = 0;
+    element.scrollTop = 0;
+  }
+}
+function getThumbTop(i) {
+  var top = toInt(i.element.virtualScrollTop);
+  if (top >= 0) {
+    return top;
+  }
+  return 0;
+}
+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
+  };
+  var roundedScrollTop = element.isVirtualElement ? 0 : Math.floor(element.scrollTop);
+  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 - roundedScrollTop;
+  } else {
+    xRailOffset.top = i.scrollbarXTop + roundedScrollTop;
+  }
+  set(i.scrollbarXRail, xRailOffset);
+  var yRailOffset = {
+    top: roundedScrollTop,
+    height: i.railYHeight
+  };
+  if (i.isScrollbarYUsingRight) {
+    if (i.isRtl) {
+      yRailOffset.right = i.contentWidth - (i.negativeScrollAdjustment + element.scrollLeft) - i.scrollbarYRight - i.scrollbarYOuterWidth - 9;
+    } 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;
+    }
+  }
+  set(i.scrollbarYRail, yRailOffset);
+  set(i.scrollbarX, {
+    left: i.scrollbarXLeft,
+    width: i.scrollbarXWidth - i.railBorderXWidth
+  });
+  set(i.scrollbarY, {
+    top: i.scrollbarYTop,
+    height: i.scrollbarYHeight - i.railBorderYWidth
+  });
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/handlers/click-rail.ts
+
+/* harmony default export */ function click_rail(i) {
+  i.event.bind(i.scrollbarY, 'mousedown', function (e) {
+    return e.stopPropagation();
+  });
+  i.event.bind(i.scrollbarYRail, 'mousedown', function (e) {
+    var positionTop = e.pageY - window.pageYOffset - i.scrollbarYRail.getBoundingClientRect().top;
+    var direction = positionTop > i.scrollbarYTop ? 1 : -1;
+    if (!i.element.isVirtualElement) {
+      i.element.scrollTop += direction * i.containerHeight;
+    } else {
+      i.element.scrollTop = positionTop / (i.element.offsetHeight / i.element.scrollHeight);
+    }
+    i.element.scrollTop += direction * i.containerHeight;
+    update_geometry(i);
+    e.stopPropagation();
+  });
+  i.event.bind(i.scrollbarX, 'mousedown', function (e) {
+    return e.stopPropagation();
+  });
+  i.event.bind(i.scrollbarXRail, 'mousedown', function (e) {
+    var positionLeft = e.pageX - window.pageXOffset - i.scrollbarXRail.getBoundingClientRect().left;
+    var direction = positionLeft > i.scrollbarXLeft ? 1 : -1;
+    i.element.scrollLeft += direction * i.containerWidth;
+    update_geometry(i);
+    e.stopPropagation();
+  });
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/slicedToArray.js
+
+
+
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/helper/class-names.ts
+
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台 (BlueKing PaaS):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+var Cls = /*#__PURE__*/_createClass(function Cls() {
+  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'bk';
+  _classCallCheck(this, Cls);
+  this.main = "".concat(prefix, "-scrollbar");
+  this.rtl = "".concat(prefix, "-rtl");
+  this.element = {
+    thumb: function thumb(x) {
+      return "".concat(prefix, "__thumb-").concat(x);
+    },
+    rail: function rail(x) {
+      return "".concat(prefix, "__rail-").concat(x);
+    },
+    size: function size(x) {
+      return "".concat(prefix, "-scroll-size-").concat(x);
+    },
+    consuming: "".concat(prefix, "__child--consume")
+  };
+  this.state = {
+    focus: "".concat(prefix, "--focus"),
+    clicking: "".concat(prefix, "--clicking"),
+    active: function active(x) {
+      return "".concat(prefix, "--active-").concat(x);
+    },
+    scrolling: function scrolling(x) {
+      return "".concat(prefix, "--scrolling-").concat(x);
+    }
+  };
+});
+/* harmony default export */ const class_names = (Cls);
+/*
+ * Helper methods
+ */
+var scrollingClassTimeout = {
+  x: null,
+  y: null
+};
+function addScrollingClass(i, x) {
+  var classList = i.element.classList;
+  var className = i.cls.state.scrolling(x);
+  if (classList.contains(className)) {
+    clearTimeout(scrollingClassTimeout[x]);
+  } else {
+    classList.add(className);
+  }
+}
+function removeScrollingClass(i, x) {
+  scrollingClassTimeout[x] = setTimeout(function () {
+    return i.isAlive && i.element.classList.remove(i.cls.state.scrolling(x));
+  }, i.settings.scrollingThreshold);
+}
+function setScrollingClassInstantly(i, x) {
+  addScrollingClass(i, x);
+  removeScrollingClass(i, x);
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/handlers/drag-thumb.ts
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台 (BlueKing PaaS):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+
+/* harmony default export */ function drag_thumb(i) {
+  bindMouseScrollHandler(i, ['containerWidth', 'contentWidth', 'pageX', 'railXWidth', 'scrollbarX', 'scrollbarXWidth', 'scrollLeft', 'x', 'scrollbarXRail']);
+  bindMouseScrollHandler(i, ['containerHeight', 'contentHeight', 'pageY', 'railYHeight', 'scrollbarY', 'scrollbarYHeight', 'scrollTop', 'y', 'scrollbarYRail']);
+}
+function bindMouseScrollHandler(i, _ref) {
+  var _ref2 = _slicedToArray(_ref, 9),
+    containerHeight = _ref2[0],
+    contentHeight = _ref2[1],
+    pageY = _ref2[2],
+    railYHeight = _ref2[3],
+    scrollbarY = _ref2[4],
+    scrollbarYHeight = _ref2[5],
+    scrollTop = _ref2[6],
+    y = _ref2[7],
+    scrollbarYRail = _ref2[8];
+  var element = i.element;
+  var startingScrollTop = null;
+  var startingMousePageY = null;
+  var scrollBy = null;
+  function mouseMoveHandler(e) {
+    var _e$touches;
+    if ((_e$touches = e.touches) !== null && _e$touches !== void 0 && _e$touches[0]) {
+      e[pageY] = e.touches[0].pageY;
+    }
+    element[scrollTop] = startingScrollTop + scrollBy * (e[pageY] - startingMousePageY);
+    addScrollingClass(i, y);
+    update_geometry(i);
+    e.stopPropagation();
+    if (e.type.startsWith('touch') && e.changedTouches.length > 1) {
+      e.preventDefault();
+    }
+  }
+  function mouseUpHandler() {
+    removeScrollingClass(i, y);
+    i[scrollbarYRail].classList.remove(i.cls.state.clicking);
+    i.event.unbind(i.ownerDocument, 'mousemove', mouseMoveHandler);
+  }
+  function bindMoves(e, touchMode) {
+    startingScrollTop = element[scrollTop];
+    if (touchMode && e.touches) {
+      e[pageY] = e.touches[0].pageY;
+    }
+    startingMousePageY = e[pageY];
+    scrollBy = (i[contentHeight] - i[containerHeight]) / (i[railYHeight] - i[scrollbarYHeight]);
+    if (!touchMode) {
+      i.event.bind(i.ownerDocument, 'mousemove', mouseMoveHandler);
+      i.event.once(i.ownerDocument, 'mouseup', mouseUpHandler);
+      e.preventDefault();
+    } else {
+      i.event.bind(i.ownerDocument, 'touchmove', mouseMoveHandler);
+    }
+    i[scrollbarYRail].classList.add(i.cls.state.clicking);
+    e.stopPropagation();
+  }
+  i.event.bind(i[scrollbarY], 'mousedown', function (e) {
+    bindMoves(e);
+  });
+  i.event.bind(i[scrollbarY], 'touchstart', function (e) {
+    bindMoves(e, true);
+  });
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/handlers/keyboard.ts
+
+
+
+/* harmony default export */ function keyboard(i) {
+  var element = i.element;
+  var elementHovered = function elementHovered() {
+    return matches(element, ':hover');
+  };
+  var scrollbarFocused = function scrollbarFocused() {
+    return matches(i.scrollbarX, ':focus') || matches(i.scrollbarY, ':focus');
+  };
+  function shouldPreventDefault(deltaX, deltaY) {
+    var scrollTop = Math.floor(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 getPageHeight() {
+    if (element.isVirtualElement) {
+      return i.containerHeight / i.element.scrollHeight * i.containerHeight;
+    }
+    return i.containerHeight;
+  }
+  function getContentHeight() {
+    if (element.isVirtualElement) {
+      return i.containerHeight;
+    }
+    return i.contentHeight;
+  }
+  i.event.bind(i.ownerDocument, 'keydown', function (e) {
+    var _e$isDefaultPrevented;
+    var step = 30;
+    if ((_e$isDefaultPrevented = e.isDefaultPrevented) !== null && _e$isDefaultPrevented !== void 0 && _e$isDefaultPrevented.call(e) || e.defaultPrevented) {
+      return;
+    }
+    if (!elementHovered() && !scrollbarFocused()) {
+      return;
+    }
+    var activeElement = document.activeElement ? document.activeElement : i.ownerDocument.activeElement;
+    if (activeElement) {
+      if (activeElement.tagName === 'IFRAME') {
+        // @ts-ignore
+        activeElement = activeElement.contentDocument.activeElement;
+      } else {
+        // go deeper if element is a webcomponent
+        while (activeElement.shadowRoot) {
+          activeElement = activeElement.shadowRoot.activeElement;
+        }
+      }
+      if (isEditable(activeElement)) {
+        return;
+      }
+    }
+    var deltaX = 0;
+    var deltaY = 0;
+    switch (e.which) {
+      case 37:
+        // left
+        if (e.metaKey) {
+          deltaX = -i.contentWidth;
+        } else if (e.altKey) {
+          deltaX = -i.containerWidth;
+        } else {
+          deltaX = -step;
+        }
+        break;
+      case 38:
+        // up
+        if (e.metaKey) {
+          deltaY = getContentHeight();
+        } else if (e.altKey) {
+          deltaY = getPageHeight();
+        } else {
+          deltaY = step;
+        }
+        break;
+      case 39:
+        // right
+        if (e.metaKey) {
+          deltaX = i.contentWidth;
+        } else if (e.altKey) {
+          deltaX = i.containerWidth;
+        } else {
+          deltaX = step;
+        }
+        break;
+      case 40:
+        // down
+        if (e.metaKey) {
+          deltaY = -getContentHeight();
+        } else if (e.altKey) {
+          deltaY = -getPageHeight();
+        } else {
+          deltaY = -step;
+        }
+        break;
+      case 32:
+        // space bar
+        if (e.shiftKey) {
+          deltaY = getPageHeight();
+        } else {
+          deltaY = -getPageHeight();
+        }
+        break;
+      case 33:
+        // page up
+        deltaY = getPageHeight();
+        break;
+      case 34:
+        // page down
+        deltaY = -getPageHeight();
+        break;
+      case 36:
+        // home
+        deltaY = getContentHeight();
+        break;
+      case 35:
+        // end
+        deltaY = -getContentHeight();
+        break;
+      default:
+        return;
+    }
+    if (i.settings.suppressScrollX && deltaX !== 0) {
+      return;
+    }
+    if (i.settings.suppressScrollY && deltaY !== 0) {
+      return;
+    }
+    element.scrollTop -= deltaY;
+    element.scrollLeft += deltaX;
+    update_geometry(i);
+    if (shouldPreventDefault(deltaX, deltaY)) {
+      e.preventDefault();
+    }
+  });
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/handlers/mouse-wheel.ts
+
+
+
+
+/* harmony default export */ function mouse_wheel(i) {
+  var isVirtualElement = i.element.isVirtualElement;
+  var element = isVirtualElement ? i.element.delegateElement : i.element;
+  function shouldPreventDefault(deltaX, deltaY) {
+    var scrollTopValue = isVirtualElement ? i.element.virtualScrollTop : element.scrollTop;
+    var roundedScrollTop = Math.floor(scrollTopValue);
+    var isTop = scrollTopValue === 0;
+    var isBottom = function isBottom() {
+      if (isVirtualElement) {
+        return roundedScrollTop + i.scrollbarYHeight >= i.railYHeight;
+      }
+      return roundedScrollTop + i.element.offsetHeight === i.element.scrollHeight;
+    };
+    var isLeft = element.scrollLeft === 0;
+    var isRight = element.scrollLeft + element.offsetWidth === element.scrollWidth;
+    var hitsBound;
+    // pick axis with primary direction
+    if (Math.abs(deltaY) > Math.abs(deltaX)) {
+      hitsBound = isTop || isBottom();
+    } else {
+      hitsBound = isLeft || isRight;
+    }
+    return hitsBound ? !i.settings.wheelPropagation : 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;
+    }
+    if (e.shiftKey) {
+      // reverse axis with shift key
+      return [-deltaY, -deltaX];
+    }
+    return [deltaX, deltaY];
+  }
+  function shouldBeConsumedByChild(target, deltaX, deltaY) {
+    // FIXME: this is a workaround for <select> issue in FF and IE #571
+    if (!env.isWebKit && element.querySelector('select:focus')) {
+      return true;
+    }
+    if (!element.contains(target)) {
+      return false;
+    }
+    var cursor = target;
+    while (cursor && cursor !== element) {
+      if (cursor.classList.contains(i.cls.element.consuming)) {
+        return true;
+      }
+      var style = get(cursor);
+      // if deltaY && vertical scrollable
+      if (deltaY && style.overflowY.match(/(scroll|auto)/)) {
+        var maxScrollTop = cursor.scrollHeight - cursor.clientHeight;
+        if (maxScrollTop > 0) {
+          if (cursor.scrollTop > 0 && deltaY < 0 || cursor.scrollTop < maxScrollTop && deltaY > 0) {
+            return true;
+          }
+        }
+      }
+      // if deltaX && horizontal scrollable
+      if (deltaX && style.overflowX.match(/(scroll|auto)/)) {
+        var maxScrollLeft = cursor.scrollWidth - cursor.clientWidth;
+        if (maxScrollLeft > 0) {
+          if (cursor.scrollLeft > 0 && deltaX < 0 || cursor.scrollLeft < maxScrollLeft && deltaX > 0) {
+            return true;
+          }
+        }
+      }
+      cursor = cursor.parentNode;
+    }
+    return false;
+  }
+  var getMaxValue = function getMaxValue() {
+    return i.element.scrollHeight - i.element.offsetHeight;
+  };
+  function setScrollTop(diff) {
+    var newValue = i.element.scrollTop - diff;
+    var maxValue = getMaxValue();
+    if (newValue > maxValue) {
+      newValue = maxValue;
+    }
+    if (newValue < 0) {
+      newValue = 0;
+    }
+    i.element.scrollTop = newValue;
+  }
+  function mousewheelHandler(e) {
+    var _getDeltaFromEvent = getDeltaFromEvent(e),
+      _getDeltaFromEvent2 = _slicedToArray(_getDeltaFromEvent, 2),
+      deltaX = _getDeltaFromEvent2[0],
+      deltaY = _getDeltaFromEvent2[1];
+    if (shouldBeConsumedByChild(e.target, deltaX, deltaY)) {
+      return;
+    }
+    var 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
+      setScrollTop(deltaY * i.settings.wheelSpeed);
+      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) {
+        setScrollTop(deltaY * i.settings.wheelSpeed);
+      } else {
+        setScrollTop(-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) {
+        element.scrollLeft += deltaX * i.settings.wheelSpeed;
+      } else {
+        element.scrollLeft -= deltaY * i.settings.wheelSpeed;
+      }
+      shouldPrevent = true;
+    }
+    update_geometry(i);
+    shouldPrevent = shouldPrevent || shouldPreventDefault(deltaX, deltaY);
+    if (shouldPrevent && !e.ctrlKey) {
+      e.stopPropagation();
+      e.preventDefault();
+    }
+  }
+  if (typeof window.onwheel !== 'undefined') {
+    i.event.bind(element, 'wheel', mousewheelHandler);
+    // @ts-ignore
+  } else if (typeof window.onmousewheel !== 'undefined') {
+    i.event.bind(element, 'mousewheel', mousewheelHandler);
+  }
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/handlers/touch.ts
+
+
+
+/* harmony default export */ function touch(i) {
+  if (!env.supportsTouch && !env.supportsIePointer) {
+    return;
+  }
+  var element = i.element;
+  function shouldPrevent(deltaX, deltaY) {
+    var scrollTop = Math.floor(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) {
+        // set prevent for mobile Chrome refresh
+        return window.scrollY === 0 && deltaY > 0 && env.isChrome;
+      }
+    } 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 true;
+      }
+    }
+    return true;
+  }
+  function applyTouchMove(differenceX, differenceY) {
+    element.scrollLeft -= differenceX;
+    element.scrollTop -= differenceY;
+    update_geometry(i);
+  }
+  var startOffset = {};
+  var startTime = 0;
+  var speed = {};
+  var easingLoop = null;
+  function getTouch(e) {
+    if (e.targetTouches) {
+      return e.targetTouches[0];
+    } else {
+      // Maybe IE pointer
+      return e;
+    }
+  }
+  function shouldHandle(e) {
+    if (e.pointerType && e.pointerType === 'pen' && e.buttons === 0) {
+      return false;
+    }
+    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)) {
+      return;
+    }
+    var touch = getTouch(e);
+    startOffset.pageX = touch.pageX;
+    startOffset.pageY = touch.pageY;
+    startTime = new Date().getTime();
+    if (easingLoop !== null) {
+      clearInterval(easingLoop);
+    }
+  }
+  function shouldBeConsumedByChild(target, deltaX, deltaY) {
+    if (!element.contains(target)) {
+      return false;
+    }
+    var cursor = target;
+    while (cursor && cursor !== element) {
+      if (cursor.classList.contains(i.cls.element.consuming)) {
+        return true;
+      }
+      var style = get(cursor);
+      // if deltaY && vertical scrollable
+      if (deltaY && style.overflowY.match(/(scroll|auto)/)) {
+        var maxScrollTop = cursor.scrollHeight - cursor.clientHeight;
+        if (maxScrollTop > 0) {
+          if (cursor.scrollTop > 0 && deltaY < 0 || cursor.scrollTop < maxScrollTop && deltaY > 0) {
+            return true;
+          }
+        }
+      }
+      // if deltaX && horizontal scrollable
+      if (deltaX && style.overflowX.match(/(scroll|auto)/)) {
+        var maxScrollLeft = cursor.scrollWidth - cursor.clientWidth;
+        if (maxScrollLeft > 0) {
+          if (cursor.scrollLeft > 0 && deltaX < 0 || cursor.scrollLeft < maxScrollLeft && deltaX > 0) {
+            return true;
+          }
+        }
+      }
+      cursor = cursor.parentNode;
+    }
+    return false;
+  }
+  function touchMove(e) {
+    if (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;
+      if (shouldBeConsumedByChild(e.target, differenceX, differenceY)) {
+        return;
+      }
+      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 (shouldPrevent(differenceX, differenceY)) {
+        e.preventDefault();
+      }
+    }
+  }
+  function touchEnd() {
+    if (i.settings.swipeEasing) {
+      clearInterval(easingLoop);
+      easingLoop = setInterval(function () {
+        if (i.isInitialized) {
+          clearInterval(easingLoop);
+          return;
+        }
+        if (!speed.x && !speed.y) {
+          clearInterval(easingLoop);
+          return;
+        }
+        if (Math.abs(speed.x) < 0.01 && Math.abs(speed.y) < 0.01) {
+          clearInterval(easingLoop);
+          return;
+        }
+        if (!i.element) {
+          clearInterval(easingLoop);
+          return;
+        }
+        applyTouchMove(speed.x * 30, speed.y * 30);
+        speed.x *= 0.8;
+        speed.y *= 0.8;
+      }, 10);
+    }
+  }
+  if (env.supportsTouch) {
+    i.event.bind(element, 'touchstart', touchStart);
+    i.event.bind(element, 'touchmove', touchMove);
+    i.event.bind(element, 'touchend', touchEnd);
+  } else if (env.supportsIePointer) {
+    if (window.PointerEvent) {
+      i.event.bind(element, 'pointerdown', touchStart);
+      i.event.bind(element, 'pointermove', touchMove);
+      i.event.bind(element, 'pointerup', touchEnd);
+      // @ts-ignore
+    } else if (window.MSPointerEvent) {
+      i.event.bind(element, 'MSPointerDown', touchStart);
+      i.event.bind(element, 'MSPointerMove', touchMove);
+      i.event.bind(element, 'MSPointerUp', touchEnd);
+    }
+  }
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/helper/event-manager.ts
+
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台 (BlueKing PaaS):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+var EventElement = /*#__PURE__*/function () {
+  function EventElement(element) {
+    _classCallCheck(this, EventElement);
+    this.element = element;
+    this.handlers = {};
+  }
+  _createClass(EventElement, [{
+    key: "bind",
+    value: function bind(eventName, handler) {
+      if (typeof this.handlers[eventName] === 'undefined') {
+        this.handlers[eventName] = [];
+      }
+      this.handlers[eventName].push(handler);
+      this.element.addEventListener(eventName, handler, false);
+    }
+  }, {
+    key: "unbind",
+    value: function unbind(eventName, target) {
+      var _this = this;
+      this.handlers[eventName] = this.handlers[eventName].filter(function (handler) {
+        if (target && handler !== target) {
+          return true;
+        }
+        _this.element.removeEventListener(eventName, handler, false);
+        return false;
+      });
+    }
+  }, {
+    key: "unbindAll",
+    value: function unbindAll() {
+      for (var name in this.handlers) {
+        this.unbind(name);
+      }
+    }
+  }, {
+    key: "isEmpty",
+    get: function get() {
+      var _this2 = this;
+      return Object.keys(this.handlers).every(function (key) {
+        return _this2.handlers[key].length === 0;
+      });
+    }
+  }]);
+  return EventElement;
+}();
+var EventManager = /*#__PURE__*/function () {
+  function EventManager() {
+    _classCallCheck(this, EventManager);
+    this.eventElements = [];
+  }
+  _createClass(EventManager, [{
+    key: "eventElement",
+    value: function eventElement(element) {
+      var ee = this.eventElements.filter(function (ee) {
+        return ee.element === element;
+      })[0];
+      if (!ee) {
+        ee = new EventElement(element);
+        this.eventElements.push(ee);
+      }
+      return ee;
+    }
+  }, {
+    key: "bind",
+    value: function bind(element, eventName, handler) {
+      this.eventElement(element).bind(eventName, handler);
+    }
+  }, {
+    key: "unbind",
+    value: function unbind(element, eventName, handler) {
+      var ee = this.eventElement(element);
+      ee.unbind(eventName, handler);
+      if (ee.isEmpty) {
+        // remove
+        this.eventElements.splice(this.eventElements.indexOf(ee), 1);
+      }
+    }
+  }, {
+    key: "unbindAll",
+    value: function unbindAll() {
+      this.eventElements.forEach(function (e) {
+        return e.unbindAll();
+      });
+      this.eventElements = [];
+    }
+  }, {
+    key: "once",
+    value: function once(element, eventName, handler) {
+      var ee = this.eventElement(element);
+      var onceHandler = function onceHandler(evt) {
+        ee.unbind(eventName, onceHandler);
+        handler(evt);
+      };
+      ee.bind(eventName, onceHandler);
+    }
+  }]);
+  return EventManager;
+}();
+
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/process-scroll-diff.ts
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台 (BlueKing PaaS):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+function createEvent(name) {
+  if (typeof window.CustomEvent === 'function') {
+    return new CustomEvent(name);
+  } else {
+    var evt = document.createEvent('CustomEvent');
+    evt.initCustomEvent(name, false, false, undefined);
+    return evt;
+  }
+}
+/* harmony default export */ function process_scroll_diff(i, axis, diff) {
+  var useScrollingClass = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var forceFireReachEvent = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var fields;
+  if (axis === 'top') {
+    fields = ['contentHeight', 'containerHeight', 'scrollTop', 'y', 'up', 'down'];
+  } else if (axis === 'left') {
+    fields = ['contentWidth', 'containerWidth', 'scrollLeft', 'x', 'left', 'right'];
+  } else {
+    throw new Error('A proper axis should be provided');
+  }
+  processScrollDiff(i, diff, fields, useScrollingClass, forceFireReachEvent);
+}
+function processScrollDiff(i, diff, _ref) {
+  var _ref2 = _slicedToArray(_ref, 6),
+    contentHeight = _ref2[0],
+    containerHeight = _ref2[1],
+    scrollTop = _ref2[2],
+    y = _ref2[3],
+    up = _ref2[4],
+    down = _ref2[5];
+  var useScrollingClass = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var forceFireReachEvent = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var element = i.element;
+  // reset reach
+  i.reach[y] = null;
+  // 1 for subpixel rounding
+  if (element[scrollTop] < 1) {
+    i.reach[y] = 'start';
+  }
+  // 1 for subpixel rounding
+  if (element[scrollTop] > i[contentHeight] - i[containerHeight] - 1) {
+    i.reach[y] = 'end';
+  }
+  if (diff) {
+    element.dispatchEvent(createEvent("ps-scroll-".concat(y)));
+    if (diff < 0) {
+      element.dispatchEvent(createEvent("ps-scroll-".concat(up)));
+    } else if (diff > 0) {
+      element.dispatchEvent(createEvent("ps-scroll-".concat(down)));
+    }
+    if (useScrollingClass) {
+      setScrollingClassInstantly(i, y);
+    }
+  }
+  if (i.reach[y] && (diff || forceFireReachEvent)) {
+    element.dispatchEvent(createEvent("ps-".concat(y, "-reach-").concat(i.reach[y])));
+  }
+}
+;// CONCATENATED MODULE: ../../packages/scrollbar/src/index.ts
+
+
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台 (BlueKing PaaS) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台 (BlueKing PaaS):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+var IScrollbarSize;
+(function (IScrollbarSize) {
+  IScrollbarSize["Large"] = "large";
+  IScrollbarSize["Normal"] = "normal";
+  IScrollbarSize["Small"] = "small";
+})(IScrollbarSize || (IScrollbarSize = {}));
+// 默认配置
+var defaultSettings = function defaultSettings() {
+  return {
+    handlers: ['click-rail', 'drag-thumb', 'keyboard', 'wheel', 'touch'],
+    maxScrollbarLength: null,
+    minScrollbarLength: 16,
+    scrollingThreshold: 1000,
+    scrollXMarginOffset: 0,
+    scrollYMarginOffset: 0,
+    suppressScrollX: false,
+    suppressScrollY: false,
+    swipeEasing: true,
+    useBothWheelAxes: false,
+    wheelPropagation: true,
+    wheelSpeed: 1,
+    classPrefix: 'bk',
+    scrollSize: IScrollbarSize.Normal
+  };
+};
+// 处理器集合
+var handlers = {
+  'click-rail': click_rail,
+  'drag-thumb': drag_thumb,
+  keyboard: keyboard,
+  wheel: mouse_wheel,
+  touch: touch
+};
+var VirtualElement = /*#__PURE__*/function () {
+  function VirtualElement(_ref) {
+    var _this = this;
+    var scrollHeight = _ref.scrollHeight,
+      delegateElement = _ref.delegateElement,
+      onScollCallback = _ref.onScollCallback;
+    _classCallCheck(this, VirtualElement);
+    _defineProperty(this, "isVirtualElement", true);
+    _defineProperty(this, "scrollTop", 0);
+    this.scrollHeight = scrollHeight;
+    this.delegateElement = delegateElement;
+    this.virtualScrollTop = 0;
+    this.virtualScrollLeft = 0;
+    this.onScollCallback = onScollCallback;
+    return new Proxy(this, {
+      get: function get(target, prop, receiver) {
+        if (prop in target) {
+          var value = Reflect.get(target, prop, receiver);
+          if (value !== undefined) {
+            return value;
+          }
+        }
+        if (delegateElement && prop in delegateElement) {
+          var _value = delegateElement[prop];
+          // Bind the method to delegateElement if it's a function
+          if (typeof _value === 'function') {
+            return _value.bind(delegateElement);
+          }
+          return _value;
+        }
+        return undefined;
+      },
+      set: function set(target, prop, value) {
+        if (prop in target) {
+          if (prop === 'scrollTop') {
+            target.virtualScrollTop = value * target.delegateElement.offsetHeight / target.scrollHeight;
+            var triggerCallbackFn = target.scrollTop !== value;
+            target.scrollTop = value;
+            if (triggerCallbackFn) {
+              _this.handleScrollChanged('scrollTop');
+            }
+            return true;
+          }
+          target[prop] = value;
+          return true;
+        }
+        if (delegateElement && prop in delegateElement) {
+          delegateElement[prop] = value;
+          _this.handleScrollChanged(prop);
+          return true;
+        }
+        target[prop] = value;
+        return true;
+      }
+    });
+  }
+  _createClass(VirtualElement, [{
+    key: "handleScrollChanged",
+    value: function handleScrollChanged(prop) {
+      if (['scrollLeft', 'scrollTop'].includes(prop)) {
+        var _this$onScollCallback;
+        var args = {
+          offset: {
+            x: this.delegateElement.scrollLeft,
+            y: this.scrollTop
+          }
+        };
+        (_this$onScollCallback = this.onScollCallback) === null || _this$onScollCallback === void 0 || _this$onScollCallback.call(this, args);
+      }
+    }
+  }, {
+    key: "scrollTo",
+    value: function scrollTo(_ref2) {
+      var x = _ref2.x,
+        y = _ref2.y;
+      this.delegateElement.scrollLeft = x;
+      this.scrollTop = y;
+      this.delegateElement.scrollTo(x, y);
+    }
+  }]);
+  return VirtualElement;
+}();
+// 自定义滚动条类
+var BkScrollbar = /*#__PURE__*/function () {
+  /**
+   * 构造函数
+   * @param {Element | string} element - 滚动条元素或选择器字符串
+   * @param {Partial<ISettingPropType>} userSettings - 用户配置
+   */
+  function BkScrollbar(element) {
+    var _element,
+      _element2,
+      _this2 = this,
+      _this$contentWidth,
+      _this$contentHeight;
+    var userSettings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, BkScrollbar);
+    if (typeof element === 'string') {
+      element = document.querySelector(element);
+    }
+    if (!((_element = element) !== null && _element !== void 0 && _element.nodeName) && !((_element2 = element) !== null && _element2 !== void 0 && _element2.isVirtualElement)) {
+      throw new Error('no element is specified to initialize PerfectScrollbar');
+    }
+    this.settings = _objectSpread(_objectSpread({}, defaultSettings()), userSettings);
+    this.element = element;
+    this.cls = new class_names(this.settings.classPrefix);
+    element.classList.add(this.cls.main);
+    this.containerWidth = null;
+    this.containerHeight = null;
+    this.contentWidth = null;
+    this.contentHeight = null;
+    var focus = function focus() {
+      return element.classList.add(_this2.cls.state.focus);
+    };
+    var blur = function blur() {
+      return element.classList.remove(_this2.cls.state.focus);
+    };
+    this.isRtl = get(element).direction === 'rtl';
+    if (this.isRtl) {
+      element.classList.add(this.cls.rtl);
+    }
+    this.isNegativeScroll = function () {
+      var originalScrollLeft = element.scrollLeft;
+      var result = null;
+      element.scrollLeft = -1;
+      result = element.scrollLeft < 0;
+      element.scrollLeft = originalScrollLeft;
+      return result;
+    }();
+    this.negativeScrollAdjustment = this.isNegativeScroll ? element.scrollWidth - element.clientWidth : 0;
+    this.event = new EventManager();
+    this.ownerDocument = element.ownerDocument || document;
+    this.scrollbarXRail = div(this.cls.element.rail('x'));
+    this.scrollbarXRail.classList.add(this.cls.element.size(this.settings.scrollSize));
+    element.appendChild(this.scrollbarXRail);
+    this.scrollbarX = div(this.cls.element.thumb('x'));
+    this.scrollbarXRail.appendChild(this.scrollbarX);
+    this.scrollbarX.setAttribute('tabindex', '0');
+    this.event.bind(this.scrollbarX, 'focus', focus);
+    this.event.bind(this.scrollbarX, 'blur', blur);
+    this.scrollbarXActive = null;
+    this.scrollbarXWidth = null;
+    this.scrollbarXLeft = null;
+    var railXStyle = get(this.scrollbarXRail);
+    this.scrollbarXBottom = parseInt(railXStyle.bottom, 10);
+    if (isNaN(this.scrollbarXBottom)) {
+      this.isScrollbarXUsingBottom = false;
+      this.scrollbarXTop = toInt(railXStyle.top);
+    } else {
+      this.isScrollbarXUsingBottom = true;
+    }
+    this.railBorderXWidth = toInt(railXStyle.borderLeftWidth) + toInt(railXStyle.borderRightWidth);
+    set(this.scrollbarXRail, {
+      display: 'block'
+    });
+    this.railXMarginWidth = toInt(railXStyle.marginLeft) + toInt(railXStyle.marginRight);
+    set(this.scrollbarXRail, {
+      display: ''
+    });
+    this.railXWidth = null;
+    this.railXRatio = null;
+    this.scrollbarYRail = div(this.cls.element.rail('y'));
+    this.scrollbarYRail.classList.add(this.cls.element.size(this.settings.scrollSize));
+    element.appendChild(this.scrollbarYRail);
+    this.scrollbarY = div(this.cls.element.thumb('y'));
+    this.scrollbarYRail.appendChild(this.scrollbarY);
+    this.scrollbarY.setAttribute('tabindex', '0');
+    this.event.bind(this.scrollbarY, 'focus', focus);
+    this.event.bind(this.scrollbarY, 'blur', blur);
+    this.scrollbarYActive = null;
+    this.scrollbarYHeight = null;
+    this.scrollbarYTop = null;
+    var railYStyle = get(this.scrollbarYRail);
+    this.scrollbarYRight = parseInt(railYStyle.right, 10);
+    if (isNaN(this.scrollbarYRight)) {
+      this.isScrollbarYUsingRight = false;
+      this.scrollbarYLeft = toInt(railYStyle.left);
+    } else {
+      this.isScrollbarYUsingRight = true;
+    }
+    this.scrollbarYOuterWidth = this.isRtl ? util_outerWidth(this.scrollbarY) : null;
+    this.railBorderYWidth = toInt(railYStyle.borderTopWidth) + toInt(railYStyle.borderBottomWidth);
+    set(this.scrollbarYRail, {
+      display: 'block'
+    });
+    this.railYMarginHeight = toInt(railYStyle.marginTop) + toInt(railYStyle.marginBottom);
+    set(this.scrollbarYRail, {
+      display: ''
+    });
+    this.railYHeight = null;
+    this.railYRatio = null;
+    this.reach = {
+      x: element.scrollLeft <= 0 ? 'start' : element.scrollLeft >= ((_this$contentWidth = this.contentWidth) !== null && _this$contentWidth !== void 0 ? _this$contentWidth : 0) - this.containerWidth ? 'end' : null,
+      y: element.scrollTop <= 0 ? 'start' : element.scrollTop >= ((_this$contentHeight = this.contentHeight) !== null && _this$contentHeight !== void 0 ? _this$contentHeight : 0) - this.containerHeight ? 'end' : null
+    };
+    this.isAlive = true;
+    this.settings.handlers.forEach(function (handlerName) {
+      return handlers[handlerName](_this2);
+    });
+    this.lastScrollTop = Math.floor(element.scrollTop);
+    this.lastScrollLeft = element.scrollLeft;
+    this.event.bind(this.element, 'scroll', function (e) {
+      return _this2.onScroll(e);
+    });
+    update_geometry(this);
+  }
+  /**
+   * 更新滚动条
+   */
+  _createClass(BkScrollbar, [{
+    key: "update",
+    value: function update(virtaulElement) {
+      if (!this.isAlive) {
+        return;
+      }
+      if (virtaulElement !== null && virtaulElement !== void 0 && virtaulElement.isVirtualElement) {
+        this.element = virtaulElement;
+      }
+      this.negativeScrollAdjustment = this.isNegativeScroll ? this.element.scrollWidth - this.element.clientWidth : 0;
+      set(this.scrollbarXRail, {
+        display: 'block'
+      });
+      set(this.scrollbarYRail, {
+        display: 'block'
+      });
+      this.railXMarginWidth = toInt(get(this.scrollbarXRail).marginLeft) + toInt(get(this.scrollbarXRail).marginRight);
+      this.railYMarginHeight = toInt(get(this.scrollbarYRail).marginTop) + toInt(get(this.scrollbarYRail).marginBottom);
+      set(this.scrollbarXRail, {
+        display: 'none'
+      });
+      set(this.scrollbarYRail, {
+        display: 'none'
+      });
+      update_geometry(this);
+      process_scroll_diff(this, 'top', 0, false, true);
+      process_scroll_diff(this, 'left', 0, false, true);
+      set(this.scrollbarXRail, {
+        display: ''
+      });
+      set(this.scrollbarYRail, {
+        display: ''
+      });
+    }
+    /**
+     * 滚动事件处理
+     * @param {Event} _e - 滚动事件
+     */
+  }, {
+    key: "onScroll",
+    value: function onScroll(_e) {
+      if (!this.isAlive) {
+        return;
+      }
+      update_geometry(this);
+      process_scroll_diff(this, 'top', this.element.scrollTop - this.lastScrollTop);
+      process_scroll_diff(this, 'left', this.element.scrollLeft - this.lastScrollLeft);
+      this.lastScrollTop = Math.floor(this.element.scrollTop);
+      this.lastScrollLeft = this.element.scrollLeft;
+    }
+  }, {
+    key: "scrollTo",
+    value: function scrollTo(_ref3) {
+      var x = _ref3.x,
+        y = _ref3.y;
+      if (y !== undefined && typeof y === 'number') {
+        this.element.scrollTop = y;
+      }
+      if (x !== undefined && typeof x === 'number') {
+        this.element.scrollLeft = x;
+      }
+      update_geometry(this);
+    }
+    /**
+     * 销毁滚动条实例
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this.isAlive) {
+        return;
+      }
+      this.event.unbindAll();
+      remove(this.scrollbarX);
+      remove(this.scrollbarY);
+      remove(this.scrollbarXRail);
+      remove(this.scrollbarYRail);
+      this.removePsClasses();
+      this.element = null;
+      this.scrollbarX = null;
+      this.scrollbarY = null;
+      this.scrollbarXRail = null;
+      this.scrollbarYRail = null;
+      this.isAlive = false;
+    }
+    /**
+     * 移除滚动条相关的类名
+     */
+  }, {
+    key: "removePsClasses",
+    value: function removePsClasses() {
+      var _this3 = this;
+      this.element.className = this.element.className.split(' ').filter(function (name) {
+        return !name.match(new RegExp("^".concat(_this3.settings.classPrefix, "([-_].+|)$")));
+      }).join(' ');
+    }
+  }]);
+  return BkScrollbar;
+}();
+
+var __webpack_exports__IScrollbarSize = __webpack_exports__.IScrollbarSize;
+var __webpack_exports__VirtualElement = __webpack_exports__.VirtualElement;
+var __webpack_exports__default = __webpack_exports__["default"];
+export { __webpack_exports__IScrollbarSize as IScrollbarSize, __webpack_exports__VirtualElement as VirtualElement, __webpack_exports__default as default };