tdesign-react 0.22.1 → 0.23.0

package/dist/tdesign.js

@@ -1,5 +1,5 @@
 /**
- * tdesign v0.22.1
+ * tdesign v0.23.0
  * (c) 2022 tdesign
  * @license MIT
  */
@@ -37,17 +37,11 @@
   function _typeof(obj) {
     "@babel/helpers - typeof";
 
-    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-      _typeof = function _typeof(obj) {
-        return typeof obj;
-      };
-    } else {
-      _typeof = function _typeof(obj) {
-        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      };
-    }
-
-    return _typeof(obj);
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof(obj);
   }
 
   function _arrayWithHoles(arr) {
@@ -295,7 +289,7 @@
         year: "\u8BF7\u9009\u62E9\u5E74\u4EFD"
       },
       weekdays: ["\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D", "\u65E5"],
-      months: ["\u4E00\u6708", "\u4E8C\u6708", "\u4E09\u6708", "\u56DB\u6708", "\u4E94\u6708", "\u516D\u6708", "\u4E03\u6708", "\u516B\u6708", "\u4E5D\u6708", "\u5341\u6708", "\u5341\u4E00\u6708", "\u5341\u4E8C\u6708"],
+      months: ["1 \u6708", "2 \u6708", "3 \u6708", "4 \u6708", "5 \u6708", "6 \u6708", "7 \u6708", "8 \u6708", "9 \u6708", "10 \u6708", "11 \u6708", "12 \u6708"],
       firstDayOfWeek: 0,
       rangeSeparator: " \u81F3 ",
       direction: "ltr",
@@ -334,9 +328,9 @@
 
   var _excluded$u = ["width", "className", "style", "children"];
 
-  function ownKeys$1Y(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+  function ownKeys$1Z(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-  function _objectSpread$1Y(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1Y(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1Y(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+  function _objectSpread$1Z(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1Z(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1Z(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
   var Aside = function Aside(props) {
     var width = props.width,
@@ -351,14 +345,14 @@
     var asideClassNames = classNames$1("".concat(classPrefix, "-layout__sider"), className);
     var asideWidth = typeof width === "number" ? "".concat(width, "px") : String(width);
 
-    var asideStyle = _objectSpread$1Y({
+    var asideStyle = _objectSpread$1Z({
       width: asideWidth,
       maxWidth: asideWidth,
       minWidth: asideWidth,
       flex: "0 0 ".concat(asideWidth)
     }, style);
 
-    return /* @__PURE__ */React__default["default"].createElement("aside", _objectSpread$1Y({
+    return /* @__PURE__ */React__default["default"].createElement("aside", _objectSpread$1Z({
       className: asideClassNames,
       style: asideStyle
     }, otherAsideProps), children);
@@ -374,9 +368,9 @@
       _excluded3 = ["className", "style", "children"],
       _excluded4 = ["direction", "className", "style", "children"];
 
-  function ownKeys$1X(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+  function ownKeys$1Y(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-  function _objectSpread$1X(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1X(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1X(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+  function _objectSpread$1Y(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1Y(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1Y(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
   var Header = function Header(props) {
     var _useConfig = useConfig$1(),
@@ -388,7 +382,7 @@
         others = _objectWithoutProperties$1(props, _excluded$t);
 
     var headerClassNames = classNames$1("".concat(classPrefix, "-layout__header"), className);
-    return /* @__PURE__ */React__default["default"].createElement("header", _objectSpread$1X({
+    return /* @__PURE__ */React__default["default"].createElement("header", _objectSpread$1Y({
       className: headerClassNames,
       style: style
     }, others), children);
@@ -404,7 +398,7 @@
         others = _objectWithoutProperties$1(props, _excluded2$2);
 
     var footerClassNames = classNames$1("".concat(classPrefix, "-layout__footer"), className);
-    return /* @__PURE__ */React__default["default"].createElement("footer", _objectSpread$1X({
+    return /* @__PURE__ */React__default["default"].createElement("footer", _objectSpread$1Y({
       className: footerClassNames,
       style: style
     }, others), children);
@@ -420,7 +414,7 @@
         others = _objectWithoutProperties$1(props, _excluded3);
 
     var contentClassNames = classNames$1("".concat(classPrefix, "-layout__content"), className);
-    return /* @__PURE__ */React__default["default"].createElement("main", _objectSpread$1X({
+    return /* @__PURE__ */React__default["default"].createElement("main", _objectSpread$1Y({
       className: contentClassNames,
       style: style
     }, others), children);
@@ -451,7 +445,7 @@
         classPrefix = _useConfig4.classPrefix;
 
     var layoutClassNames = classNames$1("".concat(classPrefix, "-layout"), (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-layout--with-sider"), !!asides.length), _defineProperty$2(_classNames, "".concat(classPrefix, "-layout__direction-").concat(direction), direction), _classNames), className);
-    return /* @__PURE__ */React__default["default"].createElement("div", _objectSpread$1X({
+    return /* @__PURE__ */React__default["default"].createElement("div", _objectSpread$1Y({
       className: layoutClassNames,
       style: style
     }, otherLayoutProps), children);
@@ -478,9 +472,9 @@
 
   var _excluded$s = ["flex", "offset", "order", "pull", "push", "span", "tag", "className", "children", "style"];
 
-  function ownKeys$1W(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+  function ownKeys$1X(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-  function _objectSpread$1W(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1W(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1W(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+  function _objectSpread$1X(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1X(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1X(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
   var calcColPadding = function calcColPadding(gutter, currentSize) {
     var paddingObj = {};
@@ -561,14 +555,14 @@
         sizeObj = sizeProp || {};
       }
 
-      return _objectSpread$1W(_objectSpread$1W({}, acc), {}, (_objectSpread2 = {}, _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-").concat(sizeObj.span), sizeObj.span !== void 0), _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-order-").concat(sizeObj.order), parseInt(sizeObj.order, 10) >= 0), _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-offset-").concat(sizeObj.offset), parseInt(sizeObj.offset, 10) >= 0), _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-push-").concat(sizeObj.push), parseInt(sizeObj.push, 10) >= 0), _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-pull-").concat(sizeObj.pull), parseInt(sizeObj.pull, 10) >= 0), _objectSpread2));
+      return _objectSpread$1X(_objectSpread$1X({}, acc), {}, (_objectSpread2 = {}, _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-").concat(sizeObj.span), sizeObj.span !== void 0), _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-order-").concat(sizeObj.order), parseInt(sizeObj.order, 10) >= 0), _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-offset-").concat(sizeObj.offset), parseInt(sizeObj.offset, 10) >= 0), _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-push-").concat(sizeObj.push), parseInt(sizeObj.push, 10) >= 0), _defineProperty$2(_objectSpread2, "".concat(classPrefix, "-col-").concat(currSize, "-pull-").concat(sizeObj.pull), parseInt(sizeObj.pull, 10) >= 0), _objectSpread2));
     }, {});
     var colClassNames = classNames$1("".concat(classPrefix, "-col"), className, (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-col-").concat(span), span !== void 0), _defineProperty$2(_classNames, "".concat(classPrefix, "-col-offset-").concat(offset), parseInt(offset, 10) >= 0), _defineProperty$2(_classNames, "".concat(classPrefix, "-col-pull-").concat(pull), parseInt(pull, 10) >= 0), _defineProperty$2(_classNames, "".concat(classPrefix, "-col-push-").concat(push), parseInt(push, 10) >= 0), _defineProperty$2(_classNames, "".concat(classPrefix, "-col-order-").concat(order), parseInt(order, 10) >= 0), _classNames), sizeClasses);
 
-    var colStyle = _objectSpread$1W(_objectSpread$1W({}, calcColPadding(rowGutter, rowSize)), propStyle);
+    var colStyle = _objectSpread$1X(_objectSpread$1X({}, calcColPadding(rowGutter, rowSize)), propStyle);
 
     flex && (colStyle.flex = parseFlex(flex));
-    return /*#__PURE__*/React__default["default"].createElement(tag, _objectSpread$1W({
+    return /*#__PURE__*/React__default["default"].createElement(tag, _objectSpread$1X({
       className: colClassNames,
       style: colStyle
     }, otherColProps), children);
@@ -578,9 +572,9 @@
 
   var _excluded$r = ["align", "gutter", "justify", "tag", "style", "className", "children"];
 
-  function ownKeys$1V(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+  function ownKeys$1W(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-  function _objectSpread$1V(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1V(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1V(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+  function _objectSpread$1W(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1W(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1W(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
   var calcSize = function calcSize(width) {
     var size = "xs";
@@ -690,7 +684,7 @@
 
     var rowClassNames = classNames$1("".concat(classPrefix, "-row"), className, (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-row--").concat(justify), true), _defineProperty$2(_classNames, "".concat(classPrefix, "-row--").concat(align), true), _classNames));
 
-    var rowStyle = _objectSpread$1V(_objectSpread$1V({}, calcRowStyle(gutter, size)), propStyle);
+    var rowStyle = _objectSpread$1W(_objectSpread$1W({}, calcRowStyle(gutter, size)), propStyle);
 
     React.useEffect(function () {
       window.addEventListener("resize", updateSize);
@@ -698,7 +692,7 @@
         window.removeEventListener("resize", updateSize);
       };
     });
-    return /*#__PURE__*/React__default["default"].createElement(tag, _objectSpread$1V({
+    return /*#__PURE__*/React__default["default"].createElement(tag, _objectSpread$1W({
       className: rowClassNames,
       style: rowStyle
     }, otherRowProps), React__default["default"].Children.map(children, function (child) {
@@ -1169,54 +1163,61 @@
   });
   Portal$1.displayName = "Portal";
 
-  function ownKeys$1U(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+  function setStyle$1(el, styles) {
+    var keys = Object.keys(styles);
+    keys.forEach(function (key) {
+      el.style[key] = styles[key];
+    });
+  }
 
-  function _objectSpread$1U(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1U(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1U(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+  function ownKeys$1V(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+  function _objectSpread$1V(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1V(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1V(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+  function circleAdapter(circleElem) {
+    var _window, _window$getComputedSt2, _window2, _window2$navigator;
+
+    var basicStyle = {};
+
+    if (!circleElem) {
+      return;
+    }
+
+    var _window$getComputedSt = (_window = window) === null || _window === void 0 ? void 0 : (_window$getComputedSt2 = _window.getComputedStyle) === null || _window$getComputedSt2 === void 0 ? void 0 : _window$getComputedSt2.call(_window, circleElem),
+        color = _window$getComputedSt.color,
+        fontSize = _window$getComputedSt.fontSize;
+
+    var ua = (_window2 = window) === null || _window2 === void 0 ? void 0 : (_window2$navigator = _window2.navigator) === null || _window2$navigator === void 0 ? void 0 : _window2$navigator.userAgent;
+    var isSafari = /Safari/.test(ua) && !/Chrome/.test(ua);
+
+    if (isSafari) {
+      basicStyle = {
+        transformOrigin: "-1px -1px",
+        transform: "scale(".concat(parseInt(fontSize, 10) / 14, ")")
+      };
+    }
+
+    if (color) {
+      var matched = color.match(/[\d.]+/g);
+      var endColor = "rgba(".concat(matched[0], ", ").concat(matched[1], ", ").concat(matched[2], ", 0)");
+      setStyle$1(circleElem, _objectSpread$1V(_objectSpread$1V({}, basicStyle), {}, {
+        background: "conic-gradient(from 90deg at 50% 50%,".concat(endColor, " 0deg, ").concat(color, " 360deg)")
+      }));
+    } else {
+      setStyle$1(circleElem, _objectSpread$1V(_objectSpread$1V({}, basicStyle), {}, {
+        background: ""
+      }));
+    }
+  }
 
   var GradientLoading = function GradientLoading() {
     var _useConfig = useConfig$1(),
         classPrefix = _useConfig.classPrefix;
 
-    var _useState = React.useState({}),
-        _useState2 = _slicedToArray(_useState, 2),
-        styleFromEnv = _useState2[0],
-        setStyleFromEnv = _useState2[1];
-
     var conicRef = React.useRef();
     var gradientClass = "".concat(classPrefix, "-loading__gradient");
     React.useEffect(function () {
       var el = conicRef === null || conicRef === void 0 ? void 0 : conicRef.current;
-      var basicStyle = {};
-
-      if (el) {
-        var _window, _window$navigator;
-
-        var _getComputedStyle = getComputedStyle(el),
-            fontSize = _getComputedStyle.fontSize,
-            color = _getComputedStyle.color;
-
-        var ua = (_window = window) === null || _window === void 0 ? void 0 : (_window$navigator = _window.navigator) === null || _window$navigator === void 0 ? void 0 : _window$navigator.userAgent;
-        var isSafari = /Safari/.test(ua) && !/Chrome/.test(ua);
-
-        if (isSafari) {
-          basicStyle = {
-            transformOrigin: "-1px -1px",
-            transform: "scale(".concat(parseInt(fontSize, 10) / 14, ")")
-          };
-        }
-
-        if (color) {
-          var matched = color.match(/[\d.]+/g);
-          var endColor = "rgba(".concat(matched[0], ", ").concat(matched[1], ", ").concat(matched[2], ", 0)");
-          setStyleFromEnv(_objectSpread$1U(_objectSpread$1U({}, basicStyle), {}, {
-            background: "conic-gradient(from 90deg at 50% 50%,".concat(endColor, " 0deg, ").concat(color, " 360deg)")
-          }));
-        } else {
-          setStyleFromEnv(_objectSpread$1U(_objectSpread$1U({}, basicStyle), {}, {
-            background: ""
-          }));
-        }
-      }
+      circleAdapter(el);
     }, []);
     return /* @__PURE__ */React__default["default"].createElement("svg", {
       className: classNames$1(gradientClass, "".concat(classPrefix, "-icon-loading")),
@@ -1232,11 +1233,14 @@
       height: "12"
     }, /* @__PURE__ */React__default["default"].createElement("div", {
       className: "".concat(gradientClass, "-conic"),
-      style: styleFromEnv,
       ref: conicRef
     })));
   };
 
+  function ownKeys$1U(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+  function _objectSpread$1U(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1U(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1U(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
   var Loading$1 = function Loading(props) {
     var attach = props.attach,
         _props$indicator = props.indicator,
@@ -1258,7 +1262,8 @@
         _props$inheritColor = props.inheritColor,
         inheritColor = _props$inheritColor === void 0 ? false : _props$inheritColor,
         zIndex = props.zIndex,
-        className = props.className;
+        className = props.className,
+        style = props.style;
 
     var _useState = React.useState(delay ? false : loading),
         _useState2 = _slicedToArray(_useState, 2),
@@ -1303,8 +1308,8 @@
         styles["font-size"] = size;
       }
 
-      return styles;
-    }, [size, zIndex]);
+      return style ? _objectSpread$1U(_objectSpread$1U({}, styles), style) : styles;
+    }, [size, zIndex, style]);
     var sizeMap = {
       large: "".concat(classPrefix, "-size-l"),
       small: "".concat(classPrefix, "-size-s"),
@@ -3920,269 +3925,6 @@
 
   var useIsomorphicLayoutEffect = typeof window !== 'undefined' && window.document && window.document.createElement ? React__namespace.useLayoutEffect : React__namespace.useEffect;
 
-  function getBoundingClientRect(element) {
-    var rect = element.getBoundingClientRect();
-    return {
-      width: rect.width,
-      height: rect.height,
-      top: rect.top,
-      right: rect.right,
-      bottom: rect.bottom,
-      left: rect.left,
-      x: rect.left,
-      y: rect.top
-    };
-  }
-
-  /*:: import type { Window } from '../types'; */
-
-  /*:: declare function getWindow(node: Node | Window): Window; */
-  function getWindow(node) {
-    if (node.toString() !== '[object Window]') {
-      var ownerDocument = node.ownerDocument;
-      return ownerDocument ? ownerDocument.defaultView : window;
-    }
-
-    return node;
-  }
-
-  function getWindowScroll(node) {
-    var win = getWindow(node);
-    var scrollLeft = win.pageXOffset;
-    var scrollTop = win.pageYOffset;
-    return {
-      scrollLeft: scrollLeft,
-      scrollTop: scrollTop
-    };
-  }
-
-  /*:: declare function isElement(node: mixed): boolean %checks(node instanceof
-    Element); */
-
-  function isElement(node) {
-    var OwnElement = getWindow(node).Element;
-    return node instanceof OwnElement || node instanceof Element;
-  }
-  /*:: declare function isHTMLElement(node: mixed): boolean %checks(node instanceof
-    HTMLElement); */
-
-
-  function isHTMLElement(node) {
-    var OwnElement = getWindow(node).HTMLElement;
-    return node instanceof OwnElement || node instanceof HTMLElement;
-  }
-
-  function getHTMLElementScroll(element) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-
-  function getNodeScroll(node) {
-    if (node === getWindow(node) || !isHTMLElement(node)) {
-      return getWindowScroll(node);
-    } else {
-      return getHTMLElementScroll(node);
-    }
-  }
-
-  function getNodeName(element) {
-    return element ? (element.nodeName || '').toLowerCase() : null;
-  }
-
-  function getDocumentElement(element) {
-    // $FlowFixMe: assume body is always available
-    return (isElement(element) ? element.ownerDocument : element.document).documentElement;
-  }
-
-  function getWindowScrollBarX(element) {
-    // If <html> has a CSS width greater than the viewport, then this will be
-    // incorrect for RTL.
-    // Popper 1 is broken in this case and never had a bug report so let's assume
-    // it's not an issue. I don't think anyone ever specifies width on <html>
-    // anyway.
-    // Browsers where the left scrollbar doesn't cause an issue report `0` for
-    // this (e.g. Edge 2019, IE11, Safari)
-    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
-  }
-
-  function getComputedStyle$1(element) {
-    return getWindow(element).getComputedStyle(element);
-  }
-
-  function isScrollParent(element) {
-    // Firefox wants us to check `-x` and `-y` variations as well
-    var _getComputedStyle = getComputedStyle$1(element),
-        overflow = _getComputedStyle.overflow,
-        overflowX = _getComputedStyle.overflowX,
-        overflowY = _getComputedStyle.overflowY;
-
-    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
-  }
-
-  // Composite means it takes into account transforms as well as layout.
-
-  function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
-    if (isFixed === void 0) {
-      isFixed = false;
-    }
-
-    var documentElement = getDocumentElement(offsetParent);
-    var rect = getBoundingClientRect(elementOrVirtualElement);
-    var isOffsetParentAnElement = isHTMLElement(offsetParent);
-    var scroll = {
-      scrollLeft: 0,
-      scrollTop: 0
-    };
-    var offsets = {
-      x: 0,
-      y: 0
-    };
-
-    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-      if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
-      isScrollParent(documentElement)) {
-        scroll = getNodeScroll(offsetParent);
-      }
-
-      if (isHTMLElement(offsetParent)) {
-        offsets = getBoundingClientRect(offsetParent);
-        offsets.x += offsetParent.clientLeft;
-        offsets.y += offsetParent.clientTop;
-      } else if (documentElement) {
-        offsets.x = getWindowScrollBarX(documentElement);
-      }
-    }
-
-    return {
-      x: rect.left + scroll.scrollLeft - offsets.x,
-      y: rect.top + scroll.scrollTop - offsets.y,
-      width: rect.width,
-      height: rect.height
-    };
-  }
-
-  // Returns the layout rect of an element relative to its offsetParent. Layout
-  // means it doesn't take into account transforms.
-  function getLayoutRect(element) {
-    return {
-      x: element.offsetLeft,
-      y: element.offsetTop,
-      width: element.offsetWidth,
-      height: element.offsetHeight
-    };
-  }
-
-  function getParentNode(element) {
-    if (getNodeName(element) === 'html') {
-      return element;
-    }
-
-    return (// $FlowFixMe: this is a quicker (but less type safe) way to save quite some bytes from the bundle
-      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
-      element.parentNode || // DOM Element detected
-      // $FlowFixMe: need a better way to handle this...
-      element.host || // ShadowRoot detected
-      // $FlowFixMe: HTMLElement is a Node
-      getDocumentElement(element) // fallback
-
-    );
-  }
-
-  function getScrollParent(node) {
-    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
-      // $FlowFixMe: assume body is always available
-      return node.ownerDocument.body;
-    }
-
-    if (isHTMLElement(node) && isScrollParent(node)) {
-      return node;
-    }
-
-    return getScrollParent(getParentNode(node));
-  }
-
-  /*
-  given a DOM element, return the list of all scroll parents, up the list of ancesors
-  until we get to the top window object. This list is what we attach scroll listeners
-  to, because if any of these parent elements scroll, we'll need to re-calculate the 
-  reference element's position.
-  */
-
-  function listScrollParents(element, list) {
-    if (list === void 0) {
-      list = [];
-    }
-
-    var scrollParent = getScrollParent(element);
-    var isBody = getNodeName(scrollParent) === 'body';
-    var win = getWindow(scrollParent);
-    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
-    var updatedList = list.concat(target);
-    return isBody ? updatedList : // $FlowFixMe: isBody tells us target will be an HTMLElement here
-    updatedList.concat(listScrollParents(getParentNode(target)));
-  }
-
-  function isTableElement(element) {
-    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
-  }
-
-  function getTrueOffsetParent(element) {
-    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
-    getComputedStyle$1(element).position === 'fixed') {
-      return null;
-    }
-
-    var offsetParent = element.offsetParent;
-
-    if (offsetParent) {
-      var html = getDocumentElement(offsetParent);
-
-      if (getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static' && getComputedStyle$1(html).position !== 'static') {
-        return html;
-      }
-    }
-
-    return offsetParent;
-  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
-  // return the containing block
-
-
-  function getContainingBlock(element) {
-    var currentNode = getParentNode(element);
-
-    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
-      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
-      // create a containing block.
-
-      if (css.transform !== 'none' || css.perspective !== 'none' || css.willChange && css.willChange !== 'auto') {
-        return currentNode;
-      } else {
-        currentNode = currentNode.parentNode;
-      }
-    }
-
-    return null;
-  } // Gets the closest ancestor positioned element. Handles some edge cases,
-  // such as table ancestors and cross browser bugs.
-
-
-  function getOffsetParent(element) {
-    var window = getWindow(element);
-    var offsetParent = getTrueOffsetParent(element);
-
-    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
-      offsetParent = getTrueOffsetParent(offsetParent);
-    }
-
-    if (offsetParent && getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static') {
-      return window;
-    }
-
-    return offsetParent || getContainingBlock(element) || window;
-  }
-
   var top = 'top';
   var bottom = 'bottom';
   var right = 'right';
@@ -4215,256 +3957,207 @@
   var afterWrite = 'afterWrite';
   var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
 
-  function order(modifiers) {
-    var map = new Map();
-    var visited = new Set();
-    var result = [];
-    modifiers.forEach(function (modifier) {
-      map.set(modifier.name, modifier);
-    }); // On visiting object, check for its dependencies and visit them recursively
+  function getNodeName(element) {
+    return element ? (element.nodeName || '').toLowerCase() : null;
+  }
 
-    function sort(modifier) {
-      visited.add(modifier.name);
-      var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
-      requires.forEach(function (dep) {
-        if (!visited.has(dep)) {
-          var depModifier = map.get(dep);
+  function getWindow(node) {
+    if (node == null) {
+      return window;
+    }
 
-          if (depModifier) {
-            sort(depModifier);
-          }
-        }
-      });
-      result.push(modifier);
+    if (node.toString() !== '[object Window]') {
+      var ownerDocument = node.ownerDocument;
+      return ownerDocument ? ownerDocument.defaultView || window : window;
     }
 
-    modifiers.forEach(function (modifier) {
-      if (!visited.has(modifier.name)) {
-        // check for visited object
-        sort(modifier);
-      }
-    });
-    return result;
+    return node;
   }
 
-  function orderModifiers(modifiers) {
-    // order based on dependencies
-    var orderedModifiers = order(modifiers); // order based on phase
-
-    return modifierPhases.reduce(function (acc, phase) {
-      return acc.concat(orderedModifiers.filter(function (modifier) {
-        return modifier.phase === phase;
-      }));
-    }, []);
+  function isElement(node) {
+    var OwnElement = getWindow(node).Element;
+    return node instanceof OwnElement || node instanceof Element;
   }
 
-  function debounce$2(fn) {
-    var pending;
-    return function () {
-      if (!pending) {
-        pending = new Promise(function (resolve) {
-          Promise.resolve().then(function () {
-            pending = undefined;
-            resolve(fn());
-          });
-        });
-      }
-
-      return pending;
-    };
+  function isHTMLElement(node) {
+    var OwnElement = getWindow(node).HTMLElement;
+    return node instanceof OwnElement || node instanceof HTMLElement;
   }
 
-  function format(str) {
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
+  function isShadowRoot(node) {
+    // IE 11 has no ShadowRoot
+    if (typeof ShadowRoot === 'undefined') {
+      return false;
     }
 
-    return [].concat(args).reduce(function (p, c) {
-      return p.replace(/%s/, c);
-    }, str);
+    var OwnElement = getWindow(node).ShadowRoot;
+    return node instanceof OwnElement || node instanceof ShadowRoot;
   }
 
-  var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';
-  var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available';
-  var VALID_PROPERTIES = ['name', 'enabled', 'phase', 'fn', 'effect', 'requires', 'options'];
-  function validateModifiers(modifiers) {
-    modifiers.forEach(function (modifier) {
-      Object.keys(modifier).forEach(function (key) {
-        switch (key) {
-          case 'name':
-            if (typeof modifier.name !== 'string') {
-              console.error(format(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', "\"" + String(modifier.name) + "\""));
-            }
-
-            break;
-
-          case 'enabled':
-            if (typeof modifier.enabled !== 'boolean') {
-              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', "\"" + String(modifier.enabled) + "\""));
-            }
-
-          case 'phase':
-            if (modifierPhases.indexOf(modifier.phase) < 0) {
-              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + modifierPhases.join(', '), "\"" + String(modifier.phase) + "\""));
-            }
-
-            break;
+  // and applies them to the HTMLElements such as popper and arrow
 
-          case 'fn':
-            if (typeof modifier.fn !== 'function') {
-              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', "\"" + String(modifier.fn) + "\""));
-            }
+  function applyStyles(_ref) {
+    var state = _ref.state;
+    Object.keys(state.elements).forEach(function (name) {
+      var style = state.styles[name] || {};
+      var attributes = state.attributes[name] || {};
+      var element = state.elements[name]; // arrow is optional + virtual elements
 
-            break;
+      if (!isHTMLElement(element) || !getNodeName(element)) {
+        return;
+      } // Flow doesn't support to extend this property, but it's the most
+      // effective way to apply styles to an HTMLElement
+      // $FlowFixMe[cannot-write]
 
-          case 'effect':
-            if (typeof modifier.effect !== 'function') {
-              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', "\"" + String(modifier.fn) + "\""));
-            }
 
-            break;
+      Object.assign(element.style, style);
+      Object.keys(attributes).forEach(function (name) {
+        var value = attributes[name];
 
-          case 'requires':
-            if (!Array.isArray(modifier.requires)) {
-              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', "\"" + String(modifier.requires) + "\""));
-            }
+        if (value === false) {
+          element.removeAttribute(name);
+        } else {
+          element.setAttribute(name, value === true ? '' : value);
+        }
+      });
+    });
+  }
 
-            break;
+  function effect$2(_ref2) {
+    var state = _ref2.state;
+    var initialStyles = {
+      popper: {
+        position: state.options.strategy,
+        left: '0',
+        top: '0',
+        margin: '0'
+      },
+      arrow: {
+        position: 'absolute'
+      },
+      reference: {}
+    };
+    Object.assign(state.elements.popper.style, initialStyles.popper);
+    state.styles = initialStyles;
 
-          case 'requiresIfExists':
-            if (!Array.isArray(modifier.requiresIfExists)) {
-              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', "\"" + String(modifier.requiresIfExists) + "\""));
-            }
+    if (state.elements.arrow) {
+      Object.assign(state.elements.arrow.style, initialStyles.arrow);
+    }
 
-            break;
+    return function () {
+      Object.keys(state.elements).forEach(function (name) {
+        var element = state.elements[name];
+        var attributes = state.attributes[name] || {};
+        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
 
-          case 'options':
-          case 'data':
-            break;
+        var style = styleProperties.reduce(function (style, property) {
+          style[property] = '';
+          return style;
+        }, {}); // arrow is optional + virtual elements
 
-          default:
-            console.error("PopperJS: an invalid property has been provided to the \"" + modifier.name + "\" modifier, valid properties are " + VALID_PROPERTIES.map(function (s) {
-              return "\"" + s + "\"";
-            }).join(', ') + "; but \"" + key + "\" was provided.");
+        if (!isHTMLElement(element) || !getNodeName(element)) {
+          return;
         }
 
-        modifier.requires && modifier.requires.forEach(function (requirement) {
-          if (modifiers.find(function (mod) {
-            return mod.name === requirement;
-          }) == null) {
-            console.error(format(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement));
-          }
+        Object.assign(element.style, style);
+        Object.keys(attributes).forEach(function (attribute) {
+          element.removeAttribute(attribute);
         });
       });
-    });
-  }
+    };
+  } // eslint-disable-next-line import/no-unused-modules
 
-  function uniqueBy(arr, fn) {
-    var identifiers = new Set();
-    return arr.filter(function (item) {
-      var identifier = fn(item);
 
-      if (!identifiers.has(identifier)) {
-        identifiers.add(identifier);
-        return true;
-      }
-    });
-  }
+  var applyStyles$1 = {
+    name: 'applyStyles',
+    enabled: true,
+    phase: 'write',
+    fn: applyStyles,
+    effect: effect$2,
+    requires: ['computeStyles']
+  };
 
   function getBasePlacement(placement) {
     return placement.split('-')[0];
   }
 
-  function mergeByName(modifiers) {
-    var merged = modifiers.reduce(function (merged, current) {
-      var existing = merged[current.name];
-      merged[current.name] = existing ? Object.assign(Object.assign(Object.assign({}, existing), current), {}, {
-        options: Object.assign(Object.assign({}, existing.options), current.options),
-        data: Object.assign(Object.assign({}, existing.data), current.data)
-      }) : current;
-      return merged;
-    }, {}); // IE11 does not support Object.values
+  var max = Math.max;
+  var min = Math.min;
+  var round = Math.round;
 
-    return Object.keys(merged).map(function (key) {
-      return merged[key];
-    });
-  }
+  function getBoundingClientRect(element, includeScale) {
+    if (includeScale === void 0) {
+      includeScale = false;
+    }
 
-  function getViewportRect(element) {
-    var win = getWindow(element);
-    var html = getDocumentElement(element);
-    var visualViewport = win.visualViewport;
-    var width = html.clientWidth;
-    var height = html.clientHeight;
-    var x = 0;
-    var y = 0; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
-    // can be obscured underneath it.
-    // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
-    // if it isn't open, so if this isn't available, the popper will be detected
-    // to overflow the bottom of the screen too early.
+    var rect = element.getBoundingClientRect();
+    var scaleX = 1;
+    var scaleY = 1;
 
-    if (visualViewport) {
-      width = visualViewport.width;
-      height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
-      // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
-      // errors due to floating point numbers, so we need to check precision.
-      // Safari returns a number <= 0, usually < -1 when pinch-zoomed
-      // Feature detection fails in mobile emulation mode in Chrome.
-      // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
-      // 0.001
-      // Fallback here: "Not Safari" userAgent
+    if (isHTMLElement(element) && includeScale) {
+      var offsetHeight = element.offsetHeight;
+      var offsetWidth = element.offsetWidth; // Do not attempt to divide by 0, otherwise we get `Infinity` as scale
+      // Fallback to 1 in case both values are `0`
 
-      if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
-        x = visualViewport.offsetLeft;
-        y = visualViewport.offsetTop;
+      if (offsetWidth > 0) {
+        scaleX = round(rect.width) / offsetWidth || 1;
+      }
+
+      if (offsetHeight > 0) {
+        scaleY = round(rect.height) / offsetHeight || 1;
       }
     }
 
     return {
-      width: width,
-      height: height,
-      x: x + getWindowScrollBarX(element),
-      y: y
+      width: rect.width / scaleX,
+      height: rect.height / scaleY,
+      top: rect.top / scaleY,
+      right: rect.right / scaleX,
+      bottom: rect.bottom / scaleY,
+      left: rect.left / scaleX,
+      x: rect.left / scaleX,
+      y: rect.top / scaleY
     };
   }
 
-  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
+  // means it doesn't take into account transforms.
 
-  function getDocumentRect(element) {
-    var html = getDocumentElement(element);
-    var winScroll = getWindowScroll(element);
-    var body = element.ownerDocument.body;
-    var width = Math.max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
-    var height = Math.max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
-    var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
-    var y = -winScroll.scrollTop;
+  function getLayoutRect(element) {
+    var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
+    // Fixes https://github.com/popperjs/popper-core/issues/1223
 
-    if (getComputedStyle$1(body || html).direction === 'rtl') {
-      x += Math.max(html.clientWidth, body ? body.clientWidth : 0) - width;
+    var width = element.offsetWidth;
+    var height = element.offsetHeight;
+
+    if (Math.abs(clientRect.width - width) <= 1) {
+      width = clientRect.width;
+    }
+
+    if (Math.abs(clientRect.height - height) <= 1) {
+      height = clientRect.height;
     }
 
     return {
+      x: element.offsetLeft,
+      y: element.offsetTop,
       width: width,
-      height: height,
-      x: x,
-      y: y
+      height: height
     };
   }
 
   function contains(parent, child) {
-    // $FlowFixMe: hasOwnProperty doesn't seem to work in tests
-    var isShadow = Boolean(child.getRootNode && child.getRootNode().host); // First, attempt with faster native method
+    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
 
     if (parent.contains(child)) {
       return true;
     } // then fallback to custom implementation with Shadow DOM support
-    else if (isShadow) {
+    else if (rootNode && isShadowRoot(rootNode)) {
       var next = child;
 
       do {
         if (next && parent.isSameNode(next)) {
           return true;
-        } // $FlowFixMe: need a better way to handle this...
+        } // $FlowFixMe[prop-missing]: need a better way to handle this...
 
 
         next = next.parentNode || next.host;
@@ -4475,142 +4168,105 @@
     return false;
   }
 
-  function rectToClientRect(rect) {
-    return Object.assign(Object.assign({}, rect), {}, {
-      left: rect.x,
-      top: rect.y,
-      right: rect.x + rect.width,
-      bottom: rect.y + rect.height
-    });
+  function getComputedStyle$1(element) {
+    return getWindow(element).getComputedStyle(element);
   }
 
-  function getInnerBoundingClientRect(element) {
-    var rect = getBoundingClientRect(element);
-    rect.top = rect.top + element.clientTop;
-    rect.left = rect.left + element.clientLeft;
-    rect.bottom = rect.top + element.clientHeight;
-    rect.right = rect.left + element.clientWidth;
-    rect.width = element.clientWidth;
-    rect.height = element.clientHeight;
-    rect.x = rect.left;
-    rect.y = rect.top;
-    return rect;
+  function isTableElement(element) {
+    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
   }
 
-  function getClientRectFromMixedType(element, clippingParent) {
-    return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isHTMLElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
-  } // A "clipping parent" is an overflowable container with the characteristic of
-  // clipping (or hiding) overflowing elements with a position different from
-  // `initial`
+  function getDocumentElement(element) {
+    // $FlowFixMe[incompatible-return]: assume body is always available
+    return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
+    element.document) || window.document).documentElement;
+  }
 
+  function getParentNode(element) {
+    if (getNodeName(element) === 'html') {
+      return element;
+    }
 
-  function getClippingParents(element) {
-    var clippingParents = listScrollParents(getParentNode(element));
-    var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
-    var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
+    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
+      // $FlowFixMe[incompatible-return]
+      // $FlowFixMe[prop-missing]
+      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+      element.parentNode || ( // DOM Element detected
+      isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
+      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
+      getDocumentElement(element) // fallback
 
-    if (!isElement(clipperElement)) {
-      return [];
-    } // $FlowFixMe: https://github.com/facebook/flow/issues/1414
+    );
+  }
 
+  function getTrueOffsetParent(element) {
+    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
+    getComputedStyle$1(element).position === 'fixed') {
+      return null;
+    }
 
-    return clippingParents.filter(function (clippingParent) {
-      return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
-    });
-  } // Gets the maximum area that the element is visible in due to any number of
-  // clipping parents
+    return element.offsetParent;
+  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
+  // return the containing block
 
 
-  function getClippingRect(element, boundary, rootBoundary) {
-    var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
-    var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
-    var firstClippingParent = clippingParents[0];
-    var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
-      var rect = getClientRectFromMixedType(element, clippingParent);
-      accRect.top = Math.max(rect.top, accRect.top);
-      accRect.right = Math.min(rect.right, accRect.right);
-      accRect.bottom = Math.min(rect.bottom, accRect.bottom);
-      accRect.left = Math.max(rect.left, accRect.left);
-      return accRect;
-    }, getClientRectFromMixedType(element, firstClippingParent));
-    clippingRect.width = clippingRect.right - clippingRect.left;
-    clippingRect.height = clippingRect.bottom - clippingRect.top;
-    clippingRect.x = clippingRect.left;
-    clippingRect.y = clippingRect.top;
-    return clippingRect;
-  }
+  function getContainingBlock(element) {
+    var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
+    var isIE = navigator.userAgent.indexOf('Trident') !== -1;
 
-  function getVariation(placement) {
-    return placement.split('-')[1];
-  }
+    if (isIE && isHTMLElement(element)) {
+      // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
+      var elementCss = getComputedStyle$1(element);
 
-  function getMainAxisFromPlacement(placement) {
-    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
-  }
+      if (elementCss.position === 'fixed') {
+        return null;
+      }
+    }
 
-  function computeOffsets(_ref) {
-    var reference = _ref.reference,
-        element = _ref.element,
-        placement = _ref.placement;
-    var basePlacement = placement ? getBasePlacement(placement) : null;
-    var variation = placement ? getVariation(placement) : null;
-    var commonX = reference.x + reference.width / 2 - element.width / 2;
-    var commonY = reference.y + reference.height / 2 - element.height / 2;
-    var offsets;
+    var currentNode = getParentNode(element);
 
-    switch (basePlacement) {
-      case top:
-        offsets = {
-          x: commonX,
-          y: reference.y - element.height
-        };
-        break;
+    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
+      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
+      // create a containing block.
+      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
 
-      case bottom:
-        offsets = {
-          x: commonX,
-          y: reference.y + reference.height
-        };
-        break;
+      if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') {
+        return currentNode;
+      } else {
+        currentNode = currentNode.parentNode;
+      }
+    }
 
-      case right:
-        offsets = {
-          x: reference.x + reference.width,
-          y: commonY
-        };
-        break;
+    return null;
+  } // Gets the closest ancestor positioned element. Handles some edge cases,
+  // such as table ancestors and cross browser bugs.
 
-      case left:
-        offsets = {
-          x: reference.x - element.width,
-          y: commonY
-        };
-        break;
 
-      default:
-        offsets = {
-          x: reference.x,
-          y: reference.y
-        };
-    }
+  function getOffsetParent(element) {
+    var window = getWindow(element);
+    var offsetParent = getTrueOffsetParent(element);
 
-    var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
+    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
+      offsetParent = getTrueOffsetParent(offsetParent);
+    }
 
-    if (mainAxis != null) {
-      var len = mainAxis === 'y' ? 'height' : 'width';
+    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) {
+      return window;
+    }
 
-      switch (variation) {
-        case start:
-          offsets[mainAxis] = Math.floor(offsets[mainAxis]) - Math.floor(reference[len] / 2 - element[len] / 2);
-          break;
+    return offsetParent || getContainingBlock(element) || window;
+  }
 
-        case end:
-          offsets[mainAxis] = Math.floor(offsets[mainAxis]) + Math.ceil(reference[len] / 2 - element[len] / 2);
-          break;
-      }
-    }
+  function getMainAxisFromPlacement(placement) {
+    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
+  }
 
-    return offsets;
+  function within(min$1, value, max$1) {
+    return max(min$1, min(value, max$1));
+  }
+  function withinMaxClamp(min, value, max) {
+    var v = within(min, value, max);
+    return v > max ? max : v;
   }
 
   function getFreshSideObject() {
@@ -4623,7 +4279,7 @@
   }
 
   function mergePaddingObject(paddingObject) {
-    return Object.assign(Object.assign({}, getFreshSideObject()), paddingObject);
+    return Object.assign({}, getFreshSideObject(), paddingObject);
   }
 
   function expandToHashMap(value, keys) {
@@ -4633,374 +4289,100 @@
     }, {});
   }
 
-  function detectOverflow(state, options) {
-    if (options === void 0) {
-      options = {};
-    }
+  var toPaddingObject = function toPaddingObject(padding, state) {
+    padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
+      placement: state.placement
+    })) : padding;
+    return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
+  };
 
-    var _options = options,
-        _options$placement = _options.placement,
-        placement = _options$placement === void 0 ? state.placement : _options$placement,
-        _options$boundary = _options.boundary,
-        boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
-        _options$rootBoundary = _options.rootBoundary,
-        rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
-        _options$elementConte = _options.elementContext,
-        elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
-        _options$altBoundary = _options.altBoundary,
-        altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
-        _options$padding = _options.padding,
-        padding = _options$padding === void 0 ? 0 : _options$padding;
-    var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
-    var altContext = elementContext === popper ? reference : popper;
-    var referenceElement = state.elements.reference;
-    var popperRect = state.rects.popper;
-    var element = state.elements[altBoundary ? altContext : elementContext];
-    var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
-    var referenceClientRect = getBoundingClientRect(referenceElement);
-    var popperOffsets = computeOffsets({
-      reference: referenceClientRect,
-      element: popperRect,
-      strategy: 'absolute',
-      placement: placement
-    });
-    var popperClientRect = rectToClientRect(Object.assign(Object.assign({}, popperRect), popperOffsets));
-    var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
-    // 0 or negative = within the clipping rect
+  function arrow(_ref) {
+    var _state$modifiersData$;
 
-    var overflowOffsets = {
-      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
-      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
-      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
-      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
-    };
-    var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
+    var state = _ref.state,
+        name = _ref.name,
+        options = _ref.options;
+    var arrowElement = state.elements.arrow;
+    var popperOffsets = state.modifiersData.popperOffsets;
+    var basePlacement = getBasePlacement(state.placement);
+    var axis = getMainAxisFromPlacement(basePlacement);
+    var isVertical = [left, right].indexOf(basePlacement) >= 0;
+    var len = isVertical ? 'height' : 'width';
 
-    if (elementContext === popper && offsetData) {
-      var offset = offsetData[placement];
-      Object.keys(overflowOffsets).forEach(function (key) {
-        var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
-        var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
-        overflowOffsets[key] += offset[axis] * multiply;
-      });
+    if (!arrowElement || !popperOffsets) {
+      return;
     }
 
-    return overflowOffsets;
-  }
-
-  var INVALID_ELEMENT_ERROR = 'Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.';
-  var INFINITE_LOOP_ERROR = 'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.';
-  var DEFAULT_OPTIONS = {
-    placement: 'bottom',
-    modifiers: [],
-    strategy: 'absolute'
-  };
+    var paddingObject = toPaddingObject(options.padding, state);
+    var arrowRect = getLayoutRect(arrowElement);
+    var minProp = axis === 'y' ? top : left;
+    var maxProp = axis === 'y' ? bottom : right;
+    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
+    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
+    var arrowOffsetParent = getOffsetParent(arrowElement);
+    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
+    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
+    // outside of the popper bounds
 
-  function areValidElements() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
+    var min = paddingObject[minProp];
+    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
+    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
+    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
 
-    return !args.some(function (element) {
-      return !(element && typeof element.getBoundingClientRect === 'function');
-    });
+    var axisProp = axis;
+    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
   }
 
-  function popperGenerator(generatorOptions) {
-    if (generatorOptions === void 0) {
-      generatorOptions = {};
-    }
+  function effect$1(_ref2) {
+    var state = _ref2.state,
+        options = _ref2.options;
+    var _options$element = options.element,
+        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
 
-    var _generatorOptions = generatorOptions,
-        _generatorOptions$def = _generatorOptions.defaultModifiers,
-        defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
-        _generatorOptions$def2 = _generatorOptions.defaultOptions,
-        defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
-    return function createPopper(reference, popper, options) {
-      if (options === void 0) {
-        options = defaultOptions;
-      }
-
-      var state = {
-        placement: 'bottom',
-        orderedModifiers: [],
-        options: Object.assign(Object.assign({}, DEFAULT_OPTIONS), defaultOptions),
-        modifiersData: {},
-        elements: {
-          reference: reference,
-          popper: popper
-        },
-        attributes: {},
-        styles: {}
-      };
-      var effectCleanupFns = [];
-      var isDestroyed = false;
-      var instance = {
-        state: state,
-        setOptions: function setOptions(options) {
-          cleanupModifierEffects();
-          state.options = Object.assign(Object.assign(Object.assign({}, defaultOptions), state.options), options);
-          state.scrollParents = {
-            reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
-            popper: listScrollParents(popper)
-          }; // Orders the modifiers based on their dependencies and `phase`
-          // properties
-
-          var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers
-
-          state.orderedModifiers = orderedModifiers.filter(function (m) {
-            return m.enabled;
-          }); // Validate the provided modifiers so that the consumer will get warned
-          // if one of the modifiers is invalid for any reason
-
-          {
-            var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function (_ref) {
-              var name = _ref.name;
-              return name;
-            });
-            validateModifiers(modifiers);
-
-            if (getBasePlacement(state.options.placement) === auto) {
-              var flipModifier = state.orderedModifiers.find(function (_ref2) {
-                var name = _ref2.name;
-                return name === 'flip';
-              });
-
-              if (!flipModifier) {
-                console.error(['Popper: "auto" placements require the "flip" modifier be', 'present and enabled to work.'].join(' '));
-              }
-            }
-
-            var _getComputedStyle = getComputedStyle$1(popper),
-                marginTop = _getComputedStyle.marginTop,
-                marginRight = _getComputedStyle.marginRight,
-                marginBottom = _getComputedStyle.marginBottom,
-                marginLeft = _getComputedStyle.marginLeft; // We no longer take into account `margins` on the popper, and it can
-            // cause bugs with positioning, so we'll warn the consumer
-
-
-            if ([marginTop, marginRight, marginBottom, marginLeft].some(function (margin) {
-              return parseFloat(margin);
-            })) {
-              console.warn(['Popper: CSS "margin" styles cannot be used to apply padding', 'between the popper and its reference element or boundary.', 'To replicate margin, use the `offset` modifier, as well as', 'the `padding` option in the `preventOverflow` and `flip`', 'modifiers.'].join(' '));
-            }
-          }
-
-          runModifierEffects();
-          return instance.update();
-        },
-        // Sync update – it will always be executed, even if not necessary. This
-        // is useful for low frequency updates where sync behavior simplifies the
-        // logic.
-        // For high frequency updates (e.g. `resize` and `scroll` events), always
-        // prefer the async Popper#update method
-        forceUpdate: function forceUpdate() {
-          if (isDestroyed) {
-            return;
-          }
-
-          var _state$elements = state.elements,
-              reference = _state$elements.reference,
-              popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
-          // anymore
-
-          if (!areValidElements(reference, popper)) {
-            {
-              console.error(INVALID_ELEMENT_ERROR);
-            }
-
-            return;
-          } // Store the reference and popper rects to be read by modifiers
-
-
-          state.rects = {
-            reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
-            popper: getLayoutRect(popper)
-          }; // Modifiers have the ability to reset the current update cycle. The
-          // most common use case for this is the `flip` modifier changing the
-          // placement, which then needs to re-run all the modifiers, because the
-          // logic was previously ran for the previous placement and is therefore
-          // stale/incorrect
-
-          state.reset = false;
-          state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
-          // is filled with the initial data specified by the modifier. This means
-          // it doesn't persist and is fresh on each update.
-          // To ensure persistent data, use `${name}#persistent`
-
-          state.orderedModifiers.forEach(function (modifier) {
-            return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
-          });
-          var __debug_loops__ = 0;
-
-          for (var index = 0; index < state.orderedModifiers.length; index++) {
-            {
-              __debug_loops__ += 1;
-
-              if (__debug_loops__ > 100) {
-                console.error(INFINITE_LOOP_ERROR);
-                break;
-              }
-            }
-
-            if (state.reset === true) {
-              state.reset = false;
-              index = -1;
-              continue;
-            }
-
-            var _state$orderedModifie = state.orderedModifiers[index],
-                fn = _state$orderedModifie.fn,
-                _state$orderedModifie2 = _state$orderedModifie.options,
-                _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
-                name = _state$orderedModifie.name;
+    if (arrowElement == null) {
+      return;
+    } // CSS selector
 
-            if (typeof fn === 'function') {
-              state = fn({
-                state: state,
-                options: _options,
-                name: name,
-                instance: instance
-              }) || state;
-            }
-          }
-        },
-        // Async and optimistically optimized update – it will not be executed if
-        // not necessary (debounced to run at most once-per-tick)
-        update: debounce$2(function () {
-          return new Promise(function (resolve) {
-            instance.forceUpdate();
-            resolve(state);
-          });
-        }),
-        destroy: function destroy() {
-          cleanupModifierEffects();
-          isDestroyed = true;
-        }
-      };
 
-      if (!areValidElements(reference, popper)) {
-        {
-          console.error(INVALID_ELEMENT_ERROR);
-        }
+    if (typeof arrowElement === 'string') {
+      arrowElement = state.elements.popper.querySelector(arrowElement);
 
-        return instance;
+      if (!arrowElement) {
+        return;
       }
+    }
 
-      instance.setOptions(options).then(function (state) {
-        if (!isDestroyed && options.onFirstUpdate) {
-          options.onFirstUpdate(state);
-        }
-      }); // Modifiers have the ability to execute arbitrary code before the first
-      // update cycle runs. They will be executed in the same order as the update
-      // cycle. This is useful when a modifier adds some persistent data that
-      // other modifiers need to use, but the modifier is run after the dependent
-      // one.
-
-      function runModifierEffects() {
-        state.orderedModifiers.forEach(function (_ref3) {
-          var name = _ref3.name,
-              _ref3$options = _ref3.options,
-              options = _ref3$options === void 0 ? {} : _ref3$options,
-              effect = _ref3.effect;
-
-          if (typeof effect === 'function') {
-            var cleanupFn = effect({
-              state: state,
-              name: name,
-              instance: instance,
-              options: options
-            });
-
-            var noopFn = function noopFn() {};
-
-            effectCleanupFns.push(cleanupFn || noopFn);
-          }
-        });
+    {
+      if (!isHTMLElement(arrowElement)) {
+        console.error(['Popper: "arrow" element must be an HTMLElement (not an SVGElement).', 'To use an SVG arrow, wrap it in an HTMLElement that will be used as', 'the arrow.'].join(' '));
       }
+    }
 
-      function cleanupModifierEffects() {
-        effectCleanupFns.forEach(function (fn) {
-          return fn();
-        });
-        effectCleanupFns = [];
+    if (!contains(state.elements.popper, arrowElement)) {
+      {
+        console.error(['Popper: "arrow" modifier\'s `element` must be a child of the popper', 'element.'].join(' '));
       }
 
-      return instance;
-    };
-  }
-
-  var passive = {
-    passive: true
-  };
-
-  function effect$2(_ref) {
-    var state = _ref.state,
-        instance = _ref.instance,
-        options = _ref.options;
-    var _options$scroll = options.scroll,
-        scroll = _options$scroll === void 0 ? true : _options$scroll,
-        _options$resize = options.resize,
-        resize = _options$resize === void 0 ? true : _options$resize;
-    var window = getWindow(state.elements.popper);
-    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
-
-    if (scroll) {
-      scrollParents.forEach(function (scrollParent) {
-        scrollParent.addEventListener('scroll', instance.update, passive);
-      });
-    }
-
-    if (resize) {
-      window.addEventListener('resize', instance.update, passive);
+      return;
     }
 
-    return function () {
-      if (scroll) {
-        scrollParents.forEach(function (scrollParent) {
-          scrollParent.removeEventListener('scroll', instance.update, passive);
-        });
-      }
-
-      if (resize) {
-        window.removeEventListener('resize', instance.update, passive);
-      }
-    };
+    state.elements.arrow = arrowElement;
   } // eslint-disable-next-line import/no-unused-modules
 
 
-  var eventListeners = {
-    name: 'eventListeners',
+  var arrow$1 = {
+    name: 'arrow',
     enabled: true,
-    phase: 'write',
-    fn: function fn() {},
-    effect: effect$2,
-    data: {}
+    phase: 'main',
+    fn: arrow,
+    effect: effect$1,
+    requires: ['popperOffsets'],
+    requiresIfExists: ['preventOverflow']
   };
 
-  function popperOffsets(_ref) {
-    var state = _ref.state,
-        name = _ref.name; // Offsets are the actual position the popper needs to have to be
-    // properly positioned near its reference element
-    // This is the most basic placement, and will be adjusted by
-    // the modifiers in the next step
-
-    state.modifiersData[name] = computeOffsets({
-      reference: state.rects.reference,
-      element: state.rects.popper,
-      strategy: 'absolute',
-      placement: state.placement
-    });
-  } // eslint-disable-next-line import/no-unused-modules
-
-
-  var popperOffsets$1 = {
-    name: 'popperOffsets',
-    enabled: true,
-    phase: 'read',
-    fn: popperOffsets,
-    data: {}
-  };
+  function getVariation(placement) {
+    return placement.split('-')[1];
+  }
 
   var unsetSides = {
     top: 'auto',
@@ -5011,14 +4393,14 @@
   // Zooming can change the DPR, but it seems to report a value that will
   // cleanly divide the values into the appropriate subpixels.
 
-  function roundOffsets(_ref) {
+  function roundOffsetsByDPR(_ref) {
     var x = _ref.x,
         y = _ref.y;
     var win = window;
     var dpr = win.devicePixelRatio || 1;
     return {
-      x: Math.round(x * dpr) / dpr || 0,
-      y: Math.round(y * dpr) / dpr || 0
+      x: round(x * dpr) / dpr || 0,
+      y: round(y * dpr) / dpr || 0
     };
   }
 
@@ -5028,15 +4410,28 @@
     var popper = _ref2.popper,
         popperRect = _ref2.popperRect,
         placement = _ref2.placement,
+        variation = _ref2.variation,
         offsets = _ref2.offsets,
         position = _ref2.position,
         gpuAcceleration = _ref2.gpuAcceleration,
-        adaptive = _ref2.adaptive;
-
-    var _roundOffsets = roundOffsets(offsets),
-        x = _roundOffsets.x,
-        y = _roundOffsets.y;
+        adaptive = _ref2.adaptive,
+        roundOffsets = _ref2.roundOffsets,
+        isFixed = _ref2.isFixed;
+    var _offsets$x = offsets.x,
+        x = _offsets$x === void 0 ? 0 : _offsets$x,
+        _offsets$y = offsets.y,
+        y = _offsets$y === void 0 ? 0 : _offsets$y;
+
+    var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({
+      x: x,
+      y: y
+    }) : {
+      x: x,
+      y: y
+    };
 
+    x = _ref3.x;
+    y = _ref3.y;
     var hasX = offsets.hasOwnProperty('x');
     var hasY = offsets.hasOwnProperty('y');
     var sideX = left;
@@ -5045,23 +4440,34 @@
 
     if (adaptive) {
       var offsetParent = getOffsetParent(popper);
+      var heightProp = 'clientHeight';
+      var widthProp = 'clientWidth';
 
       if (offsetParent === getWindow(popper)) {
         offsetParent = getDocumentElement(popper);
-      } // $FlowFixMe: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
 
-      /*:: offsetParent = (offsetParent: Element); */
+        if (getComputedStyle$1(offsetParent).position !== 'static' && position === 'absolute') {
+          heightProp = 'scrollHeight';
+          widthProp = 'scrollWidth';
+        }
+      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
+
 
+      offsetParent = offsetParent;
 
-      if (placement === top) {
+      if (placement === top || (placement === left || placement === right) && variation === end) {
         sideY = bottom;
-        y -= offsetParent.clientHeight - popperRect.height;
+        var offsetY = isFixed && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing]
+        offsetParent[heightProp];
+        y -= offsetY - popperRect.height;
         y *= gpuAcceleration ? 1 : -1;
       }
 
-      if (placement === left) {
+      if (placement === left || (placement === top || placement === bottom) && variation === end) {
         sideX = right;
-        x -= offsetParent.clientWidth - popperRect.width;
+        var offsetX = isFixed && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing]
+        offsetParent[widthProp];
+        x -= offsetX - popperRect.width;
         x *= gpuAcceleration ? 1 : -1;
       }
     }
@@ -5070,22 +4476,35 @@
       position: position
     }, adaptive && unsetSides);
 
+    var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
+      x: x,
+      y: y
+    }) : {
+      x: x,
+      y: y
+    };
+
+    x = _ref4.x;
+    y = _ref4.y;
+
     if (gpuAcceleration) {
       var _Object$assign;
 
-      return Object.assign(Object.assign({}, commonStyles), {}, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) < 2 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
+      return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
     }
 
-    return Object.assign(Object.assign({}, commonStyles), {}, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
+    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
   }
 
-  function computeStyles(_ref3) {
-    var state = _ref3.state,
-        options = _ref3.options;
+  function computeStyles(_ref5) {
+    var state = _ref5.state,
+        options = _ref5.options;
     var _options$gpuAccelerat = options.gpuAcceleration,
         gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
         _options$adaptive = options.adaptive,
-        adaptive = _options$adaptive === void 0 ? true : _options$adaptive;
+        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
+        _options$roundOffsets = options.roundOffsets,
+        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
 
     {
       var transitionProperty = getComputedStyle$1(state.elements.popper).transitionProperty || '';
@@ -5099,28 +4518,32 @@
 
     var commonStyles = {
       placement: getBasePlacement(state.placement),
+      variation: getVariation(state.placement),
       popper: state.elements.popper,
       popperRect: state.rects.popper,
-      gpuAcceleration: gpuAcceleration
+      gpuAcceleration: gpuAcceleration,
+      isFixed: state.options.strategy === 'fixed'
     };
 
     if (state.modifiersData.popperOffsets != null) {
-      state.styles.popper = Object.assign(Object.assign({}, state.styles.popper), mapToStyles(Object.assign(Object.assign({}, commonStyles), {}, {
+      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
         offsets: state.modifiersData.popperOffsets,
         position: state.options.strategy,
-        adaptive: adaptive
+        adaptive: adaptive,
+        roundOffsets: roundOffsets
       })));
     }
 
     if (state.modifiersData.arrow != null) {
-      state.styles.arrow = Object.assign(Object.assign({}, state.styles.arrow), mapToStyles(Object.assign(Object.assign({}, commonStyles), {}, {
+      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
         offsets: state.modifiersData.arrow,
         position: 'absolute',
-        adaptive: false
+        adaptive: false,
+        roundOffsets: roundOffsets
       })));
     }
 
-    state.attributes.popper = Object.assign(Object.assign({}, state.attributes.popper), {}, {
+    state.attributes.popper = Object.assign({}, state.attributes.popper, {
       'data-popper-placement': state.placement
     });
   } // eslint-disable-next-line import/no-unused-modules
@@ -5134,141 +4557,52 @@
     data: {}
   };
 
-  // and applies them to the HTMLElements such as popper and arrow
-
-  function applyStyles(_ref) {
-    var state = _ref.state;
-    Object.keys(state.elements).forEach(function (name) {
-      var style = state.styles[name] || {};
-      var attributes = state.attributes[name] || {};
-      var element = state.elements[name]; // arrow is optional + virtual elements
-
-      if (!isHTMLElement(element) || !getNodeName(element)) {
-        return;
-      } // Flow doesn't support to extend this property, but it's the most
-      // effective way to apply styles to an HTMLElement
-      // $FlowFixMe
-
+  var passive = {
+    passive: true
+  };
 
-      Object.assign(element.style, style);
-      Object.keys(attributes).forEach(function (name) {
-        var value = attributes[name];
+  function effect(_ref) {
+    var state = _ref.state,
+        instance = _ref.instance,
+        options = _ref.options;
+    var _options$scroll = options.scroll,
+        scroll = _options$scroll === void 0 ? true : _options$scroll,
+        _options$resize = options.resize,
+        resize = _options$resize === void 0 ? true : _options$resize;
+    var window = getWindow(state.elements.popper);
+    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
 
-        if (value === false) {
-          element.removeAttribute(name);
-        } else {
-          element.setAttribute(name, value === true ? '' : value);
-        }
+    if (scroll) {
+      scrollParents.forEach(function (scrollParent) {
+        scrollParent.addEventListener('scroll', instance.update, passive);
       });
-    });
-  }
-
-  function effect$1(_ref2) {
-    var state = _ref2.state;
-    var initialStyles = {
-      popper: {
-        position: state.options.strategy,
-        left: '0',
-        top: '0',
-        margin: '0'
-      },
-      arrow: {
-        position: 'absolute'
-      },
-      reference: {}
-    };
-    Object.assign(state.elements.popper.style, initialStyles.popper);
+    }
 
-    if (state.elements.arrow) {
-      Object.assign(state.elements.arrow.style, initialStyles.arrow);
+    if (resize) {
+      window.addEventListener('resize', instance.update, passive);
     }
 
     return function () {
-      Object.keys(state.elements).forEach(function (name) {
-        var element = state.elements[name];
-        var attributes = state.attributes[name] || {};
-        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
-
-        var style = styleProperties.reduce(function (style, property) {
-          style[property] = '';
-          return style;
-        }, {}); // arrow is optional + virtual elements
-
-        if (!isHTMLElement(element) || !getNodeName(element)) {
-          return;
-        } // Flow doesn't support to extend this property, but it's the most
-        // effective way to apply styles to an HTMLElement
-        // $FlowFixMe
-
-
-        Object.assign(element.style, style);
-        Object.keys(attributes).forEach(function (attribute) {
-          element.removeAttribute(attribute);
+      if (scroll) {
+        scrollParents.forEach(function (scrollParent) {
+          scrollParent.removeEventListener('scroll', instance.update, passive);
         });
-      });
-    };
-  } // eslint-disable-next-line import/no-unused-modules
-
-
-  var applyStyles$1 = {
-    name: 'applyStyles',
-    enabled: true,
-    phase: 'write',
-    fn: applyStyles,
-    effect: effect$1,
-    requires: ['computeStyles']
-  };
-
-  function distanceAndSkiddingToXY(placement, rects, offset) {
-    var basePlacement = getBasePlacement(placement);
-    var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
-
-    var _ref = typeof offset === 'function' ? offset(Object.assign(Object.assign({}, rects), {}, {
-      placement: placement
-    })) : offset,
-        skidding = _ref[0],
-        distance = _ref[1];
+      }
 
-    skidding = skidding || 0;
-    distance = (distance || 0) * invertDistance;
-    return [left, right].indexOf(basePlacement) >= 0 ? {
-      x: distance,
-      y: skidding
-    } : {
-      x: skidding,
-      y: distance
+      if (resize) {
+        window.removeEventListener('resize', instance.update, passive);
+      }
     };
-  }
-
-  function offset(_ref2) {
-    var state = _ref2.state,
-        options = _ref2.options,
-        name = _ref2.name;
-    var _options$offset = options.offset,
-        offset = _options$offset === void 0 ? [0, 0] : _options$offset;
-    var data = placements.reduce(function (acc, placement) {
-      acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
-      return acc;
-    }, {});
-    var _data$state$placement = data[state.placement],
-        x = _data$state$placement.x,
-        y = _data$state$placement.y;
-
-    if (state.modifiersData.popperOffsets != null) {
-      state.modifiersData.popperOffsets.x += x;
-      state.modifiersData.popperOffsets.y += y;
-    }
-
-    state.modifiersData[name] = data;
   } // eslint-disable-next-line import/no-unused-modules
 
 
-  var offset$1 = {
-    name: 'offset',
+  var eventListeners = {
+    name: 'eventListeners',
     enabled: true,
-    phase: 'main',
-    requires: ['popperOffsets'],
-    fn: offset
+    phase: 'write',
+    fn: function fn() {},
+    effect: effect,
+    data: {}
   };
 
   var hash$1 = {
@@ -5293,19 +4627,329 @@
     });
   }
 
-  /*:: type OverflowsMap = { [ComputedPlacement]: number }; */
+  function getWindowScroll(node) {
+    var win = getWindow(node);
+    var scrollLeft = win.pageXOffset;
+    var scrollTop = win.pageYOffset;
+    return {
+      scrollLeft: scrollLeft,
+      scrollTop: scrollTop
+    };
+  }
 
-  /*;; type OverflowsMap = { [key in ComputedPlacement]: number }; */
+  function getWindowScrollBarX(element) {
+    // If <html> has a CSS width greater than the viewport, then this will be
+    // incorrect for RTL.
+    // Popper 1 is broken in this case and never had a bug report so let's assume
+    // it's not an issue. I don't think anyone ever specifies width on <html>
+    // anyway.
+    // Browsers where the left scrollbar doesn't cause an issue report `0` for
+    // this (e.g. Edge 2019, IE11, Safari)
+    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
+  }
 
-  function computeAutoPlacement(state, options) {
-    if (options === void 0) {
-      options = {};
+  function getViewportRect(element) {
+    var win = getWindow(element);
+    var html = getDocumentElement(element);
+    var visualViewport = win.visualViewport;
+    var width = html.clientWidth;
+    var height = html.clientHeight;
+    var x = 0;
+    var y = 0; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
+    // can be obscured underneath it.
+    // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
+    // if it isn't open, so if this isn't available, the popper will be detected
+    // to overflow the bottom of the screen too early.
+
+    if (visualViewport) {
+      width = visualViewport.width;
+      height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
+      // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
+      // errors due to floating point numbers, so we need to check precision.
+      // Safari returns a number <= 0, usually < -1 when pinch-zoomed
+      // Feature detection fails in mobile emulation mode in Chrome.
+      // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
+      // 0.001
+      // Fallback here: "Not Safari" userAgent
+
+      if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+        x = visualViewport.offsetLeft;
+        y = visualViewport.offsetTop;
+      }
     }
 
-    var _options = options,
-        placement = _options.placement,
-        boundary = _options.boundary,
-        rootBoundary = _options.rootBoundary,
+    return {
+      width: width,
+      height: height,
+      x: x + getWindowScrollBarX(element),
+      y: y
+    };
+  }
+
+  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
+
+  function getDocumentRect(element) {
+    var _element$ownerDocumen;
+
+    var html = getDocumentElement(element);
+    var winScroll = getWindowScroll(element);
+    var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
+    var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+    var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+    var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
+    var y = -winScroll.scrollTop;
+
+    if (getComputedStyle$1(body || html).direction === 'rtl') {
+      x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+    }
+
+    return {
+      width: width,
+      height: height,
+      x: x,
+      y: y
+    };
+  }
+
+  function isScrollParent(element) {
+    // Firefox wants us to check `-x` and `-y` variations as well
+    var _getComputedStyle = getComputedStyle$1(element),
+        overflow = _getComputedStyle.overflow,
+        overflowX = _getComputedStyle.overflowX,
+        overflowY = _getComputedStyle.overflowY;
+
+    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+  }
+
+  function getScrollParent(node) {
+    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
+      // $FlowFixMe[incompatible-return]: assume body is always available
+      return node.ownerDocument.body;
+    }
+
+    if (isHTMLElement(node) && isScrollParent(node)) {
+      return node;
+    }
+
+    return getScrollParent(getParentNode(node));
+  }
+
+  /*
+  given a DOM element, return the list of all scroll parents, up the list of ancesors
+  until we get to the top window object. This list is what we attach scroll listeners
+  to, because if any of these parent elements scroll, we'll need to re-calculate the
+  reference element's position.
+  */
+
+  function listScrollParents(element, list) {
+    var _element$ownerDocumen;
+
+    if (list === void 0) {
+      list = [];
+    }
+
+    var scrollParent = getScrollParent(element);
+    var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
+    var win = getWindow(scrollParent);
+    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
+    var updatedList = list.concat(target);
+    return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
+    updatedList.concat(listScrollParents(getParentNode(target)));
+  }
+
+  function rectToClientRect(rect) {
+    return Object.assign({}, rect, {
+      left: rect.x,
+      top: rect.y,
+      right: rect.x + rect.width,
+      bottom: rect.y + rect.height
+    });
+  }
+
+  function getInnerBoundingClientRect(element) {
+    var rect = getBoundingClientRect(element);
+    rect.top = rect.top + element.clientTop;
+    rect.left = rect.left + element.clientLeft;
+    rect.bottom = rect.top + element.clientHeight;
+    rect.right = rect.left + element.clientWidth;
+    rect.width = element.clientWidth;
+    rect.height = element.clientHeight;
+    rect.x = rect.left;
+    rect.y = rect.top;
+    return rect;
+  }
+
+  function getClientRectFromMixedType(element, clippingParent) {
+    return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
+  } // A "clipping parent" is an overflowable container with the characteristic of
+  // clipping (or hiding) overflowing elements with a position different from
+  // `initial`
+
+
+  function getClippingParents(element) {
+    var clippingParents = listScrollParents(getParentNode(element));
+    var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
+    var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
+
+    if (!isElement(clipperElement)) {
+      return [];
+    } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
+
+
+    return clippingParents.filter(function (clippingParent) {
+      return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
+    });
+  } // Gets the maximum area that the element is visible in due to any number of
+  // clipping parents
+
+
+  function getClippingRect(element, boundary, rootBoundary) {
+    var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
+    var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
+    var firstClippingParent = clippingParents[0];
+    var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
+      var rect = getClientRectFromMixedType(element, clippingParent);
+      accRect.top = max(rect.top, accRect.top);
+      accRect.right = min(rect.right, accRect.right);
+      accRect.bottom = min(rect.bottom, accRect.bottom);
+      accRect.left = max(rect.left, accRect.left);
+      return accRect;
+    }, getClientRectFromMixedType(element, firstClippingParent));
+    clippingRect.width = clippingRect.right - clippingRect.left;
+    clippingRect.height = clippingRect.bottom - clippingRect.top;
+    clippingRect.x = clippingRect.left;
+    clippingRect.y = clippingRect.top;
+    return clippingRect;
+  }
+
+  function computeOffsets(_ref) {
+    var reference = _ref.reference,
+        element = _ref.element,
+        placement = _ref.placement;
+    var basePlacement = placement ? getBasePlacement(placement) : null;
+    var variation = placement ? getVariation(placement) : null;
+    var commonX = reference.x + reference.width / 2 - element.width / 2;
+    var commonY = reference.y + reference.height / 2 - element.height / 2;
+    var offsets;
+
+    switch (basePlacement) {
+      case top:
+        offsets = {
+          x: commonX,
+          y: reference.y - element.height
+        };
+        break;
+
+      case bottom:
+        offsets = {
+          x: commonX,
+          y: reference.y + reference.height
+        };
+        break;
+
+      case right:
+        offsets = {
+          x: reference.x + reference.width,
+          y: commonY
+        };
+        break;
+
+      case left:
+        offsets = {
+          x: reference.x - element.width,
+          y: commonY
+        };
+        break;
+
+      default:
+        offsets = {
+          x: reference.x,
+          y: reference.y
+        };
+    }
+
+    var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
+
+    if (mainAxis != null) {
+      var len = mainAxis === 'y' ? 'height' : 'width';
+
+      switch (variation) {
+        case start:
+          offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
+          break;
+
+        case end:
+          offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
+          break;
+      }
+    }
+
+    return offsets;
+  }
+
+  function detectOverflow(state, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    var _options = options,
+        _options$placement = _options.placement,
+        placement = _options$placement === void 0 ? state.placement : _options$placement,
+        _options$boundary = _options.boundary,
+        boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
+        _options$rootBoundary = _options.rootBoundary,
+        rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
+        _options$elementConte = _options.elementContext,
+        elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
+        _options$altBoundary = _options.altBoundary,
+        altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
+        _options$padding = _options.padding,
+        padding = _options$padding === void 0 ? 0 : _options$padding;
+    var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
+    var altContext = elementContext === popper ? reference : popper;
+    var popperRect = state.rects.popper;
+    var element = state.elements[altBoundary ? altContext : elementContext];
+    var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
+    var referenceClientRect = getBoundingClientRect(state.elements.reference);
+    var popperOffsets = computeOffsets({
+      reference: referenceClientRect,
+      element: popperRect,
+      strategy: 'absolute',
+      placement: placement
+    });
+    var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
+    var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
+    // 0 or negative = within the clipping rect
+
+    var overflowOffsets = {
+      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
+      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
+      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
+      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
+    };
+    var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
+
+    if (elementContext === popper && offsetData) {
+      var offset = offsetData[placement];
+      Object.keys(overflowOffsets).forEach(function (key) {
+        var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
+        var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
+        overflowOffsets[key] += offset[axis] * multiply;
+      });
+    }
+
+    return overflowOffsets;
+  }
+
+  function computeAutoPlacement(state, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    var _options = options,
+        placement = _options.placement,
+        boundary = _options.boundary,
+        rootBoundary = _options.rootBoundary,
         padding = _options.padding,
         flipVariations = _options.flipVariations,
         _options$allowedAutoP = _options.allowedAutoPlacements,
@@ -5313,8 +4957,7 @@
     var variation = getVariation(placement);
     var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {
       return getVariation(placement) === variation;
-    }) : basePlacements; // $FlowFixMe
-
+    }) : basePlacements;
     var allowedPlacements = placements$1.filter(function (placement) {
       return allowedAutoPlacements.indexOf(placement) >= 0;
     });
@@ -5325,7 +4968,7 @@
       {
         console.error(['Popper: The `allowedAutoPlacements` option did not allow any', 'placements. Ensure the `placement` option matches the variation', 'of the allowed placements.', 'For example, "auto" cannot be used to allow "bottom-start".', 'Use "auto-start" instead.'].join(' '));
       }
-    } // $FlowFixMe: Flow seems to have problems with two array unions...
+    } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
 
 
     var overflows = allowedPlacements.reduce(function (acc, placement) {
@@ -5409,344 +5052,833 @@
       });
       var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
 
-      if (referenceRect[len] > popperRect[len]) {
-        mainVariationSide = getOppositePlacement(mainVariationSide);
-      }
+      if (referenceRect[len] > popperRect[len]) {
+        mainVariationSide = getOppositePlacement(mainVariationSide);
+      }
+
+      var altVariationSide = getOppositePlacement(mainVariationSide);
+      var checks = [];
+
+      if (checkMainAxis) {
+        checks.push(overflow[_basePlacement] <= 0);
+      }
+
+      if (checkAltAxis) {
+        checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
+      }
+
+      if (checks.every(function (check) {
+        return check;
+      })) {
+        firstFittingPlacement = placement;
+        makeFallbackChecks = false;
+        break;
+      }
+
+      checksMap.set(placement, checks);
+    }
+
+    if (makeFallbackChecks) {
+      // `2` may be desired in some cases – research later
+      var numberOfChecks = flipVariations ? 3 : 1;
+
+      var _loop = function _loop(_i) {
+        var fittingPlacement = placements.find(function (placement) {
+          var checks = checksMap.get(placement);
+
+          if (checks) {
+            return checks.slice(0, _i).every(function (check) {
+              return check;
+            });
+          }
+        });
+
+        if (fittingPlacement) {
+          firstFittingPlacement = fittingPlacement;
+          return "break";
+        }
+      };
+
+      for (var _i = numberOfChecks; _i > 0; _i--) {
+        var _ret = _loop(_i);
+
+        if (_ret === "break") break;
+      }
+    }
+
+    if (state.placement !== firstFittingPlacement) {
+      state.modifiersData[name]._skip = true;
+      state.placement = firstFittingPlacement;
+      state.reset = true;
+    }
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var flip$1 = {
+    name: 'flip',
+    enabled: true,
+    phase: 'main',
+    fn: flip,
+    requiresIfExists: ['offset'],
+    data: {
+      _skip: false
+    }
+  };
+
+  function getSideOffsets(overflow, rect, preventedOffsets) {
+    if (preventedOffsets === void 0) {
+      preventedOffsets = {
+        x: 0,
+        y: 0
+      };
+    }
+
+    return {
+      top: overflow.top - rect.height - preventedOffsets.y,
+      right: overflow.right - rect.width + preventedOffsets.x,
+      bottom: overflow.bottom - rect.height + preventedOffsets.y,
+      left: overflow.left - rect.width - preventedOffsets.x
+    };
+  }
+
+  function isAnySideFullyClipped(overflow) {
+    return [top, right, bottom, left].some(function (side) {
+      return overflow[side] >= 0;
+    });
+  }
+
+  function hide(_ref) {
+    var state = _ref.state,
+        name = _ref.name;
+    var referenceRect = state.rects.reference;
+    var popperRect = state.rects.popper;
+    var preventedOffsets = state.modifiersData.preventOverflow;
+    var referenceOverflow = detectOverflow(state, {
+      elementContext: 'reference'
+    });
+    var popperAltOverflow = detectOverflow(state, {
+      altBoundary: true
+    });
+    var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
+    var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
+    var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
+    var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
+    state.modifiersData[name] = {
+      referenceClippingOffsets: referenceClippingOffsets,
+      popperEscapeOffsets: popperEscapeOffsets,
+      isReferenceHidden: isReferenceHidden,
+      hasPopperEscaped: hasPopperEscaped
+    };
+    state.attributes.popper = Object.assign({}, state.attributes.popper, {
+      'data-popper-reference-hidden': isReferenceHidden,
+      'data-popper-escaped': hasPopperEscaped
+    });
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var hide$1 = {
+    name: 'hide',
+    enabled: true,
+    phase: 'main',
+    requiresIfExists: ['preventOverflow'],
+    fn: hide
+  };
+
+  function distanceAndSkiddingToXY(placement, rects, offset) {
+    var basePlacement = getBasePlacement(placement);
+    var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
+
+    var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {
+      placement: placement
+    })) : offset,
+        skidding = _ref[0],
+        distance = _ref[1];
+
+    skidding = skidding || 0;
+    distance = (distance || 0) * invertDistance;
+    return [left, right].indexOf(basePlacement) >= 0 ? {
+      x: distance,
+      y: skidding
+    } : {
+      x: skidding,
+      y: distance
+    };
+  }
+
+  function offset(_ref2) {
+    var state = _ref2.state,
+        options = _ref2.options,
+        name = _ref2.name;
+    var _options$offset = options.offset,
+        offset = _options$offset === void 0 ? [0, 0] : _options$offset;
+    var data = placements.reduce(function (acc, placement) {
+      acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
+      return acc;
+    }, {});
+    var _data$state$placement = data[state.placement],
+        x = _data$state$placement.x,
+        y = _data$state$placement.y;
+
+    if (state.modifiersData.popperOffsets != null) {
+      state.modifiersData.popperOffsets.x += x;
+      state.modifiersData.popperOffsets.y += y;
+    }
+
+    state.modifiersData[name] = data;
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var offset$1 = {
+    name: 'offset',
+    enabled: true,
+    phase: 'main',
+    requires: ['popperOffsets'],
+    fn: offset
+  };
+
+  function popperOffsets(_ref) {
+    var state = _ref.state,
+        name = _ref.name; // Offsets are the actual position the popper needs to have to be
+    // properly positioned near its reference element
+    // This is the most basic placement, and will be adjusted by
+    // the modifiers in the next step
+
+    state.modifiersData[name] = computeOffsets({
+      reference: state.rects.reference,
+      element: state.rects.popper,
+      strategy: 'absolute',
+      placement: state.placement
+    });
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var popperOffsets$1 = {
+    name: 'popperOffsets',
+    enabled: true,
+    phase: 'read',
+    fn: popperOffsets,
+    data: {}
+  };
+
+  function getAltAxis(axis) {
+    return axis === 'x' ? 'y' : 'x';
+  }
+
+  function preventOverflow(_ref) {
+    var state = _ref.state,
+        options = _ref.options,
+        name = _ref.name;
+    var _options$mainAxis = options.mainAxis,
+        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
+        _options$altAxis = options.altAxis,
+        checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,
+        boundary = options.boundary,
+        rootBoundary = options.rootBoundary,
+        altBoundary = options.altBoundary,
+        padding = options.padding,
+        _options$tether = options.tether,
+        tether = _options$tether === void 0 ? true : _options$tether,
+        _options$tetherOffset = options.tetherOffset,
+        tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
+    var overflow = detectOverflow(state, {
+      boundary: boundary,
+      rootBoundary: rootBoundary,
+      padding: padding,
+      altBoundary: altBoundary
+    });
+    var basePlacement = getBasePlacement(state.placement);
+    var variation = getVariation(state.placement);
+    var isBasePlacement = !variation;
+    var mainAxis = getMainAxisFromPlacement(basePlacement);
+    var altAxis = getAltAxis(mainAxis);
+    var popperOffsets = state.modifiersData.popperOffsets;
+    var referenceRect = state.rects.reference;
+    var popperRect = state.rects.popper;
+    var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, {
+      placement: state.placement
+    })) : tetherOffset;
+    var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? {
+      mainAxis: tetherOffsetValue,
+      altAxis: tetherOffsetValue
+    } : Object.assign({
+      mainAxis: 0,
+      altAxis: 0
+    }, tetherOffsetValue);
+    var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
+    var data = {
+      x: 0,
+      y: 0
+    };
+
+    if (!popperOffsets) {
+      return;
+    }
+
+    if (checkMainAxis) {
+      var _offsetModifierState$;
+
+      var mainSide = mainAxis === 'y' ? top : left;
+      var altSide = mainAxis === 'y' ? bottom : right;
+      var len = mainAxis === 'y' ? 'height' : 'width';
+      var offset = popperOffsets[mainAxis];
+      var min$1 = offset + overflow[mainSide];
+      var max$1 = offset - overflow[altSide];
+      var additive = tether ? -popperRect[len] / 2 : 0;
+      var minLen = variation === start ? referenceRect[len] : popperRect[len];
+      var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go
+      // outside the reference bounds
+
+      var arrowElement = state.elements.arrow;
+      var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
+        width: 0,
+        height: 0
+      };
+      var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();
+      var arrowPaddingMin = arrowPaddingObject[mainSide];
+      var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want
+      // to include its full size in the calculation. If the reference is small
+      // and near the edge of a boundary, the popper can overflow even if the
+      // reference is not overflowing as well (e.g. virtual elements with no
+      // width or height)
+
+      var arrowLen = within(0, referenceRect[len], arrowRect[len]);
+      var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
+      var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
+      var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
+      var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
+      var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
+      var tetherMin = offset + minOffset - offsetModifierValue - clientOffset;
+      var tetherMax = offset + maxOffset - offsetModifierValue;
+      var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1);
+      popperOffsets[mainAxis] = preventedOffset;
+      data[mainAxis] = preventedOffset - offset;
+    }
+
+    if (checkAltAxis) {
+      var _offsetModifierState$2;
+
+      var _mainSide = mainAxis === 'x' ? top : left;
+
+      var _altSide = mainAxis === 'x' ? bottom : right;
+
+      var _offset = popperOffsets[altAxis];
+
+      var _len = altAxis === 'y' ? 'height' : 'width';
+
+      var _min = _offset + overflow[_mainSide];
+
+      var _max = _offset - overflow[_altSide];
+
+      var isOriginSide = [top, left].indexOf(basePlacement) !== -1;
+
+      var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
+
+      var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
+
+      var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
+
+      var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
+
+      popperOffsets[altAxis] = _preventedOffset;
+      data[altAxis] = _preventedOffset - _offset;
+    }
+
+    state.modifiersData[name] = data;
+  } // eslint-disable-next-line import/no-unused-modules
+
+
+  var preventOverflow$1 = {
+    name: 'preventOverflow',
+    enabled: true,
+    phase: 'main',
+    fn: preventOverflow,
+    requiresIfExists: ['offset']
+  };
+
+  function getHTMLElementScroll(element) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+
+  function getNodeScroll(node) {
+    if (node === getWindow(node) || !isHTMLElement(node)) {
+      return getWindowScroll(node);
+    } else {
+      return getHTMLElementScroll(node);
+    }
+  }
+
+  function isElementScaled(element) {
+    var rect = element.getBoundingClientRect();
+    var scaleX = round(rect.width) / element.offsetWidth || 1;
+    var scaleY = round(rect.height) / element.offsetHeight || 1;
+    return scaleX !== 1 || scaleY !== 1;
+  } // Returns the composite rect of an element relative to its offsetParent.
+  // Composite means it takes into account transforms as well as layout.
+
+
+  function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
+    if (isFixed === void 0) {
+      isFixed = false;
+    }
+
+    var isOffsetParentAnElement = isHTMLElement(offsetParent);
+    var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
+    var documentElement = getDocumentElement(offsetParent);
+    var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled);
+    var scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    var offsets = {
+      x: 0,
+      y: 0
+    };
+
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+      if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
+      isScrollParent(documentElement)) {
+        scroll = getNodeScroll(offsetParent);
+      }
+
+      if (isHTMLElement(offsetParent)) {
+        offsets = getBoundingClientRect(offsetParent, true);
+        offsets.x += offsetParent.clientLeft;
+        offsets.y += offsetParent.clientTop;
+      } else if (documentElement) {
+        offsets.x = getWindowScrollBarX(documentElement);
+      }
+    }
+
+    return {
+      x: rect.left + scroll.scrollLeft - offsets.x,
+      y: rect.top + scroll.scrollTop - offsets.y,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+
+  function order(modifiers) {
+    var map = new Map();
+    var visited = new Set();
+    var result = [];
+    modifiers.forEach(function (modifier) {
+      map.set(modifier.name, modifier);
+    }); // On visiting object, check for its dependencies and visit them recursively
+
+    function sort(modifier) {
+      visited.add(modifier.name);
+      var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
+      requires.forEach(function (dep) {
+        if (!visited.has(dep)) {
+          var depModifier = map.get(dep);
+
+          if (depModifier) {
+            sort(depModifier);
+          }
+        }
+      });
+      result.push(modifier);
+    }
+
+    modifiers.forEach(function (modifier) {
+      if (!visited.has(modifier.name)) {
+        // check for visited object
+        sort(modifier);
+      }
+    });
+    return result;
+  }
+
+  function orderModifiers(modifiers) {
+    // order based on dependencies
+    var orderedModifiers = order(modifiers); // order based on phase
+
+    return modifierPhases.reduce(function (acc, phase) {
+      return acc.concat(orderedModifiers.filter(function (modifier) {
+        return modifier.phase === phase;
+      }));
+    }, []);
+  }
+
+  function debounce$2(fn) {
+    var pending;
+    return function () {
+      if (!pending) {
+        pending = new Promise(function (resolve) {
+          Promise.resolve().then(function () {
+            pending = undefined;
+            resolve(fn());
+          });
+        });
+      }
+
+      return pending;
+    };
+  }
+
+  function format(str) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    return [].concat(args).reduce(function (p, c) {
+      return p.replace(/%s/, c);
+    }, str);
+  }
+
+  var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';
+  var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available';
+  var VALID_PROPERTIES = ['name', 'enabled', 'phase', 'fn', 'effect', 'requires', 'options'];
+  function validateModifiers(modifiers) {
+    modifiers.forEach(function (modifier) {
+      [].concat(Object.keys(modifier), VALID_PROPERTIES) // IE11-compatible replacement for `new Set(iterable)`
+      .filter(function (value, index, self) {
+        return self.indexOf(value) === index;
+      }).forEach(function (key) {
+        switch (key) {
+          case 'name':
+            if (typeof modifier.name !== 'string') {
+              console.error(format(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', "\"" + String(modifier.name) + "\""));
+            }
+
+            break;
+
+          case 'enabled':
+            if (typeof modifier.enabled !== 'boolean') {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', "\"" + String(modifier.enabled) + "\""));
+            }
+
+            break;
+
+          case 'phase':
+            if (modifierPhases.indexOf(modifier.phase) < 0) {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + modifierPhases.join(', '), "\"" + String(modifier.phase) + "\""));
+            }
+
+            break;
+
+          case 'fn':
+            if (typeof modifier.fn !== 'function') {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', "\"" + String(modifier.fn) + "\""));
+            }
+
+            break;
+
+          case 'effect':
+            if (modifier.effect != null && typeof modifier.effect !== 'function') {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', "\"" + String(modifier.fn) + "\""));
+            }
 
-      var altVariationSide = getOppositePlacement(mainVariationSide);
-      var checks = [];
+            break;
 
-      if (checkMainAxis) {
-        checks.push(overflow[_basePlacement] <= 0);
-      }
+          case 'requires':
+            if (modifier.requires != null && !Array.isArray(modifier.requires)) {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', "\"" + String(modifier.requires) + "\""));
+            }
 
-      if (checkAltAxis) {
-        checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
-      }
+            break;
 
-      if (checks.every(function (check) {
-        return check;
-      })) {
-        firstFittingPlacement = placement;
-        makeFallbackChecks = false;
-        break;
-      }
+          case 'requiresIfExists':
+            if (!Array.isArray(modifier.requiresIfExists)) {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', "\"" + String(modifier.requiresIfExists) + "\""));
+            }
 
-      checksMap.set(placement, checks);
-    }
+            break;
 
-    if (makeFallbackChecks) {
-      // `2` may be desired in some cases – research later
-      var numberOfChecks = flipVariations ? 3 : 1;
+          case 'options':
+          case 'data':
+            break;
 
-      var _loop = function _loop(_i) {
-        var fittingPlacement = placements.find(function (placement) {
-          var checks = checksMap.get(placement);
+          default:
+            console.error("PopperJS: an invalid property has been provided to the \"" + modifier.name + "\" modifier, valid properties are " + VALID_PROPERTIES.map(function (s) {
+              return "\"" + s + "\"";
+            }).join(', ') + "; but \"" + key + "\" was provided.");
+        }
 
-          if (checks) {
-            return checks.slice(0, _i).every(function (check) {
-              return check;
-            });
+        modifier.requires && modifier.requires.forEach(function (requirement) {
+          if (modifiers.find(function (mod) {
+            return mod.name === requirement;
+          }) == null) {
+            console.error(format(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement));
           }
         });
+      });
+    });
+  }
 
-        if (fittingPlacement) {
-          firstFittingPlacement = fittingPlacement;
-          return "break";
-        }
-      };
-
-      for (var _i = numberOfChecks; _i > 0; _i--) {
-        var _ret = _loop(_i);
+  function uniqueBy(arr, fn) {
+    var identifiers = new Set();
+    return arr.filter(function (item) {
+      var identifier = fn(item);
 
-        if (_ret === "break") break;
+      if (!identifiers.has(identifier)) {
+        identifiers.add(identifier);
+        return true;
       }
-    }
+    });
+  }
 
-    if (state.placement !== firstFittingPlacement) {
-      state.modifiersData[name]._skip = true;
-      state.placement = firstFittingPlacement;
-      state.reset = true;
-    }
-  } // eslint-disable-next-line import/no-unused-modules
+  function mergeByName(modifiers) {
+    var merged = modifiers.reduce(function (merged, current) {
+      var existing = merged[current.name];
+      merged[current.name] = existing ? Object.assign({}, existing, current, {
+        options: Object.assign({}, existing.options, current.options),
+        data: Object.assign({}, existing.data, current.data)
+      }) : current;
+      return merged;
+    }, {}); // IE11 does not support Object.values
 
+    return Object.keys(merged).map(function (key) {
+      return merged[key];
+    });
+  }
 
-  var flip$1 = {
-    name: 'flip',
-    enabled: true,
-    phase: 'main',
-    fn: flip,
-    requiresIfExists: ['offset'],
-    data: {
-      _skip: false
-    }
+  var INVALID_ELEMENT_ERROR = 'Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.';
+  var INFINITE_LOOP_ERROR = 'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.';
+  var DEFAULT_OPTIONS = {
+    placement: 'bottom',
+    modifiers: [],
+    strategy: 'absolute'
   };
 
-  function getAltAxis(axis) {
-    return axis === 'x' ? 'y' : 'x';
-  }
-
-  function within(min, value, max) {
-    return Math.max(min, Math.min(value, max));
-  }
+  function areValidElements() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
 
-  function preventOverflow(_ref) {
-    var state = _ref.state,
-        options = _ref.options,
-        name = _ref.name;
-    var _options$mainAxis = options.mainAxis,
-        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
-        _options$altAxis = options.altAxis,
-        checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,
-        boundary = options.boundary,
-        rootBoundary = options.rootBoundary,
-        altBoundary = options.altBoundary,
-        padding = options.padding,
-        _options$tether = options.tether,
-        tether = _options$tether === void 0 ? true : _options$tether,
-        _options$tetherOffset = options.tetherOffset,
-        tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
-    var overflow = detectOverflow(state, {
-      boundary: boundary,
-      rootBoundary: rootBoundary,
-      padding: padding,
-      altBoundary: altBoundary
+    return !args.some(function (element) {
+      return !(element && typeof element.getBoundingClientRect === 'function');
     });
-    var basePlacement = getBasePlacement(state.placement);
-    var variation = getVariation(state.placement);
-    var isBasePlacement = !variation;
-    var mainAxis = getMainAxisFromPlacement(basePlacement);
-    var altAxis = getAltAxis(mainAxis);
-    var popperOffsets = state.modifiersData.popperOffsets;
-    var referenceRect = state.rects.reference;
-    var popperRect = state.rects.popper;
-    var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign(Object.assign({}, state.rects), {}, {
-      placement: state.placement
-    })) : tetherOffset;
-    var data = {
-      x: 0,
-      y: 0
-    };
+  }
 
-    if (!popperOffsets) {
-      return;
+  function popperGenerator(generatorOptions) {
+    if (generatorOptions === void 0) {
+      generatorOptions = {};
     }
 
-    if (checkMainAxis) {
-      var mainSide = mainAxis === 'y' ? top : left;
-      var altSide = mainAxis === 'y' ? bottom : right;
-      var len = mainAxis === 'y' ? 'height' : 'width';
-      var offset = popperOffsets[mainAxis];
-      var min = popperOffsets[mainAxis] + overflow[mainSide];
-      var max = popperOffsets[mainAxis] - overflow[altSide];
-      var additive = tether ? -popperRect[len] / 2 : 0;
-      var minLen = variation === start ? referenceRect[len] : popperRect[len];
-      var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go
-      // outside the reference bounds
+    var _generatorOptions = generatorOptions,
+        _generatorOptions$def = _generatorOptions.defaultModifiers,
+        defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
+        _generatorOptions$def2 = _generatorOptions.defaultOptions,
+        defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
+    return function createPopper(reference, popper, options) {
+      if (options === void 0) {
+        options = defaultOptions;
+      }
 
-      var arrowElement = state.elements.arrow;
-      var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
-        width: 0,
-        height: 0
+      var state = {
+        placement: 'bottom',
+        orderedModifiers: [],
+        options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
+        modifiersData: {},
+        elements: {
+          reference: reference,
+          popper: popper
+        },
+        attributes: {},
+        styles: {}
       };
-      var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();
-      var arrowPaddingMin = arrowPaddingObject[mainSide];
-      var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want
-      // to include its full size in the calculation. If the reference is small
-      // and near the edge of a boundary, the popper can overflow even if the
-      // reference is not overflowing as well (e.g. virtual elements with no
-      // width or height)
+      var effectCleanupFns = [];
+      var isDestroyed = false;
+      var instance = {
+        state: state,
+        setOptions: function setOptions(setOptionsAction) {
+          var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction;
+          cleanupModifierEffects();
+          state.options = Object.assign({}, defaultOptions, state.options, options);
+          state.scrollParents = {
+            reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
+            popper: listScrollParents(popper)
+          }; // Orders the modifiers based on their dependencies and `phase`
+          // properties
 
-      var arrowLen = within(0, referenceRect[len], arrowRect[len]);
-      var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue;
-      var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue;
-      var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
-      var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
-      var offsetModifierValue = state.modifiersData.offset ? state.modifiersData.offset[state.placement][mainAxis] : 0;
-      var tetherMin = popperOffsets[mainAxis] + minOffset - offsetModifierValue - clientOffset;
-      var tetherMax = popperOffsets[mainAxis] + maxOffset - offsetModifierValue;
-      var preventedOffset = within(tether ? Math.min(min, tetherMin) : min, offset, tether ? Math.max(max, tetherMax) : max);
-      popperOffsets[mainAxis] = preventedOffset;
-      data[mainAxis] = preventedOffset - offset;
-    }
+          var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers
 
-    if (checkAltAxis) {
-      var _mainSide = mainAxis === 'x' ? top : left;
+          state.orderedModifiers = orderedModifiers.filter(function (m) {
+            return m.enabled;
+          }); // Validate the provided modifiers so that the consumer will get warned
+          // if one of the modifiers is invalid for any reason
 
-      var _altSide = mainAxis === 'x' ? bottom : right;
+          {
+            var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function (_ref) {
+              var name = _ref.name;
+              return name;
+            });
+            validateModifiers(modifiers);
 
-      var _offset = popperOffsets[altAxis];
+            if (getBasePlacement(state.options.placement) === auto) {
+              var flipModifier = state.orderedModifiers.find(function (_ref2) {
+                var name = _ref2.name;
+                return name === 'flip';
+              });
 
-      var _min = _offset + overflow[_mainSide];
+              if (!flipModifier) {
+                console.error(['Popper: "auto" placements require the "flip" modifier be', 'present and enabled to work.'].join(' '));
+              }
+            }
 
-      var _max = _offset - overflow[_altSide];
+            var _getComputedStyle = getComputedStyle$1(popper),
+                marginTop = _getComputedStyle.marginTop,
+                marginRight = _getComputedStyle.marginRight,
+                marginBottom = _getComputedStyle.marginBottom,
+                marginLeft = _getComputedStyle.marginLeft; // We no longer take into account `margins` on the popper, and it can
+            // cause bugs with positioning, so we'll warn the consumer
 
-      var _preventedOffset = within(_min, _offset, _max);
 
-      popperOffsets[altAxis] = _preventedOffset;
-      data[altAxis] = _preventedOffset - _offset;
-    }
+            if ([marginTop, marginRight, marginBottom, marginLeft].some(function (margin) {
+              return parseFloat(margin);
+            })) {
+              console.warn(['Popper: CSS "margin" styles cannot be used to apply padding', 'between the popper and its reference element or boundary.', 'To replicate margin, use the `offset` modifier, as well as', 'the `padding` option in the `preventOverflow` and `flip`', 'modifiers.'].join(' '));
+            }
+          }
 
-    state.modifiersData[name] = data;
-  } // eslint-disable-next-line import/no-unused-modules
+          runModifierEffects();
+          return instance.update();
+        },
+        // Sync update – it will always be executed, even if not necessary. This
+        // is useful for low frequency updates where sync behavior simplifies the
+        // logic.
+        // For high frequency updates (e.g. `resize` and `scroll` events), always
+        // prefer the async Popper#update method
+        forceUpdate: function forceUpdate() {
+          if (isDestroyed) {
+            return;
+          }
 
+          var _state$elements = state.elements,
+              reference = _state$elements.reference,
+              popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
+          // anymore
 
-  var preventOverflow$1 = {
-    name: 'preventOverflow',
-    enabled: true,
-    phase: 'main',
-    fn: preventOverflow,
-    requiresIfExists: ['offset']
-  };
+          if (!areValidElements(reference, popper)) {
+            {
+              console.error(INVALID_ELEMENT_ERROR);
+            }
 
-  function arrow(_ref) {
-    var _state$modifiersData$;
+            return;
+          } // Store the reference and popper rects to be read by modifiers
 
-    var state = _ref.state,
-        name = _ref.name;
-    var arrowElement = state.elements.arrow;
-    var popperOffsets = state.modifiersData.popperOffsets;
-    var basePlacement = getBasePlacement(state.placement);
-    var axis = getMainAxisFromPlacement(basePlacement);
-    var isVertical = [left, right].indexOf(basePlacement) >= 0;
-    var len = isVertical ? 'height' : 'width';
 
-    if (!arrowElement || !popperOffsets) {
-      return;
-    }
+          state.rects = {
+            reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
+            popper: getLayoutRect(popper)
+          }; // Modifiers have the ability to reset the current update cycle. The
+          // most common use case for this is the `flip` modifier changing the
+          // placement, which then needs to re-run all the modifiers, because the
+          // logic was previously ran for the previous placement and is therefore
+          // stale/incorrect
 
-    var paddingObject = state.modifiersData[name + "#persistent"].padding;
-    var arrowRect = getLayoutRect(arrowElement);
-    var minProp = axis === 'y' ? top : left;
-    var maxProp = axis === 'y' ? bottom : right;
-    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
-    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
-    var arrowOffsetParent = getOffsetParent(arrowElement);
-    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
-    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
-    // outside of the popper bounds
+          state.reset = false;
+          state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
+          // is filled with the initial data specified by the modifier. This means
+          // it doesn't persist and is fresh on each update.
+          // To ensure persistent data, use `${name}#persistent`
 
-    var min = paddingObject[minProp];
-    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
-    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
-    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
+          state.orderedModifiers.forEach(function (modifier) {
+            return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
+          });
+          var __debug_loops__ = 0;
 
-    var axisProp = axis;
-    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
-  }
+          for (var index = 0; index < state.orderedModifiers.length; index++) {
+            {
+              __debug_loops__ += 1;
 
-  function effect(_ref2) {
-    var state = _ref2.state,
-        options = _ref2.options,
-        name = _ref2.name;
-    var _options$element = options.element,
-        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element,
-        _options$padding = options.padding,
-        padding = _options$padding === void 0 ? 0 : _options$padding;
+              if (__debug_loops__ > 100) {
+                console.error(INFINITE_LOOP_ERROR);
+                break;
+              }
+            }
 
-    if (arrowElement == null) {
-      return;
-    } // CSS selector
+            if (state.reset === true) {
+              state.reset = false;
+              index = -1;
+              continue;
+            }
 
+            var _state$orderedModifie = state.orderedModifiers[index],
+                fn = _state$orderedModifie.fn,
+                _state$orderedModifie2 = _state$orderedModifie.options,
+                _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
+                name = _state$orderedModifie.name;
 
-    if (typeof arrowElement === 'string') {
-      arrowElement = state.elements.popper.querySelector(arrowElement);
+            if (typeof fn === 'function') {
+              state = fn({
+                state: state,
+                options: _options,
+                name: name,
+                instance: instance
+              }) || state;
+            }
+          }
+        },
+        // Async and optimistically optimized update – it will not be executed if
+        // not necessary (debounced to run at most once-per-tick)
+        update: debounce$2(function () {
+          return new Promise(function (resolve) {
+            instance.forceUpdate();
+            resolve(state);
+          });
+        }),
+        destroy: function destroy() {
+          cleanupModifierEffects();
+          isDestroyed = true;
+        }
+      };
 
-      if (!arrowElement) {
-        return;
-      }
-    }
+      if (!areValidElements(reference, popper)) {
+        {
+          console.error(INVALID_ELEMENT_ERROR);
+        }
 
-    {
-      if (!isHTMLElement(arrowElement)) {
-        console.error(['Popper: "arrow" element must be an HTMLElement (not an SVGElement).', 'To use an SVG arrow, wrap it in an HTMLElement that will be used as', 'the arrow.'].join(' '));
+        return instance;
       }
-    }
 
-    if (!contains(state.elements.popper, arrowElement)) {
-      {
-        console.error(['Popper: "arrow" modifier\'s `element` must be a child of the popper', 'element.'].join(' '));
-      }
+      instance.setOptions(options).then(function (state) {
+        if (!isDestroyed && options.onFirstUpdate) {
+          options.onFirstUpdate(state);
+        }
+      }); // Modifiers have the ability to execute arbitrary code before the first
+      // update cycle runs. They will be executed in the same order as the update
+      // cycle. This is useful when a modifier adds some persistent data that
+      // other modifiers need to use, but the modifier is run after the dependent
+      // one.
 
-      return;
-    }
+      function runModifierEffects() {
+        state.orderedModifiers.forEach(function (_ref3) {
+          var name = _ref3.name,
+              _ref3$options = _ref3.options,
+              options = _ref3$options === void 0 ? {} : _ref3$options,
+              effect = _ref3.effect;
 
-    state.elements.arrow = arrowElement;
-    state.modifiersData[name + "#persistent"] = {
-      padding: mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements))
-    };
-  } // eslint-disable-next-line import/no-unused-modules
+          if (typeof effect === 'function') {
+            var cleanupFn = effect({
+              state: state,
+              name: name,
+              instance: instance,
+              options: options
+            });
 
+            var noopFn = function noopFn() {};
 
-  var arrow$1 = {
-    name: 'arrow',
-    enabled: true,
-    phase: 'main',
-    fn: arrow,
-    effect: effect,
-    requires: ['popperOffsets'],
-    requiresIfExists: ['preventOverflow']
-  };
+            effectCleanupFns.push(cleanupFn || noopFn);
+          }
+        });
+      }
 
-  function getSideOffsets(overflow, rect, preventedOffsets) {
-    if (preventedOffsets === void 0) {
-      preventedOffsets = {
-        x: 0,
-        y: 0
-      };
-    }
+      function cleanupModifierEffects() {
+        effectCleanupFns.forEach(function (fn) {
+          return fn();
+        });
+        effectCleanupFns = [];
+      }
 
-    return {
-      top: overflow.top - rect.height - preventedOffsets.y,
-      right: overflow.right - rect.width + preventedOffsets.x,
-      bottom: overflow.bottom - rect.height + preventedOffsets.y,
-      left: overflow.left - rect.width - preventedOffsets.x
+      return instance;
     };
   }
 
-  function isAnySideFullyClipped(overflow) {
-    return [top, right, bottom, left].some(function (side) {
-      return overflow[side] >= 0;
-    });
-  }
-
-  function hide(_ref) {
-    var state = _ref.state,
-        name = _ref.name;
-    var referenceRect = state.rects.reference;
-    var popperRect = state.rects.popper;
-    var preventedOffsets = state.modifiersData.preventOverflow;
-    var referenceOverflow = detectOverflow(state, {
-      elementContext: 'reference'
-    });
-    var popperAltOverflow = detectOverflow(state, {
-      altBoundary: true
-    });
-    var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
-    var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
-    var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
-    var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
-    state.modifiersData[name] = {
-      referenceClippingOffsets: referenceClippingOffsets,
-      popperEscapeOffsets: popperEscapeOffsets,
-      isReferenceHidden: isReferenceHidden,
-      hasPopperEscaped: hasPopperEscaped
-    };
-    state.attributes.popper = Object.assign(Object.assign({}, state.attributes.popper), {}, {
-      'data-popper-reference-hidden': isReferenceHidden,
-      'data-popper-escaped': hasPopperEscaped
-    });
-  } // eslint-disable-next-line import/no-unused-modules
-
-
-  var hide$1 = {
-    name: 'hide',
-    enabled: true,
-    phase: 'main',
-    requiresIfExists: ['preventOverflow'],
-    fn: hide
-  };
-
   var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
   var createPopper = /*#__PURE__*/popperGenerator({
     defaultModifiers: defaultModifiers
@@ -6038,7 +6170,9 @@
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var ref = _step.value;
 
-          if (typeof ref === "function") {
+          if (instance && instance.currentElement && typeof ref === "function") {
+            ref(instance.currentElement);
+          } else if (typeof ref === "function") {
             ref(instance);
           } else if (ref) {
             ref.current = instance;
@@ -6052,14 +6186,6 @@
     };
   }
 
-  function usePrevious(state) {
-    var ref = React.useRef();
-    React.useEffect(function () {
-      ref.current = state;
-    });
-    return ref.current;
-  }
-
   var Portal = function Portal(props) {
     var children = props.children,
         attach = props.attach;
@@ -6262,7 +6388,10 @@
         var scrollHeight = contentEle.scrollHeight;
         var minHeight = presetMaxHeight !== Infinity ? presetMaxHeight : scrollHeight;
         contentEle.style.maxHeight = "".concat(minHeight, "px");
-        contentEle.style.overflow = "";
+
+        if (presetMaxHeight !== Infinity) {
+          contentEle.style.overflow = "";
+        }
       }
     };
 
@@ -6350,8 +6479,6 @@
         visible = _useDefault2[0],
         setVisible = _useDefault2[1];
 
-    var preVisible = usePrevious(visible);
-
     var _useState = React.useState(null),
         _useState2 = _slicedToArray(_useState, 2),
         triggerRef = _useState2[0],
@@ -6363,48 +6490,49 @@
         setOverlayRef = _useState4[1];
 
     var contentRef = React.useRef(null);
+    var popupRef = React.useRef(null);
+    var popperRef = React.useRef(null);
+    var onPopperFirstUpdate = React.useCallback(function (state) {
+      var referenceElmRect = popupRef.current.getBoundingClientRect();
+      var referenceElmTop = referenceElmRect.top,
+          referenceElmLeft = referenceElmRect.left,
+          bottom = referenceElmRect.bottom,
+          right = referenceElmRect.right;
+      var referenceElmBottom = window.innerHeight - bottom;
+      var referenceElmRight = window.innerWidth - right;
+      var _contentRef$current = contentRef.current,
+          contentScrollHeight = _contentRef$current.scrollHeight,
+          contentOffsetWidth = _contentRef$current.offsetWidth;
+      var newPlacement = state.options.placement;
 
-    var _useState5 = React.useState(false),
-        _useState6 = _slicedToArray(_useState5, 2),
-        firstUpdate = _useState6[0],
-        setFirstUpdate = _useState6[1];
+      if (referenceElmBottom < contentScrollHeight && referenceElmTop >= contentScrollHeight) {
+        newPlacement = state.options.placement.replace("bottom", "top");
+      }
 
-    var onPopperFirstUpdate = React.useMemo(function () {
-      return function () {
-        setFirstUpdate(true);
-      };
-    }, []);
-    var popperOptions = React.useMemo(function () {
-      var _contentRef$current, _childElement$offsetH, _childElement$offsetW;
+      if (referenceElmTop < contentScrollHeight && referenceElmBottom >= contentScrollHeight) {
+        newPlacement = state.options.placement.replace("top", "bottom");
+      }
 
-      if (!visible) return {
-        padding: 0
-      };
-      var childElement = (_contentRef$current = contentRef.current) === null || _contentRef$current === void 0 ? void 0 : _contentRef$current.firstElementChild;
-      var height = (_childElement$offsetH = childElement === null || childElement === void 0 ? void 0 : childElement.offsetHeight) !== null && _childElement$offsetH !== void 0 ? _childElement$offsetH : 0;
-      var width = (_childElement$offsetW = childElement === null || childElement === void 0 ? void 0 : childElement.offsetWidth) !== null && _childElement$offsetW !== void 0 ? _childElement$offsetW : 0;
-      return {
-        padding: {
-          top: height,
-          left: width,
-          right: width,
-          bottom: height
-        }
-      };
-    }, [visible, overlayRef]);
+      if (referenceElmLeft < contentOffsetWidth && referenceElmRight >= contentOffsetWidth) {
+        newPlacement = state.options.placement.replace("left", "right");
+      }
 
-    var _usePopper = usePopper(triggerRef, overlayRef, {
-      placement: placementMap[placement],
-      onFirstUpdate: onPopperFirstUpdate,
-      modifiers: [{
-        name: "flip",
-        options: _objectSpread$1R({}, popperOptions)
-      }]
-    }),
-        styles = _usePopper.styles,
-        attributes = _usePopper.attributes,
-        update = _usePopper.update;
+      if (referenceElmRight < contentOffsetWidth && referenceElmLeft >= contentOffsetWidth) {
+        newPlacement = state.options.placement.replace("right", "left");
+      }
 
+      Object.assign(state.options, _objectSpread$1R(_objectSpread$1R({}, state.options), {}, {
+        placement: newPlacement
+      }));
+      popperRef.current.update();
+    }, []);
+    popperRef.current = usePopper(triggerRef, overlayRef, {
+      placement: placementMap[placement],
+      onFirstUpdate: onPopperFirstUpdate
+    });
+    var _popperRef$current = popperRef.current,
+        styles = _popperRef$current.styles,
+        attributes = _popperRef$current.attributes;
     var defaultStyles = React.useMemo(function () {
       if (triggerRef && typeof overlayStyle === "function") return _objectSpread$1R(_objectSpread$1R({}, overlayStyle(triggerRef)), {}, {
         zIndex: zIndex
@@ -6447,22 +6575,6 @@
       classPrefix: classPrefix,
       expandAnimation: expandAnimation
     });
-    React.useEffect(function () {
-      if ((visible || firstUpdate) && update) {
-        update();
-      }
-    }, [visible, preVisible, update, children, firstUpdate]);
-
-    var handlePopupWrapperMouseDown = function handlePopupWrapperMouseDown() {
-      var removeUpdate = function removeUpdate() {
-        return window.removeEventListener("mousemove", update);
-      };
-
-      window.removeEventListener("mouseup", removeUpdate);
-      window.addEventListener("mousemove", update);
-      window.addEventListener("mouseup", removeUpdate);
-    };
-
     var portal = visible || overlayRef ? /* @__PURE__ */React__default["default"].createElement(Portal, {
       attach: attach
     }, /* @__PURE__ */React__default["default"].createElement(CSSTransition$1, _objectSpread$1R({
@@ -6483,8 +6595,8 @@
     }) : null, content)))) : null;
     return /* @__PURE__ */React__default["default"].createElement("div", {
       className: classNames$1("".concat(classPrefix, "-popup__reference"), className),
-      onMouseDown: handlePopupWrapperMouseDown,
-      style: style
+      style: style,
+      ref: popupRef
     }, triggerNode, portal);
   });
   Popup$1.displayName = "Popup";
@@ -6683,13 +6795,13 @@
       }
     }
 
-    return /* @__PURE__ */React__default["default"].createElement("button", _objectSpread$1Q({
+    return /* @__PURE__ */React__default["default"].createElement("button", _objectSpread$1Q(_objectSpread$1Q({}, buttonProps), {}, {
       ref: ref || btnRef,
       type: type,
       className: classNames$1(className, ["".concat(classPrefix, "-button"), "".concat(classPrefix, "-button--theme-").concat(renderTheme), "".concat(classPrefix, "-button--variant-").concat(variant)], (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-button--shape-").concat(shape), shape !== "rectangle"), _defineProperty$2(_classNames, "".concat(classPrefix, "-button--ghost"), ghost), _defineProperty$2(_classNames, "".concat(classPrefix, "-is-loading"), loading), _defineProperty$2(_classNames, "".concat(classPrefix, "-is-disabled"), disabled || loading), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-s"), size === "small"), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-l"), size === "large"), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-full-width"), block), _classNames)),
       onClick: !disabled && !loading ? onClick : void 0,
       disabled: disabled || loading
-    }, buttonProps), iconNode ? /* @__PURE__ */React__default["default"].createElement(React__default["default"].Fragment, null, iconNode, (hasChildren || hasContent) && /* @__PURE__ */React__default["default"].createElement("span", {
+    }), iconNode ? /* @__PURE__ */React__default["default"].createElement(React__default["default"].Fragment, null, iconNode, (hasChildren || hasContent) && /* @__PURE__ */React__default["default"].createElement("span", {
       className: "".concat(classPrefix, "-button__text")
     }, childrenNode)) : /* @__PURE__ */React__default["default"].createElement("span", {
       className: "".concat(classPrefix, "-button__text")
@@ -6699,45 +6811,6 @@
 
   var Button = Button$1;
 
-  var baseGetTag$8 = _baseGetTag,
-      isObject$a = isObject_1;
-  /** `Object#toString` result references. */
-
-  var asyncTag = '[object AsyncFunction]',
-      funcTag$2 = '[object Function]',
-      genTag$1 = '[object GeneratorFunction]',
-      proxyTag = '[object Proxy]';
-  /**
-   * Checks if `value` is classified as a `Function` object.
-   *
-   * @static
-   * @memberOf _
-   * @since 0.1.0
-   * @category Lang
-   * @param {*} value The value to check.
-   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
-   * @example
-   *
-   * _.isFunction(_);
-   * // => true
-   *
-   * _.isFunction(/abc/);
-   * // => false
-   */
-
-  function isFunction$3(value) {
-    if (!isObject$a(value)) {
-      return false;
-    } // The use of `Object#toString` avoids issues with the `typeof` operator
-    // in Safari 9 which returns 'object' for typed arrays and other constructors.
-
-
-    var tag = baseGetTag$8(value);
-    return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
-  }
-
-  var isFunction_1 = isFunction$3;
-
   function _objectWithoutPropertiesLoose(source, excluded) {
     if (source == null) return {};
     var target = {};
@@ -8808,7 +8881,7 @@
     }, restProps);
   }
 
-  var _excluded$m = ["disabled", "status", "size", "className", "style", "prefixIcon", "suffixIcon", "clearable", "value", "onChange", "onClear", "onEnter", "onKeydown", "onCompositionStart", "onCompositionEnd", "autofocus", "readonly"];
+  var _excluded$m = ["disabled", "status", "size", "className", "style", "prefixIcon", "suffixIcon", "clearable", "value", "tips", "onChange", "onClear", "onEnter", "onKeydown", "onFocus", "onBlur", "onPaste", "onCompositionStart", "onCompositionEnd", "autofocus", "readonly"];
 
   function ownKeys$1h(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
@@ -8841,10 +8914,14 @@
         suffixIcon = _useDefaultValue.suffixIcon,
         clearable = _useDefaultValue.clearable,
         value = _useDefaultValue.value,
+        tips = _useDefaultValue.tips,
         onChange = _useDefaultValue.onChange,
         onClear = _useDefaultValue.onClear,
         onEnter = _useDefaultValue.onEnter,
         onKeydown = _useDefaultValue.onKeydown,
+        onFocus = _useDefaultValue.onFocus,
+        onBlur = _useDefaultValue.onBlur,
+        onPaste = _useDefaultValue.onPaste,
         onCompositionStart = _useDefaultValue.onCompositionStart,
         onCompositionEnd = _useDefaultValue.onCompositionEnd,
         autofocus = _useDefaultValue.autofocus,
@@ -8855,6 +8932,8 @@
         classPrefix = _useConfig.classPrefix;
 
     var composingRef = React.useRef(false);
+    var inputRef = React.useRef();
+    var wrapperRef = React.useRef();
 
     var _useState = React.useState(false),
         _useState2 = _slicedToArray(_useState, 2),
@@ -8872,17 +8951,10 @@
         setComposingValue = _useState6[1];
 
     var isShowClearIcon = clearable && value && !disabled && isHover;
-    var componentType = "input";
     var prefixIconContent = renderIcon$1(classPrefix, "prefix", prefixIcon);
     var suffixIconNew = isShowClearIcon ? /* @__PURE__ */React__default["default"].createElement(CloseCircleFilledIcon, {
       className: "".concat(classPrefix, "-input__suffix-clear"),
-      onClick: handleClear,
-      onMouseUp: function onMouseUp(e) {
-        return e.preventDefault();
-      },
-      onMouseDown: function onMouseDown(e) {
-        return e.preventDefault();
-      }
+      onClick: handleClear
     }) : suffixIcon;
     var suffixIconContent = renderIcon$1(classPrefix, "suffix", suffixIconNew);
     var inputPropsNames = Object.keys(restProps).filter(function (key) {
@@ -8890,7 +8962,9 @@
     });
     var inputProps = inputPropsNames.reduce(function (inputProps2, key) {
       return Object.assign(inputProps2, _defineProperty$2({}, key, props[key]));
-    }, {});
+    }, {
+      className: ""
+    });
     var eventPropsNames = Object.keys(restProps).filter(function (key) {
       return /^on[A-Z]/.test(key);
     });
@@ -8902,19 +8976,35 @@
       }));
       return eventProps2;
     }, {});
+    var wrapperProps = {
+      style: style,
+      ref: wrapperRef
+    };
     var renderInput = /* @__PURE__ */React__default["default"].createElement("input", _objectSpread$1h(_objectSpread$1h(_objectSpread$1h({
+      ref: inputRef
+    }, inputProps), eventProps), {}, {
+      className: classNames$1(inputProps.className, "".concat(classPrefix, "-input__inner")),
+      value: composingRef.current ? composingRefValue : value,
       readOnly: readonly,
       disabled: disabled,
-      className: "".concat(classPrefix, "-").concat(componentType, "__inner")
-    }, inputProps), {}, {
-      value: composingRef.current ? composingRefValue : value
-    }, eventProps), {}, {
       autoFocus: autofocus,
       onChange: handleChange,
       onKeyDown: handleKeyDown,
       onCompositionStart: handleCompositionStart,
-      onCompositionEnd: handleCompositionEnd
+      onCompositionEnd: handleCompositionEnd,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onPaste: handlePaste
     }));
+    var renderInputNode = /* @__PURE__ */React__default["default"].createElement("div", _objectSpread$1h(_objectSpread$1h({}, wrapperProps), {}, {
+      className: classNames$1(tips ? "" : className, "".concat(classPrefix, "-input"), (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-is-readonly"), readonly), _defineProperty$2(_classNames, "".concat(classPrefix, "-is-disabled"), disabled), _defineProperty$2(_classNames, "".concat(classPrefix, "-is-focused"), isFocused), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-s"), size === "small"), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-l"), size === "large"), _defineProperty$2(_classNames, "".concat(classPrefix, "-is-").concat(status), status), _defineProperty$2(_classNames, "".concat(classPrefix, "-input--prefix"), prefixIcon), _defineProperty$2(_classNames, "".concat(classPrefix, "-input--suffix"), suffixIconContent), _defineProperty$2(_classNames, "".concat(classPrefix, "-input--focused"), isFocused), _classNames)),
+      onMouseEnter: function onMouseEnter() {
+        return toggleIsHover(true);
+      },
+      onMouseLeave: function onMouseLeave() {
+        return toggleIsHover(false);
+      }
+    }), prefixIconContent, renderInput, suffixIconContent);
 
     function handleChange(e) {
       var value2 = e.currentTarget.value;
@@ -8929,10 +9019,10 @@
     }
 
     function handleClear(e) {
-      isFunction_1(onChange) && onChange("", {
+      onChange === null || onChange === void 0 ? void 0 : onChange("", {
         e: e
       });
-      isFunction_1(onClear) && onClear({
+      onClear === null || onClear === void 0 ? void 0 : onClear({
         e: e
       });
     }
@@ -8940,46 +9030,92 @@
     function handleKeyDown(e) {
       var key = e.key,
           value2 = e.currentTarget.value;
-      isFunction_1(onEnter) && key === "Enter" && onEnter(value2, {
+      key === "Enter" && (onEnter === null || onEnter === void 0 ? void 0 : onEnter(value2, {
         e: e
-      });
-      isFunction_1(onKeydown) && onKeydown(value2, {
+      }));
+      onKeydown === null || onKeydown === void 0 ? void 0 : onKeydown(value2, {
         e: e
       });
     }
 
-    function handleCompositionStart(event) {
+    function handleCompositionStart(e) {
       composingRef.current = true;
-      isFunction_1(onCompositionStart) && onCompositionStart(event);
+      var value2 = e.currentTarget.value;
+      onCompositionStart === null || onCompositionStart === void 0 ? void 0 : onCompositionStart(value2, {
+        e: e
+      });
     }
 
-    function handleCompositionEnd(event) {
+    function handleCompositionEnd(e) {
+      var value2 = e.currentTarget.value;
+
       if (composingRef.current) {
         composingRef.current = false;
-        handleChange(event);
+        handleChange(e);
       }
 
       setComposingValue("");
-      isFunction_1(onCompositionEnd) && onCompositionEnd(event);
+      onCompositionEnd === null || onCompositionEnd === void 0 ? void 0 : onCompositionEnd(value2, {
+        e: e
+      });
     }
 
-    return /* @__PURE__ */React__default["default"].createElement("div", {
-      ref: ref,
-      style: style,
-      className: classNames$1("".concat(classPrefix, "-").concat(componentType), (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-is-disabled"), disabled), _defineProperty$2(_classNames, "".concat(classPrefix, "-is-focused"), isFocused), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-s"), size === "small"), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-l"), size === "large"), _defineProperty$2(_classNames, "".concat(classPrefix, "-is-").concat(status), status), _defineProperty$2(_classNames, "".concat(classPrefix, "-").concat(componentType, "--prefix"), prefixIcon), _defineProperty$2(_classNames, "".concat(classPrefix, "-").concat(componentType, "--suffix"), suffixIconContent), _defineProperty$2(_classNames, "".concat(classPrefix, "-").concat(componentType, "--focused"), isFocused), _classNames), className),
-      onMouseEnter: function onMouseEnter() {
-        return toggleIsHover(true);
-      },
-      onMouseLeave: function onMouseLeave() {
-        return toggleIsHover(false);
-      },
-      onFocus: function onFocus() {
-        return toggleIsFocused(true);
-      },
-      onBlur: function onBlur() {
-        return toggleIsFocused(false);
-      }
-    }, prefixIconContent, renderInput, suffixIconContent);
+    function handleFocus(e) {
+      var value2 = e.currentTarget.value;
+      onFocus === null || onFocus === void 0 ? void 0 : onFocus(value2, {
+        e: e
+      });
+      toggleIsFocused(true);
+    }
+
+    function handleBlur(e) {
+      var value2 = e.currentTarget.value;
+      onBlur === null || onBlur === void 0 ? void 0 : onBlur(value2, {
+        e: e
+      });
+      toggleIsFocused(false);
+    }
+
+    function handlePaste(e) {
+      var clipData = e.clipboardData;
+      var pasteValue = clipData === null || clipData === void 0 ? void 0 : clipData.getData("text/plain");
+      onPaste === null || onPaste === void 0 ? void 0 : onPaste({
+        e: e,
+        pasteValue: pasteValue
+      });
+    }
+
+    React.useImperativeHandle(ref, function () {
+      return {
+        currentElement: wrapperRef.current,
+        inputElement: inputRef.current,
+        focus: function focus() {
+          var _inputRef$current;
+
+          return (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.focus();
+        },
+        blur: function blur() {
+          var _inputRef$current2;
+
+          return (_inputRef$current2 = inputRef.current) === null || _inputRef$current2 === void 0 ? void 0 : _inputRef$current2.blur();
+        },
+        select: function select() {
+          var _inputRef$current3;
+
+          return (_inputRef$current3 = inputRef.current) === null || _inputRef$current3 === void 0 ? void 0 : _inputRef$current3.select();
+        }
+      };
+    });
+
+    if (tips) {
+      return /* @__PURE__ */React__default["default"].createElement("div", _objectSpread$1h(_objectSpread$1h({}, wrapperProps), {}, {
+        className: classNames$1(className, "".concat(classPrefix, "-input__wrap"))
+      }), renderInputNode, /* @__PURE__ */React__default["default"].createElement("div", {
+        className: classNames$1("".concat(classPrefix, "-input__tips"), "".concat(classPrefix, "-input__tips--").concat(status || "normal"))
+      }, tips));
+    }
+
+    return renderInputNode;
   }, {
     Group: InputGroup
   });
@@ -9249,7 +9385,7 @@
 
   var _arrayMap = arrayMap$3;
 
-  var baseGetTag$7 = _baseGetTag,
+  var baseGetTag$8 = _baseGetTag,
       isObjectLike$b = isObjectLike_1;
   /** `Object#toString` result references. */
 
@@ -9273,7 +9409,7 @@
    */
 
   function isSymbol$4(value) {
-    return _typeof(value) == 'symbol' || isObjectLike$b(value) && baseGetTag$7(value) == symbolTag$3;
+    return _typeof(value) == 'symbol' || isObjectLike$b(value) && baseGetTag$8(value) == symbolTag$3;
   }
 
   var isSymbol_1 = isSymbol$4;
@@ -10356,7 +10492,7 @@
 
   var Radio = Radio$1;
 
-  var baseGetTag$6 = _baseGetTag,
+  var baseGetTag$7 = _baseGetTag,
       isObjectLike$a = isObjectLike_1;
   /** `Object#toString` result references. */
 
@@ -10389,7 +10525,7 @@
    */
 
   function isNumber(value) {
-    return typeof value == 'number' || isObjectLike$a(value) && baseGetTag$6(value) == numberTag$4;
+    return typeof value == 'number' || isObjectLike$a(value) && baseGetTag$7(value) == numberTag$4;
   }
 
   var isNumber_1 = isNumber;
@@ -11518,7 +11654,7 @@
   var _baseTrim = baseTrim$1;
 
   var baseTrim = _baseTrim,
-      isObject$9 = isObject_1,
+      isObject$a = isObject_1,
       isSymbol$2 = isSymbol_1;
   /** Used as references for various `Number` constants. */
 
@@ -11568,9 +11704,9 @@
       return NAN;
     }
 
-    if (isObject$9(value)) {
+    if (isObject$a(value)) {
       var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
-      value = isObject$9(other) ? other + '' : other;
+      value = isObject$a(other) ? other + '' : other;
     }
 
     if (typeof value != 'string') {
@@ -11584,7 +11720,7 @@
 
   var toNumber_1 = toNumber$2;
 
-  var isObject$8 = isObject_1,
+  var isObject$9 = isObject_1,
       now = now_1,
       toNumber$1 = toNumber_1;
   /** Error message constants. */
@@ -11667,7 +11803,7 @@
 
     wait = toNumber$1(wait) || 0;
 
-    if (isObject$8(options)) {
+    if (isObject$9(options)) {
       leading = !!options.leading;
       maxing = 'maxWait' in options;
       maxWait = maxing ? nativeMax$4(toNumber$1(options.maxWait) || 0, wait) : maxWait;
@@ -11779,7 +11915,7 @@
   var debounce_1 = debounce$1;
 
   var debounce = debounce_1,
-      isObject$7 = isObject_1;
+      isObject$8 = isObject_1;
   /** Error message constants. */
 
   var FUNC_ERROR_TEXT$1 = 'Expected a function';
@@ -11836,7 +11972,7 @@
       throw new TypeError(FUNC_ERROR_TEXT$1);
     }
 
-    if (isObject$7(options)) {
+    if (isObject$8(options)) {
       leading = 'leading' in options ? !!options.leading : leading;
       trailing = 'trailing' in options ? !!options.trailing : trailing;
     }
@@ -11850,6 +11986,45 @@
 
   var throttle_1 = throttle;
 
+  var baseGetTag$6 = _baseGetTag,
+      isObject$7 = isObject_1;
+  /** `Object#toString` result references. */
+
+  var asyncTag = '[object AsyncFunction]',
+      funcTag$2 = '[object Function]',
+      genTag$1 = '[object GeneratorFunction]',
+      proxyTag = '[object Proxy]';
+  /**
+   * Checks if `value` is classified as a `Function` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+   * @example
+   *
+   * _.isFunction(_);
+   * // => true
+   *
+   * _.isFunction(/abc/);
+   * // => false
+   */
+
+  function isFunction$3(value) {
+    if (!isObject$7(value)) {
+      return false;
+    } // The use of `Object#toString` avoids issues with the `typeof` operator
+    // in Safari 9 which returns 'object' for typed arrays and other constructors.
+
+
+    var tag = baseGetTag$6(value);
+    return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+  }
+
+  var isFunction_1 = isFunction$3;
+
   var isArray$9 = isArray_1,
       isSymbol$1 = isSymbol_1;
   /** Used to match property names within property paths. */
@@ -24309,7 +24484,9 @@
     var _useConfig = useConfig$1(),
         classPrefix = _useConfig.classPrefix;
 
-    var _props$bordered = props.bordered,
+    var className = props.className,
+        style = props.style,
+        _props$bordered = props.bordered,
         bordered = _props$bordered === void 0 ? false : _props$bordered,
         _props$stripe = props.stripe,
         stripe = _props$stripe === void 0 ? false : _props$stripe,
@@ -24525,10 +24702,10 @@
     }
 
     function getTableWithFixedHeader() {
-      var style = {};
+      var style2 = {};
 
       if (isHasScrollbar) {
-        style = _objectSpread$T(_objectSpread$T({}, style), {}, {
+        style2 = _objectSpread$T(_objectSpread$T({}, style2), {}, {
           paddingRight: scrollBarWidth
         });
       }
@@ -24536,7 +24713,7 @@
       var fixedHeaderRN = /* @__PURE__ */React__default["default"].createElement("div", {
         ref: scrollHeaderRef,
         className: "".concat(classPrefix, "-table__header"),
-        style: style
+        style: style2
       }, getTable({
         enableBody: false
       }));
@@ -24605,7 +24782,8 @@
     }
 
     return /* @__PURE__ */React__default["default"].createElement("div", {
-      className: classNames$1("".concat(classPrefix, "-table"), (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-table--striped"), stripe), _defineProperty$2(_classNames, "".concat(classPrefix, "-table--bordered"), bordered), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-l"), size === "large"), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-s"), size === "small"), _defineProperty$2(_classNames, "".concat(classPrefix, "-table--hoverable"), hover), _defineProperty$2(_classNames, "".concat(classPrefix, "-table--align-").concat(verticalAlign), verticalAlign), _defineProperty$2(_classNames, "".concat(classPrefix, "-table__header--fixed"), fixedHeader), _defineProperty$2(_classNames, "".concat(classPrefix, "-table__cell--fixed ").concat(classPrefix, "-table--has-fixed"), hasFixedColumns), _classNames))
+      className: classNames$1("".concat(classPrefix, "-table"), (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-table--striped"), stripe), _defineProperty$2(_classNames, "".concat(classPrefix, "-table--bordered"), bordered), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-l"), size === "large"), _defineProperty$2(_classNames, "".concat(classPrefix, "-size-s"), size === "small"), _defineProperty$2(_classNames, "".concat(classPrefix, "-table--hoverable"), hover), _defineProperty$2(_classNames, "".concat(classPrefix, "-table--align-").concat(verticalAlign), verticalAlign), _defineProperty$2(_classNames, "".concat(classPrefix, "-table__header--fixed"), fixedHeader), _defineProperty$2(_classNames, "".concat(classPrefix, "-table__cell--fixed ").concat(classPrefix, "-table--has-fixed"), hasFixedColumns), _classNames), className),
+      style: style
     }, /* @__PURE__ */React__default["default"].createElement(TableContextProvider, {
       value: table
     }, /* @__PURE__ */React__default["default"].createElement(Loading, {
@@ -29922,6 +30100,9 @@
   function _createClass(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
     if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
     return Constructor;
   }
 
@@ -31658,6 +31839,31 @@
   });
   var pick_1 = pick;
 
+  var logSet = /* @__PURE__ */new Set();
+  var log = {
+    warn: function warn(componentName, message) {
+      console.warn("TDesign ".concat(componentName, " Warn: ").concat(message));
+    },
+    warnOnce: function warnOnce(componentName, message) {
+      var msgContent = "TDesign ".concat(componentName, " Warn: ").concat(message);
+      if (logSet.has(msgContent)) return;
+      logSet.add(msgContent);
+      console.warn(msgContent);
+    },
+    error: function error(componentName, message) {
+      console.error("TDesign ".concat(componentName, " Error: ").concat(message));
+    },
+    errorOnce: function errorOnce(componentName, message) {
+      var msgContent = "TDesign ".concat(componentName, " Error: ").concat(message);
+      if (logSet.has(msgContent)) return;
+      logSet.add(msgContent);
+      console.error(msgContent);
+    },
+    info: function info(componentName, message) {
+      console.info("TDesign ".concat(componentName, " Info: ").concat(message));
+    }
+  };
+
   function ownKeys$x(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
   function _objectSpread$x(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$x(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$x(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
@@ -31758,7 +31964,7 @@
         var targetNode = tree.getNode(value);
 
         if (!targetNode) {
-          console.warn("TDesign Tree Warn: `".concat(value, "` is not exist"));
+          log.warnOnce("Tree", "`".concat(value, "` is not exist"));
           return;
         }
 
@@ -31768,7 +31974,7 @@
         });
 
         if (parentValues.indexOf(node.value) < 0) {
-          console.warn("TDesign Tree Warn: `".concat(value, "` is not a childNode of current node"));
+          log.warnOnce("Tree", "`".concat(value, "` is not a childNode of current node"));
           return;
         }
 
@@ -34430,7 +34636,7 @@
 
   var TreeSelect = TreeSelect$1;
 
-  var _excluded$8 = ["layout", "dashed", "align", "className", "style", "children"];
+  var _excluded$8 = ["layout", "dashed", "align", "className", "style", "children", "content"];
 
   function ownKeys$s(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
@@ -34447,18 +34653,27 @@
         className = props.className,
         style = props.style,
         children = props.children,
+        content = props.content,
         otherDividerProps = _objectWithoutProperties$1(props, _excluded$8);
 
     var _useConfig = useConfig$1(),
         classPrefix = _useConfig.classPrefix;
 
-    var dividerClassNames = classNames$1("".concat(classPrefix, "-divider"), className, (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--horizontal"), layout === "horizontal"), _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--vertical"), layout === "vertical"), _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--dashed"), !!dashed), _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--with-text"), !!children), _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--with-text-").concat(align), !!children), _classNames));
-    return /* @__PURE__ */React__default["default"].createElement("div", _objectSpread$s({
+    var hasChildren = typeof children !== "undefined";
+    var hasContent = typeof content !== "undefined";
+    var childrenNode = children;
+
+    if (!hasChildren && hasContent) {
+      childrenNode = content;
+    }
+
+    var dividerClassNames = classNames$1("".concat(classPrefix, "-divider"), className, (_classNames = {}, _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--horizontal"), layout === "horizontal"), _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--vertical"), layout === "vertical"), _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--dashed"), !!dashed), _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--with-text"), !!childrenNode), _defineProperty$2(_classNames, "".concat(classPrefix, "-divider--with-text-").concat(align), !!childrenNode), _classNames));
+    return /* @__PURE__ */React__default["default"].createElement("div", _objectSpread$s(_objectSpread$s({}, otherDividerProps), {}, {
       className: dividerClassNames,
       style: style
-    }, otherDividerProps), children ? /* @__PURE__ */React__default["default"].createElement("span", {
+    }), childrenNode ? /* @__PURE__ */React__default["default"].createElement("span", {
       className: "".concat(classPrefix, "-divider__inner-text")
-    }, children) : null);
+    }, childrenNode) : null);
   };
 
   Divider$1.displayName = "Divider";
@@ -38926,6 +39141,53 @@
     }, restProps);
   }
 
+  var SIZE_MAP = {
+    B: 1,
+    KB: 1024,
+    MB: 1048576,
+    GB: 1073741824
+  };
+
+  function judgeIsSuitableSize(fileSize, sizeLimit, unit) {
+    var units = ["B", "KB", "MB", "GB"];
+    var index = units.indexOf(unit);
+
+    if (index === -1) {
+      console.warn("TDesign Upload Warn: `sizeLimit.unit` can only be one of ".concat(units.join()));
+    }
+
+    return fileSize <= sizeLimit * SIZE_MAP[unit];
+  }
+
+  function useHandleLimit() {
+    var _useLocaleReceiver = useLocaleReceiver("upload"),
+        _useLocaleReceiver2 = _slicedToArray(_useLocaleReceiver, 2),
+        local = _useLocaleReceiver2[0],
+        t = _useLocaleReceiver2[1];
+
+    return handleSizeLimit;
+
+    function handleSizeLimit(fileSize, rawSizeLimit) {
+      var sizeLimit = typeof rawSizeLimit === "number" ? {
+        size: rawSizeLimit,
+        unit: "KB"
+      } : rawSizeLimit;
+      sizeLimit.unit = sizeLimit.unit.toUpperCase();
+      var isSuitableSize = judgeIsSuitableSize(fileSize, sizeLimit.size, sizeLimit.unit);
+      var errorMsg;
+
+      if (!isSuitableSize) {
+        errorMsg = sizeLimit.message ? t(sizeLimit.message, {
+          sizeLimit: sizeLimit.size
+        }) : "".concat(t(local.sizeLimitMessage, {
+          sizeLimit: sizeLimit.size
+        }), " ").concat(sizeLimit.unit);
+      }
+
+      return [isSuitableSize, errorMsg];
+    }
+  }
+
   function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
   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); }
@@ -38960,6 +39222,9 @@
         withCredentials = _useDefaultValue.withCredentials,
         _useDefaultValue$auto = _useDefaultValue.autoUpload,
         autoUpload = _useDefaultValue$auto === void 0 ? true : _useDefaultValue$auto,
+        _useDefaultValue$file = _useDefaultValue.files,
+        fileList = _useDefaultValue$file === void 0 ? [] : _useDefaultValue$file,
+        sizeLimit = _useDefaultValue.sizeLimit,
         formatResponse = _useDefaultValue.formatResponse,
         beforeUpload = _useDefaultValue.beforeUpload,
         onProgress = _useDefaultValue.onProgress,
@@ -38970,8 +39235,6 @@
         onDragenter = _useDefaultValue.onDragenter,
         onDragleave = _useDefaultValue.onDragleave,
         requestMethod = _useDefaultValue.requestMethod,
-        _useDefaultValue$file = _useDefaultValue.files,
-        fileList = _useDefaultValue$file === void 0 ? [] : _useDefaultValue$file,
         customDraggerRender = _useDefaultValue.customDraggerRender,
         children = _useDefaultValue.children;
 
@@ -39011,6 +39274,7 @@
       setShowImg(false);
       setImgURL("");
     }, []);
+    var handleSizeLimit = useHandleLimit();
     var handlePreviewImg = React.useCallback(function (event, file) {
       if (!file.url) throw new Error("Error file");
       setImgURL(file.url);
@@ -39265,14 +39529,23 @@
       if (typeof beforeUpload === "function") {
         var r = beforeUpload(file);
         if (r instanceof Promise) return r;
-        return new Promise(function (resolve) {
-          return resolve(r);
-        });
+        return Promise.resolve(r);
       }
 
-      return new Promise(function (resolve) {
-        return resolve(true);
-      });
+      if (sizeLimit) {
+        var _handleSizeLimit = handleSizeLimit(file.size, sizeLimit),
+            _handleSizeLimit2 = _slicedToArray(_handleSizeLimit, 2),
+            overrideSize = _handleSizeLimit2[0],
+            errorMsg2 = _handleSizeLimit2[1];
+
+        if (errorMsg2) {
+          setErrorMsg(errorMsg2);
+        }
+
+        return Promise.resolve(overrideSize);
+      }
+
+      return Promise.resolve(true);
     };
 
     var uploadFiles = function uploadFiles() {
@@ -40989,6 +41262,15 @@
     }, [formValue]);
     React.useEffect(function () {
       formItemsRef.current.push(currentFormItemRef);
+      return function () {
+        var index = formItemsRef.current.indexOf(currentFormItemRef);
+
+        if (index !== -1) {
+          var _formItemsRef$current;
+
+          (_formItemsRef$current = formItemsRef.current) === null || _formItemsRef$current === void 0 ? void 0 : _formItemsRef$current.splice(index, 1);
+        }
+      };
     }, []);
     React.useImperativeHandle(currentFormItemRef, function () {
       return {
@@ -41099,6 +41381,7 @@
         classPrefix = _useConfig.classPrefix;
 
     var formClass = classNames$1(className, "".concat(classPrefix, "-form"), _defineProperty$2({}, "".concat(classPrefix, "-form-inline"), layout === "inline"));
+    var formRef = React.useRef();
     var formItemsRef = React.useRef([]);
     var FORM_ITEM_CLASS_PREFIX = "".concat(classPrefix, "-form-item__");
 
@@ -41141,8 +41424,10 @@
       e === null || e === void 0 ? void 0 : e.preventDefault();
       formItemsRef.current.forEach(function (_ref) {
         var formItemRef = _ref.current;
-        if (!isFunction_1(formItemRef.resetField)) return;
-        formItemRef.resetField();
+
+        if (formItemRef && isFunction_1(formItemRef.resetField)) {
+          formItemRef.resetField();
+        }
       });
       onReset === null || onReset === void 0 ? void 0 : onReset({
         e: e
@@ -41162,7 +41447,7 @@
 
       var list = formItemsRef.current.filter(function (_ref3) {
         var formItemRef = _ref3.current;
-        return isFunction_1(formItemRef.validate) && needValidate(formItemRef.name, fields);
+        return formItemRef && isFunction_1(formItemRef.validate) && needValidate(formItemRef.name, fields);
       }).map(function (_ref4) {
         var formItemRef = _ref4.current;
         return formItemRef.validate(trigger);
@@ -41187,7 +41472,7 @@
       formItemsRef.current.forEach(function (_ref5) {
         var formItemRef = _ref5.current;
 
-        if (formItemRef.name) {
+        if (formItemRef !== null && formItemRef !== void 0 && formItemRef.name) {
           fieldsValue[formItemRef.name] = formItemRef.value;
         }
       });
@@ -41198,7 +41483,7 @@
       if (!name) return null;
       var target = formItemsRef.current.find(function (_ref6) {
         var formItemRef = _ref6.current;
-        return formItemRef.name === name;
+        return (formItemRef === null || formItemRef === void 0 ? void 0 : formItemRef.name) === name;
       });
       return target && target.value;
     }
@@ -41207,8 +41492,13 @@
       var fileds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
       var formItemsMap = formItemsRef.current.reduce(function (acc, _ref7) {
         var currItem = _ref7.current;
-        var name = currItem.name;
-        return _objectSpread$j(_objectSpread$j({}, acc), {}, _defineProperty$2({}, name, currItem));
+
+        if (currItem !== null && currItem !== void 0 && currItem.name) {
+          var name = currItem.name;
+          return _objectSpread$j(_objectSpread$j({}, acc), {}, _defineProperty$2({}, name, currItem));
+        }
+
+        return acc;
       }, {});
       Object.keys(fileds).forEach(function (key) {
         var _formItemsMap$key;
@@ -41222,8 +41512,13 @@
       if (!Array.isArray(fileds)) throw new Error("setFields \u53C2\u6570\u9700\u8981 Array \u7C7B\u578B");
       var formItemsMap = formItemsRef.current.reduce(function (acc, _ref8) {
         var currItem = _ref8.current;
-        var name = currItem.name;
-        return _objectSpread$j(_objectSpread$j({}, acc), {}, _defineProperty$2({}, name, currItem));
+
+        if (currItem !== null && currItem !== void 0 && currItem.name) {
+          var name = currItem.name;
+          return _objectSpread$j(_objectSpread$j({}, acc), {}, _defineProperty$2({}, name, currItem));
+        }
+
+        return acc;
       }, {});
       fileds.forEach(function (filed) {
         var _formItemsMap$name;
@@ -41240,6 +41535,7 @@
 
     React.useImperativeHandle(ref, function () {
       return {
+        currentElement: formRef.current,
         submit: submitHandler,
         reset: resetHandler,
         getFieldValue: getFieldValue,
@@ -41276,7 +41572,7 @@
       style: style,
       onSubmit: submitHandler,
       onReset: resetHandler,
-      ref: ref
+      ref: formRef
     }, children));
   }, {
     FormItem: FormItem
@@ -41531,7 +41827,7 @@
         theme: "primary",
         onClick: onConfirmClick,
         className: "".concat(prefixCls, "__confirm")
-      }, confirmText);
+      }, confirmBtn && typeof confirmBtn === "string" ? confirmBtn : confirmText);
       var renderCancelBtn = cancelBtn && /*#__PURE__*/React__default["default"].isValidElement(cancelBtn) ? cancelBtn : defaultCancelBtn;
       var renderConfirmBtn = confirmBtn && /*#__PURE__*/React__default["default"].isValidElement(confirmBtn) ? confirmBtn : defaultConfirmBtn;
       var footerStyle = {
@@ -44962,8 +45258,8 @@
 
     var _useState = React.useState(void 0),
         _useState2 = _slicedToArray(_useState, 2),
-        formatedValue = _useState2[0],
-        changeFormatedValue = _useState2[1];
+        formattedValue = _useState2[0],
+        changeFormattedValue = _useState2[1];
 
     React.useEffect(function () {
       if (!startTime) return;
@@ -44971,7 +45267,7 @@
       var hour = /[h]{1}/.test(format) ? dayjsValue.hour() % 12 : dayjsValue.hour();
       var minute = dayjsValue.minute();
       var second = dayjsValue.second();
-      changeFormatedValue(function (preVal) {
+      changeFormattedValue(function (preVal) {
         return [{
           hour: padStart_1(String(hour), 2, "0"),
           minute: padStart_1(String(minute), 2, "0"),
@@ -44986,7 +45282,7 @@
       var hour = /[h]{1}/.test(format) ? dayjsValue.hour() % 12 : dayjsValue.hour();
       var minute = dayjsValue.minute();
       var second = dayjsValue.second();
-      changeFormatedValue(function (preVal) {
+      changeFormattedValue(function (preVal) {
         return [preVal[0], {
           hour: padStart_1(String(hour), 2, "0"),
           minute: padStart_1(String(minute), 2, "0"),
@@ -44996,6 +45292,16 @@
       });
     }, [endTime, format]);
     var handleInputChange = React.useCallback(function (type, result, index) {
+      var max = 59;
+
+      if (type === EPickerCols.hour) {
+        max = /[h]{1}/.test(format) ? 11 : 23;
+      }
+
+      if (isNaN(Number(result))) return;
+      result = String(result).length > 2 ? String(result).slice(1, 3) : result;
+      if (Number(result) > max) return;
+
       if (!isRangePicker) {
         var _currentDayjsValue$ty;
 
@@ -45026,10 +45332,10 @@
       var which = e.which;
 
       if ([up, down].includes(which)) {
-        var _formatedValue$index;
+        var _formattedValue$index;
 
         if (type === EPickerCols.meridiem) return;
-        var timeValue = formatedValue === null || formatedValue === void 0 ? void 0 : (_formatedValue$index = formatedValue[index]) === null || _formatedValue$index === void 0 ? void 0 : _formatedValue$index[type];
+        var timeValue = formattedValue === null || formattedValue === void 0 ? void 0 : (_formattedValue$index = formattedValue[index]) === null || _formattedValue$index === void 0 ? void 0 : _formattedValue$index[type];
         var current = timeValue ? Number(timeValue) : 0;
         var operate = which === up ? -1 : 1;
         var result = current + operate;
@@ -45043,7 +45349,7 @@
             result = maxHour;
           }
         } else if (result > 59) {
-          result = 1;
+          result = 0;
         } else if (result < 0) {
           result = 59;
         }
@@ -45062,7 +45368,7 @@
           if (input !== null && input !== void 0 && input.focus) input.focus();
         }
       }
-    }, [allowInput, format, formatedValue, handleInputChange]);
+    }, [allowInput, format, formattedValue, handleInputChange]);
     var TEXT_CONFIG = useTimePickerTextConfig();
 
     function renderMeridiemItem(text) {
@@ -45100,7 +45406,7 @@
         onChange: function onChange(e) {
           var _e$target2;
 
-          return handleInputChange(type, e === null || e === void 0 ? void 0 : (_e$target2 = e.target) === null || _e$target2 === void 0 ? void 0 : _e$target2.value);
+          return handleInputChange(type, e === null || e === void 0 ? void 0 : (_e$target2 = e.target) === null || _e$target2 === void 0 ? void 0 : _e$target2.value, index);
         },
         onBlur: function onBlur(e) {
           return _onBlur({
@@ -45127,7 +45433,7 @@
 
     return /* @__PURE__ */React__default["default"].createElement("div", {
       className: inputItemClass
-    }, isRangePicker ? /* @__PURE__ */React__default["default"].createElement(React__default["default"].Fragment, null, renderItems(formatedValue === null || formatedValue === void 0 ? void 0 : formatedValue[0], 0), " - ", renderItems(formatedValue === null || formatedValue === void 0 ? void 0 : formatedValue[1], 1)) : renderItems(formatedValue === null || formatedValue === void 0 ? void 0 : formatedValue[0], 0));
+    }, isRangePicker ? /* @__PURE__ */React__default["default"].createElement(React__default["default"].Fragment, null, renderItems(formattedValue === null || formattedValue === void 0 ? void 0 : formattedValue[0], 0), " - ", renderItems(formattedValue === null || formattedValue === void 0 ? void 0 : formattedValue[1], 1)) : renderItems(formattedValue === null || formattedValue === void 0 ? void 0 : formattedValue[0], 0));
   };
 
   var TimeRangePicker = function TimeRangePicker(props) {
@@ -45751,21 +46057,21 @@
     return str[0].toUpperCase().concat(str.substring(1, str.length));
   }
 
-  function getFirstDayOfMonth(_ref3) {
-    var year = _ref3.year,
-        month = _ref3.month;
+  function getFirstDayOfMonth(_ref) {
+    var year = _ref.year,
+        month = _ref.month;
     return new Date(year, month, 1);
   }
 
-  function getDaysInMonth(_ref4) {
-    var year = _ref4.year,
-        month = _ref4.month;
+  function getDaysInMonth(_ref2) {
+    var year = _ref2.year,
+        month = _ref2.month;
     return new Date(year, month + 1, 0).getDate();
   }
 
-  function getLastDayOfMonth(_ref5) {
-    var year = _ref5.year,
-        month = _ref5.month;
+  function getLastDayOfMonth(_ref3) {
+    var year = _ref3.year,
+        month = _ref3.month;
     return new Date(year, month, getDaysInMonth({
       year: year,
       month: month
@@ -45784,9 +46090,9 @@
     return isSameMonth(date1, date2) && date1.getDate() === date2.getDate();
   }
 
-  function isBetween(value, _ref6) {
-    var start = _ref6.start,
-        end = _ref6.end;
+  function isBetween(value, _ref4) {
+    var start = _ref4.start,
+        end = _ref4.end;
     var date = new Date(value.getFullYear(), value.getMonth(), value.getDate());
     var startTime = new Date(start.getFullYear(), start.getMonth(), start.getDate());
     var endTime = new Date(end.getFullYear(), end.getMonth(), end.getDate());
@@ -45818,18 +46124,20 @@
     return new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0);
   }
   function getDateObj(date) {
+    var tempDate = date;
+
     if (!(date instanceof Date)) {
-      throw new Error("date must be Date object");
+      tempDate = getToday();
     }
 
     return {
-      year: date.getFullYear(),
-      month: date.getMonth(),
-      date: date.getDate(),
-      hours: date.getHours(),
-      minutes: date.getMinutes(),
-      seconds: date.getSeconds(),
-      meridiem: date.getHours() > 11 ? "PM" : "AM"
+      year: tempDate.getFullYear(),
+      month: tempDate.getMonth(),
+      date: tempDate.getDate(),
+      hours: tempDate.getHours(),
+      minutes: tempDate.getMinutes(),
+      seconds: tempDate.getSeconds(),
+      meridiem: tempDate.getHours() > 11 ? "PM" : "AM"
     };
   }
   function setDateTime(d, hour, min, sec) {
@@ -45843,9 +46151,9 @@
   function subtractMonth(date, num) {
     var day = date.getDate();
     var newDate = new Date(date);
-    var monthNum = num;
+    var _num = num;
 
-    while (monthNum--) {
+    while (_num--) {
       newDate.setDate(0);
     }
 
@@ -45853,22 +46161,22 @@
     return newDate;
   }
   function addMonth(date, num) {
-    var monthNum = num;
-    if (num < 0) monthNum = 0;
+    var _num = num;
+    if (num < 0) _num = 0;
     var newDate = new Date(date);
-    newDate.setMonth(date.getMonth() + monthNum);
+    newDate.setMonth(date.getMonth() + _num);
     return newDate;
   }
-  function getWeeks(_ref7, _ref8) {
-    var year = _ref7.year,
-        month = _ref7.month;
-    var firstDayOfWeek = _ref8.firstDayOfWeek,
-        _ref8$disableDate = _ref8.disableDate,
-        disableDate = _ref8$disableDate === void 0 ? function () {
+  function getWeeks(_ref5, _ref6) {
+    var year = _ref5.year,
+        month = _ref5.month;
+    var firstDayOfWeek = _ref6.firstDayOfWeek,
+        _ref6$disableDate = _ref6.disableDate,
+        disableDate = _ref6$disableDate === void 0 ? function () {
       return false;
-    } : _ref8$disableDate,
-        minDate = _ref8.minDate,
-        maxDate = _ref8.maxDate;
+    } : _ref6$disableDate,
+        minDate = _ref6.minDate,
+        maxDate = _ref6.maxDate;
     var prependDay = getFirstDayOfMonth({
       year: year,
       month: month
@@ -45882,15 +46190,16 @@
       month: month
     });
     var daysArr = [];
+    var i = 1;
     var today = getToday();
 
-    for (var i = 1; i <= maxDays; i++) {
+    for (i; i <= maxDays; i++) {
       var currentDay = new Date(year, month, i);
       daysArr.push({
         text: i,
         active: false,
         value: currentDay,
-        disabled: disableDate(currentDay) || outOfRanges(currentDay, minDate, maxDate),
+        disabled: typeof disableDate === "function" && disableDate(currentDay) || outOfRanges(currentDay, minDate, maxDate),
         now: isSame(today, currentDay),
         firstDayOfMonth: i === 1,
         lastDayOfMonth: i === maxDays,
@@ -45898,16 +46207,15 @@
       });
     }
 
-    if (prependDay.getDay() !== firstDayOfWeek - 1) {
+    if (prependDay.getDay() !== firstDayOfWeek) {
       prependDay.setDate(0);
-      var FLAG = true;
 
-      while (FLAG) {
+      while (true) {
         daysArr.unshift({
           text: prependDay.getDate().toString(),
           active: false,
           value: new Date(prependDay),
-          disabled: disableDate(prependDay) || outOfRanges(prependDay, minDate, maxDate),
+          disabled: typeof disableDate === "function" && disableDate(prependDay) || outOfRanges(prependDay, minDate, maxDate),
           additional: true,
           type: "prev-month"
         });
@@ -45924,7 +46232,7 @@
         text: appendDay.getDate(),
         active: false,
         value: new Date(appendDay),
-        disabled: disableDate(appendDay) || outOfRanges(appendDay, minDate, maxDate),
+        disabled: typeof disableDate === "function" && disableDate(appendDay) || outOfRanges(appendDay, minDate, maxDate),
         additional: true,
         type: "next-month"
       });
@@ -45932,13 +46240,13 @@
 
     return chunk_1(daysArr, 7);
   }
-  function getYears(year, _ref9) {
-    var _ref9$disableDate = _ref9.disableDate,
-        disableDate = _ref9$disableDate === void 0 ? function () {
+  function getYears(year, _ref7) {
+    var _ref7$disableDate = _ref7.disableDate,
+        disableDate = _ref7$disableDate === void 0 ? function () {
       return false;
-    } : _ref9$disableDate,
-        minDate = _ref9.minDate,
-        maxDate = _ref9.maxDate;
+    } : _ref7$disableDate,
+        minDate = _ref7.minDate,
+        maxDate = _ref7.maxDate;
     var startYear = parseInt((year / 10).toString(), 10) * 10;
     var endYear = startYear + 9;
     var yearArr = [];
@@ -45950,7 +46258,7 @@
       var outOfRangeMonth = 0;
 
       for (var j = 0; j < 12; j++) {
-        var d = new Date(i, j, j === 11 ? 31 : 1);
+        var d = new Date(i, j);
         if (typeof disableDate === "function" && disableDate(d)) disabledMonth += 1;
         if (outOfRanges(d, minDate, maxDate)) outOfRangeMonth += 1;
       }
@@ -45966,16 +46274,15 @@
 
     return chunk_1(yearArr, 4);
   }
-  function getMonths(year, _ref10) {
-    var _ref10$disableDate = _ref10.disableDate,
-        disableDate = _ref10$disableDate === void 0 ? function () {
+  function getMonths(year, params) {
+    var _params$disableDate = params.disableDate,
+        disableDate = _params$disableDate === void 0 ? function () {
       return false;
-    } : _ref10$disableDate,
-        minDate = _ref10.minDate,
-        maxDate = _ref10.maxDate,
-        _ref10$monthText = _ref10.monthText,
-        monthText = _ref10$monthText === void 0 ? "" : _ref10$monthText;
-    var monthArr = [];
+    } : _params$disableDate,
+        minDate = params.minDate,
+        maxDate = params.maxDate,
+        monthLocal = params.monthLocal;
+    var MonthArr = [];
     var today = getToday();
 
     for (var i = 0; i <= 11; i++) {
@@ -45989,23 +46296,23 @@
 
       for (var j = 1; j <= daysInMonth; j++) {
         var d = new Date(year, i, j);
-        if (disableDate(d)) disabledDay += 1;
+        if (typeof disableDate === "function" && disableDate(d)) disabledDay += 1;
         if (outOfRanges(d, minDate, maxDate)) outOfRangeDay += 1;
       }
 
-      monthArr.push({
+      MonthArr.push({
         value: date,
         now: isSame(date, today, "month"),
         disabled: disabledDay === daysInMonth || outOfRangeDay === daysInMonth,
         active: false,
-        text: "".concat(date.getMonth() + 1, " ").concat(monthText)
+        text: monthLocal[date.getMonth()]
       });
     }
 
-    return chunk_1(monthArr, 4);
+    return chunk_1(MonthArr, 4);
   }
-  function flagActive(data, _ref11) {
-    var args = _extends({}, _ref11);
+  function flagActive(data, _ref8) {
+    var args = _extends({}, _ref8);
 
     var start = args.start,
         end = args.end,
@@ -46015,29 +46322,27 @@
     if (!end) {
       return data.map(function (row) {
         return row.map(function (item) {
-          Object.assign(item, {
-            active: isSame(item.value, start, type)
-          });
-          return item;
+          var _item = item;
+          _item.active = isSame(item.value, start, type);
+          return _item;
         });
       });
     }
 
     return data.map(function (row) {
       return row.map(function (item) {
+        var _item = item;
         var date = item.value;
         var isStart = isSame(start, date, type);
         var isEnd = isSame(end, date, type);
-        Object.assign(item, {
-          active: isStart || isEnd,
-          highlight: isBetween(date, {
-            start: start,
-            end: end
-          }),
-          startOfRange: isStart,
-          endOfRange: isEnd
+        _item.active = isStart || isEnd;
+        _item.highlight = isBetween(date, {
+          start: start,
+          end: end
         });
-        return item;
+        _item.startOfRange = isStart;
+        _item.endOfRange = isEnd;
+        return _item;
       });
     });
   }
@@ -46050,7 +46355,7 @@
         local = _useLocaleReceiver2[0],
         t = _useLocaleReceiver2[1];
 
-    var monthAriaLabel = t(local.monthAriaLabel);
+    var monthAriaLabel = t(local.months);
 
     var _useConfig = useConfig$1(),
         classPrefix = _useConfig.classPrefix;
@@ -46130,7 +46435,7 @@
         minDate: minDate,
         maxDate: maxDate,
         firstDayOfWeek: firstDayOfWeek,
-        monthText: monthAriaLabel
+        monthLocal: monthAriaLabel
       };
 
       switch (type) {
@@ -46211,7 +46516,7 @@
         local = _useLocaleReceiver2[0],
         t = _useLocaleReceiver2[1];
 
-    var monthAriaLabel = t(local.monthAriaLabel);
+    var monthAriaLabel = t(local.months);
 
     var _useConfig = useConfig$1(),
         classPrefix = _useConfig.classPrefix;
@@ -46458,7 +46763,7 @@
         minDate: minDate,
         maxDate: maxDate,
         firstDayOfWeek: firstDayOfWeek,
-        monthText: monthAriaLabel
+        monthLocal: monthAriaLabel
       };
 
       switch (type) {