intergalactic 15.87.0-prerelease.3 → 15.88.0

package/libs/popper/lib/cjs/Popper.js

@@ -0,0 +1,596 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _core = _interopRequireWildcard(require("@semcore/core"));
+var _react = _interopRequireDefault(require("react"));
+var _canUseDOM = _interopRequireDefault(require("@semcore/utils/lib/canUseDOM"));
+var _flexBox = require("@semcore/flex-box");
+var _outsideClick = _interopRequireDefault(require("@semcore/outside-click"));
+var _portal = _interopRequireWildcard(require("@semcore/portal"));
+var _neighborLocation = _interopRequireDefault(require("@semcore/neighbor-location"));
+var _ref5 = require("@semcore/utils/lib/ref");
+var _useFocusLock = require("@semcore/utils/lib/use/useFocusLock");
+var _assignProps3 = require("@semcore/utils/lib/assignProps");
+var _pick = _interopRequireDefault(require("@semcore/utils/lib/pick"));
+var _logger = _interopRequireDefault(require("@semcore/utils/lib/logger"));
+var _uniqueID = _interopRequireDefault(require("@semcore/utils/lib/uniqueID"));
+var _animation = require("@semcore/animation");
+var _useCssVariable = require("@semcore/utils/lib/useCssVariable");
+var _ThemeProvider = require("@semcore/utils/lib/ThemeProvider");
+var _ScreenReaderOnly = require("@semcore/utils/lib/ScreenReaderOnly");
+var _keyboardFocusEnhance = _interopRequireWildcard(require("@semcore/utils/lib/enhances/keyboardFocusEnhance"));
+var _createPopper2 = _interopRequireDefault(require("./createPopper"));
+var _excluded = ["placement", "modifiers", "strategy", "onFirstUpdate"],
+  _excluded2 = ["onKeyDown"],
+  _excluded3 = ["visible", "disablePortal", "interaction", "placement", "duration", "animationsDisabled", "disableEnforceFocus"],
+  _excluded4 = ["onKeyDown"];
+/*__reshadow-styles__:"./style/popper.shadow.css"*/
+var style = ( /*__reshadow_css_start__*/_core.sstyled.insert( /*__inner_css_start__*/".___SPopper_ufzkc_gg_{outline:0;z-index:var(--intergalactic-z-index-popper, 700);color:var(--intergalactic-text-primary, #191b23)}.___SPopper_ufzkc_gg_.__keyboardFocused_ufzkc_gg_:focus:after{position:absolute;display:block;content:\"\";top:0;right:0;bottom:0;left:0;box-shadow:var(--intergalactic-keyboard-focus, 0px 0px 0px 3px rgba(0, 143, 248, 0.5));pointer-events:none}.___SFocusHint_ufzkc_gg_{display:none}.___STrigger_ufzkc_gg_:focus .___SFocusHint_ufzkc_gg_,.___STrigger_ufzkc_gg_:focus-within .___SFocusHint_ufzkc_gg_{display:inline}" /*__inner_css_end__*/, "ufzkc_gg_") /*__reshadow_css_end__*/, {
+  "__SPopper": "___SPopper_ufzkc_gg_",
+  "_keyboardFocused": "__keyboardFocused_ufzkc_gg_",
+  "__SFocusHint": "___SFocusHint_ufzkc_gg_",
+  "__STrigger": "___STrigger_ufzkc_gg_"
+});
+function isObject(obj) {
+  return (0, _typeof2["default"])(obj) === 'object' && !Array.isArray(obj);
+}
+function someArray(arr1, arr2) {
+  return arr1.filter(function (i) {
+    return arr2.indexOf(i) !== -1;
+  });
+}
+var useUpdatePopperEveryFrame = function useUpdatePopperEveryFrame(popperRef) {
+  var nextAnimationFrameRef = _react["default"].useRef(-1);
+  var handleAnimationFrame = _react["default"].useCallback(function (until) {
+    var _popperRef$current;
+    if (until < Date.now()) return;
+    (_popperRef$current = popperRef.current) === null || _popperRef$current === void 0 ? void 0 : _popperRef$current.update();
+    nextAnimationFrameRef.current = requestAnimationFrame(function () {
+      return handleAnimationFrame(until);
+    });
+  }, []);
+  _react["default"].useEffect(function () {
+    return function () {
+      return cancelAnimationFrame(nextAnimationFrameRef.current);
+    };
+  }, []);
+  return handleAnimationFrame;
+};
+var MODIFIERS_OPTIONS = ['offset', 'preventOverflow', 'arrow', 'flip', 'computeStyles', 'eventListeners'];
+var Popper = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(Popper, _Component);
+  var _super = (0, _createSuper2["default"])(Popper);
+  // timer: ReturnType<typeof setTimeout>;
+  // observer: ResizeObserver;
+
+  function Popper(props) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, Popper);
+    _this = _super.call(this, props);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "eventsInteractionMap", {
+      click: {
+        trigger: [['onClick'], ['onClick']],
+        popper: []
+      },
+      hover: {
+        trigger: [['onMouseEnter', 'onKeyboardFocus'], ['onMouseLeave', 'onBlur']],
+        popper: [['onMouseEnter', 'onFocusCapture'], ['onMouseLeave']]
+      },
+      focus: {
+        trigger: [['onFocus'], ['onBlur']],
+        // to intercept faster than onBlur on the trigger
+        popper: [['onFocusCapture'], ['onBlur']]
+      },
+      none: {
+        trigger: [],
+        popper: []
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "triggerRef", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "focusableTriggerReturnFocusToRef", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "popperRef", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "popper", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "createTriggerRef", function (ref) {
+      if (ref && _this.triggerRef.current !== ref) {
+        (0, _ref5.setRef)(_this.triggerRef, ref);
+        _this.createPopper();
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "createPopperRef", function (ref) {
+      if (ref && _this.popperRef.current !== ref) {
+        (0, _ref5.setRef)(_this.popperRef, ref);
+        _this.createPopper();
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getPopperOptions", function () {
+      var _this$asProps = _this.asProps,
+        placement = _this$asProps.placement,
+        modifiers = _this$asProps.modifiers,
+        strategy = _this$asProps.strategy,
+        onFirstUpdate = _this$asProps.onFirstUpdate,
+        other = (0, _objectWithoutProperties2["default"])(_this$asProps, _excluded);
+      var optionsModifiers = (0, _pick["default"])(other, MODIFIERS_OPTIONS);
+      var modifiersFallback = [];
+      if (typeof optionsModifiers.offset === 'number') {
+        optionsModifiers.offset = [0, optionsModifiers.offset];
+      }
+      var modifiersOptions = MODIFIERS_OPTIONS.filter(function (name) {
+        return optionsModifiers[name] !== undefined;
+      }).map(function (name) {
+        return {
+          name: name,
+          options: isObject(optionsModifiers[name]) ? optionsModifiers[name] : (0, _defineProperty2["default"])({}, name, optionsModifiers[name])
+        };
+      });
+      modifiersOptions.push({
+        name: 'computeStyles',
+        options: {
+          gpuAcceleration: false
+        }
+      });
+      var modifiersMerge = [].concat(modifiersFallback, (0, _toConsumableArray2["default"])(modifiersOptions)).concat(modifiers);
+      return {
+        placement: placement,
+        strategy: strategy,
+        onFirstUpdate: (0, _assignProps3.callAllEventHandlers)(onFirstUpdate, function () {
+          var _this$observer, _this$observer2;
+          (_this$observer = _this.observer) === null || _this$observer === void 0 ? void 0 : _this$observer.observe(_this.triggerRef.current);
+          (_this$observer2 = _this.observer) === null || _this$observer2 === void 0 ? void 0 : _this$observer2.observe(_this.popperRef.current);
+        }),
+        modifiers: modifiersMerge
+      };
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handlerKeyDown", function (e) {
+      var visible = _this.asProps.visible;
+      if (visible && e.key === 'Escape') {
+        e.stopPropagation();
+        _this.bindHandlerChangeVisibleWithTimer(false)(e);
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "bindHandlerKeyDown", function (onKeyDown) {
+      return (0, _assignProps3.callAllEventHandlers)(onKeyDown, _this.handlerKeyDown);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "bindHandlerChangeVisibleWithTimer", function (visible, component) {
+      return function (e) {
+        var currentTarget = e === null || e === void 0 ? void 0 : e.currentTarget;
+        _this.handlerChangeVisibleWithTimer(visible, e, function () {
+          clearTimeout(_this.timerMultiTrigger);
+          // instance popper is not here yet because the popperRef did not have time to come
+          _this.timerMultiTrigger = setTimeout(function () {
+            if (visible && component === 'trigger' && _this.popper.current && currentTarget) {
+              if (_this.popper.current.state.elements.reference !== currentTarget) {
+                _this.popper.current.state.elements.reference = currentTarget;
+                // for update
+                _this.popper.current.setOptions({});
+              }
+            }
+          }, 0);
+        });
+      };
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handlerChangeVisibleWithTimer", function (visible, e, cb) {
+      var _this$asProps2 = _this.asProps,
+        timeout = _this$asProps2.timeout,
+        disabled = _this$asProps2.disabled;
+      if (typeof disabled === 'boolean' && disabled && visible) return;
+      var handlers = _this.handlers;
+      var timeoutConfig = typeof timeout === 'number' ? [timeout, timeout] : timeout;
+      var latency = visible ? timeoutConfig[0] : timeoutConfig[1];
+      clearTimeout(_this.timer);
+      _this.timer = setTimeout(function () {
+        handlers.visible(visible, e);
+        cb();
+      }, latency);
+    });
+    if ((0, _canUseDOM["default"])()) {
+      _this.observer = new ResizeObserver(function () {
+        requestAnimationFrame(function () {
+          var _this$popper$current;
+          (_this$popper$current = _this.popper.current) === null || _this$popper$current === void 0 ? void 0 : _this$popper$current.update();
+        });
+      });
+    }
+    return _this;
+  }
+  (0, _createClass2["default"])(Popper, [{
+    key: "uncontrolledProps",
+    value: function uncontrolledProps() {
+      return {
+        visible: null
+      };
+    }
+  }, {
+    key: "createPopper",
+    value: function createPopper() {
+      if (!this.triggerRef.current || !this.popperRef.current) return;
+      this.popper.current = (0, _createPopper2["default"])(this.triggerRef.current, this.popperRef.current, this.getPopperOptions());
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var _this2 = this;
+      var popperProps = ['strategy', 'placement', 'offset', 'preventOverflow', 'arrow', 'flip', 'computeStyles', 'eventListeners', 'onFirstUpdate'];
+      if (this.popper.current && popperProps.some(function (propName) {
+        return prevProps[propName] !== _this2.asProps[propName];
+      })) {
+        this.popper.current.setOptions(this.getPopperOptions());
+      }
+    }
+  }, {
+    key: "destroyPopper",
+    value: function destroyPopper() {
+      var _this$observer3;
+      clearTimeout(this.timer);
+      clearTimeout(this.timerMultiTrigger);
+      (_this$observer3 = this.observer) === null || _this$observer3 === void 0 ? void 0 : _this$observer3.disconnect();
+      if (this.popper.current) {
+        this.popper.current.destroy();
+        this.popper.current = null;
+      }
+    }
+  }, {
+    key: "handlersFromInteraction",
+    value: function handlersFromInteraction(interaction, component, visible) {
+      var _this3 = this;
+      var eventInteraction = typeof interaction === 'string' ? this.eventsInteractionMap[interaction] : interaction;
+      var _eventInteraction$com = (0, _slicedToArray2["default"])(eventInteraction[component], 2),
+        _eventInteraction$com2 = _eventInteraction$com[0],
+        showEvents = _eventInteraction$com2 === void 0 ? [] : _eventInteraction$com2,
+        _eventInteraction$com3 = _eventInteraction$com[1],
+        hideEvents = _eventInteraction$com3 === void 0 ? [] : _eventInteraction$com3;
+      var crossEvents = someArray(showEvents, hideEvents);
+      var handlers = {};
+      showEvents.forEach(function (action) {
+        handlers[action] = _this3.bindHandlerChangeVisibleWithTimer(true, component);
+      });
+      hideEvents.forEach(function (action) {
+        handlers[action] = _this3.bindHandlerChangeVisibleWithTimer(false, component);
+      });
+      crossEvents.forEach(function (action) {
+        handlers[action] = visible ? _this3.bindHandlerChangeVisibleWithTimer(false, component) : _this3.bindHandlerChangeVisibleWithTimer(true, component);
+      });
+      return handlers;
+    }
+  }, {
+    key: "getTriggerProps",
+    value: function getTriggerProps() {
+      var _this$asProps3 = this.asProps,
+        visible = _this$asProps3.visible,
+        interaction = _this$asProps3.interaction,
+        disableEnforceFocus = _this$asProps3.disableEnforceFocus;
+      // @ts-ignore
+      var _this$handlersFromInt = this.handlersFromInteraction(interaction, 'trigger', visible),
+        onKeyDown = _this$handlersFromInt.onKeyDown,
+        interactionProps = (0, _objectWithoutProperties2["default"])(_this$handlersFromInt, _excluded2);
+      return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
+        ref: this.createTriggerRef,
+        active: visible,
+        interaction: interaction
+      }, interactionProps), {}, {
+        onKeyDown: this.bindHandlerKeyDown(onKeyDown),
+        focusableTriggerReturnFocusToRef: this.focusableTriggerReturnFocusToRef,
+        disableEnforceFocus: disableEnforceFocus,
+        popperRef: this.popperRef
+      });
+    }
+  }, {
+    key: "getPopperProps",
+    value: function getPopperProps() {
+      var _this$asProps4 = this.asProps,
+        visible = _this$asProps4.visible,
+        disablePortal = _this$asProps4.disablePortal,
+        interaction = _this$asProps4.interaction,
+        placement = _this$asProps4.placement,
+        duration = _this$asProps4.duration,
+        animationsDisabled = _this$asProps4.animationsDisabled,
+        disableEnforceFocus = _this$asProps4.disableEnforceFocus,
+        other = (0, _objectWithoutProperties2["default"])(_this$asProps4, _excluded3);
+      // @ts-ignore
+      var _this$handlersFromInt2 = this.handlersFromInteraction(interaction, 'popper', visible),
+        onKeyDown = _this$handlersFromInt2.onKeyDown,
+        interactionProps = (0, _objectWithoutProperties2["default"])(_this$handlersFromInt2, _excluded4);
+      return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
+        ref: this.createPopperRef,
+        triggerRef: this.triggerRef,
+        visible: visible,
+        interaction: interaction,
+        disablePortal: disablePortal
+      }, interactionProps), {}, {
+        onKeyDown: this.bindHandlerKeyDown(onKeyDown),
+        placement: placement,
+        duration: duration,
+        animationsDisabled: animationsDisabled,
+        popper: this.popper,
+        focusableTriggerReturnFocusToRef: this.focusableTriggerReturnFocusToRef,
+        disableEnforceFocus: disableEnforceFocus
+      });
+    }
+  }, {
+    key: "setContext",
+    value: function setContext() {
+      return {
+        popper: this.popper,
+        setTrigger: this.createTriggerRef,
+        setPopper: this.createPopperRef
+      };
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.destroyPopper();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$asProps5 = this.asProps,
+        Children = _this$asProps5.Children,
+        visible = _this$asProps5.visible,
+        root = _this$asProps5.root,
+        onOutsideClick = _this$asProps5.onOutsideClick,
+        excludeRefs = _this$asProps5.excludeRefs;
+      return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, visible ? /*#__PURE__*/_react["default"].createElement(_outsideClick["default"], {
+        root: root,
+        excludeRefs: [this.triggerRef, this.popperRef].concat((0, _toConsumableArray2["default"])(excludeRefs)),
+        onOutsideClick: (0, _assignProps3.callAllEventHandlers)(onOutsideClick, this.bindHandlerChangeVisibleWithTimer(false))
+      }) : null, /*#__PURE__*/_react["default"].createElement(Children, null));
+    }
+  }]);
+  return Popper;
+}(_core.Component);
+(0, _defineProperty2["default"])(Popper, "displayName", 'Popper');
+(0, _defineProperty2["default"])(Popper, "style", style);
+(0, _defineProperty2["default"])(Popper, "defaultProps", {
+  defaultVisible: false,
+  placement: 'auto',
+  modifiers: [],
+  arrow: {
+    padding: 6
+  },
+  strategy: 'absolute',
+  interaction: 'click',
+  timeout: 0,
+  excludeRefs: []
+});
+(0, _defineProperty2["default"])(Popper, "enhance", [(0, _uniqueID["default"])(), (0, _useCssVariable.cssVariableEnhance)({
+  variable: '--intergalactic-duration-popper',
+  fallback: '200',
+  map: Number.parseInt,
+  prop: 'duration'
+})]);
+var getElementNestingIndexes = function getElementNestingIndexes(element) {
+  var chain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set([element, document.body]);
+  if (!(element !== null && element !== void 0 && element.parentElement)) return [];
+  var index = Array.from(element.parentElement.children).indexOf(element);
+  if (chain.has(element.parentElement)) return [index];
+  chain.add(element.parentElement);
+  return [].concat((0, _toConsumableArray2["default"])(getElementNestingIndexes(element.parentElement, chain)), [index]);
+};
+var useReturnFocusEl = function useReturnFocusEl(interaction, onKeyboardFocus, disable) {
+  var _React$useState = _react["default"].useState(null),
+    _React$useState2 = (0, _slicedToArray2["default"])(_React$useState, 2),
+    returnFocusEl = _React$useState2[0],
+    setReturnFocusEl = _React$useState2[1];
+  var focusSourceRef = (0, _keyboardFocusEnhance.useFocusSource)();
+  var handleFocus = _react["default"].useCallback(function (event) {
+    if (focusSourceRef.current !== 'keyboard') return;
+    onKeyboardFocus === null || onKeyboardFocus === void 0 ? void 0 : onKeyboardFocus();
+    if (disable) return;
+    if (interaction !== 'focus') return;
+    if (!event.relatedTarget) {
+      setReturnFocusEl('after');
+    }
+    var focusToNesting = getElementNestingIndexes(event.target);
+    var focusFromNesting = getElementNestingIndexes(event.relatedTarget);
+    var nestingLength = Math.max(focusToNesting.length, focusFromNesting.length);
+    for (var i = 0; i < nestingLength; i++) {
+      if (focusFromNesting[i] === undefined) {
+        setReturnFocusEl('after'); // <div tabIndex="0" id="focus1" /> <input id="focus2" /> </div>
+        return;
+      }
+      if (focusFromNesting[i] > focusToNesting[i]) {
+        setReturnFocusEl('before'); // <input id="focus2" /> <input id="focus1" />
+        return;
+      }
+    }
+    setReturnFocusEl('after'); // <input id="focus1" /> <input id="focus2" />
+  }, [interaction, onKeyboardFocus, disable]);
+  var handleFocusReturnElBlur = _react["default"].useCallback(function () {
+    setTimeout(function () {
+      return setReturnFocusEl(null);
+    }, 0);
+  }, []);
+  return {
+    returnFocusEl: returnFocusEl,
+    handleFocus: handleFocus,
+    handleFocusReturnElBlur: handleFocusReturnElBlur
+  };
+};
+var useFocusCatch = function useFocusCatch(active, popperRef) {
+  var activeRef = _react["default"].useRef(active);
+  activeRef.current = active;
+  var _React$useState3 = _react["default"].useState(false),
+    _React$useState4 = (0, _slicedToArray2["default"])(_React$useState3, 2),
+    focusCatch = _React$useState4[0],
+    setFocusCatch = _React$useState4[1];
+  var handleFocusCatchBlur = _react["default"].useCallback(function () {
+    return setFocusCatch(false);
+  }, []);
+  var handleFocusCatchRef = _react["default"].useCallback(function (node) {
+    if (activeRef.current) return setFocusCatch(false);
+    if (!(0, _useFocusLock.isFocusInside)(popperRef.current) && document.activeElement !== document.body) return setFocusCatch(false);
+    node === null || node === void 0 ? void 0 : node.focus();
+  }, []);
+  _react["default"].useEffect(function () {
+    if (!active) return;
+    if (!popperRef.current) return;
+    return function () {
+      setTimeout(function () {
+        if (activeRef.current) return;
+        if (!(0, _useFocusLock.isFocusInside)(popperRef.current) && document.activeElement !== document.body) return;
+        setFocusCatch(true);
+      }, 1);
+    };
+  }, [active]);
+  return {
+    focusCatch: focusCatch,
+    handleFocusCatchBlur: handleFocusCatchBlur,
+    handleFocusCatchRef: handleFocusCatchRef
+  };
+};
+var focusCatcherStyles = {
+  position: 'fixed'
+};
+function Trigger(props) {
+  var _ref = arguments[0];
+  var STrigger = _flexBox.Box;
+  var SFocusHint = 'span';
+  var Children = props.Children,
+    interaction = props.interaction,
+    focusableTriggerReturnFocusToRef = props.focusableTriggerReturnFocusToRef,
+    focusHint = props.focusHint,
+    onKeyboardFocus = props.onKeyboardFocus,
+    disableEnforceFocus = props.disableEnforceFocus,
+    active = props.active,
+    popperRef = props.popperRef;
+  var _useReturnFocusEl = useReturnFocusEl(interaction, onKeyboardFocus, disableEnforceFocus),
+    returnFocusEl = _useReturnFocusEl.returnFocusEl,
+    handleFocusReturnElBlur = _useReturnFocusEl.handleFocusReturnElBlur,
+    handleFocus = _useReturnFocusEl.handleFocus;
+  var _useFocusCatch = useFocusCatch(active, popperRef),
+    focusCatch = _useFocusCatch.focusCatch,
+    handleFocusCatchBlur = _useFocusCatch.handleFocusCatchBlur,
+    handleFocusCatchRef = _useFocusCatch.handleFocusCatchRef;
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, returnFocusEl === 'before' && /*#__PURE__*/_react["default"].createElement("div", {
+    tabIndex: "0",
+    ref: focusableTriggerReturnFocusToRef,
+    onBlur: handleFocusReturnElBlur,
+    style: focusCatcherStyles
+  }), /*#__PURE__*/_react["default"].createElement(STrigger, (0, _core.assignProps)({
+    "inline": true,
+    "role": 'button',
+    "aria-haspopup": true,
+    "onFocus": handleFocus
+  }, _ref), /*#__PURE__*/_react["default"].createElement(Children, null)), focusHint && false && /*#__PURE__*/_react["default"].createElement(SFocusHint, {
+    "aria-live": "polite"
+  }, /*#__PURE__*/_react["default"].createElement(_ScreenReaderOnly.ScreenReaderOnly, null, focusHint)), returnFocusEl === 'after' && /*#__PURE__*/_react["default"].createElement("div", {
+    tabIndex: "0",
+    ref: focusableTriggerReturnFocusToRef,
+    onBlur: handleFocusReturnElBlur,
+    style: focusCatcherStyles
+  }), focusCatch && /*#__PURE__*/_react["default"].createElement("div", {
+    tabIndex: "0",
+    ref: handleFocusCatchRef,
+    onBlur: handleFocusCatchBlur,
+    style: focusCatcherStyles
+  }));
+}
+function PopperPopper(props) {
+  var _ref2 = arguments[0],
+    _ref3;
+  var SPopper = _animation.Scale;
+  var Children = props.Children,
+    styles = props.styles,
+    visible = props.visible,
+    disablePortal = props.disablePortal,
+    ignorePortalsStacking = props.ignorePortalsStacking,
+    disableEnforceFocus = props.disableEnforceFocus,
+    triggerRef = props.triggerRef,
+    interaction = props.interaction,
+    autoFocus = props.autoFocus,
+    controlsLength = props.controlsLength,
+    duration = props.duration,
+    animationsDisabled = props.animationsDisabled,
+    popper = props.popper,
+    focusableTriggerReturnFocusToRef = props.focusableTriggerReturnFocusToRef;
+  var ref = _react["default"].useRef(null);
+
+  // https://github.com/facebook/react/issues/11387
+  var stopPropagation = _react["default"].useCallback(function (event) {
+    return event.stopPropagation();
+  }, []);
+  (0, _useFocusLock.useFocusLock)(ref, autoFocus, interaction === 'focus' ? focusableTriggerReturnFocusToRef : triggerRef, !visible || disableEnforceFocus);
+  (0, _ThemeProvider.useContextTheme)(ref, visible);
+  var updatePopperEveryFrame = useUpdatePopperEveryFrame(popper);
+  var handleAnimationStart = _react["default"].useCallback(function (duration) {
+    if (duration > 0) {
+      updatePopperEveryFrame(Date.now() + Math.min(duration, 2000));
+    }
+  }, [updatePopperEveryFrame]);
+  var handleAnimationEnd = _react["default"].useCallback(function () {
+    var _popper$current;
+    (_popper$current = popper.current) === null || _popper$current === void 0 ? void 0 : _popper$current.update();
+  }, []);
+  var animationCtx = _react["default"].useContext(_animation.animationContext);
+  _react["default"].useEffect(function () {
+    if (!ignorePortalsStacking) return;
+    if (!animationCtx) return;
+    var unsubscribeAnimationStart = animationCtx.onAnimationStart(handleAnimationStart);
+    var unsubscribeAnimationEnd = animationCtx.onAnimationEnd(handleAnimationEnd);
+    return function () {
+      unsubscribeAnimationStart();
+      unsubscribeAnimationEnd();
+    };
+  }, [animationCtx, ignorePortalsStacking]);
+  return _ref3 = (0, _core.sstyled)(styles), /*#__PURE__*/_react["default"].createElement(_portal["default"], _ref3.cn("Portal", {
+    "disablePortal": disablePortal,
+    "ignorePortalsStacking": ignorePortalsStacking
+  }), /*#__PURE__*/_react["default"].createElement(_neighborLocation["default"], _ref3.cn("NeighborLocation", {
+    "controlsLength": controlsLength
+  }), /*#__PURE__*/_react["default"].createElement(SPopper, _ref3.cn("SPopper", (0, _objectSpread2["default"])({}, (0, _core.assignProps)({
+    "animationsDisabled": animationsDisabled,
+    "visible": visible,
+    "duration": [duration, duration / 2],
+    "ref": ref,
+    "onClick": stopPropagation,
+    "onContextMenu": stopPropagation,
+    "onDoubleClick": stopPropagation,
+    "onDrag": stopPropagation,
+    "onDragEnd": stopPropagation,
+    "onDragEnter": stopPropagation,
+    "onDragExit": stopPropagation,
+    "onDragLeave": stopPropagation,
+    "onDragOver": stopPropagation,
+    "onDragStart": stopPropagation,
+    "onDrop": stopPropagation,
+    "onMouseDown": stopPropagation,
+    "onMouseMove": stopPropagation,
+    "onMouseOver": stopPropagation,
+    "onMouseOut": stopPropagation,
+    "onMouseUp": stopPropagation,
+    "onKeyDown": stopPropagation,
+    "onKeyPress": stopPropagation,
+    "onKeyUp": stopPropagation,
+    "onFocus": stopPropagation,
+    "onBlur": stopPropagation,
+    "onChange": stopPropagation,
+    "onInput": stopPropagation,
+    "onInvalid": stopPropagation,
+    "onReset": stopPropagation,
+    "onSubmit": stopPropagation
+  }, _ref2))), /*#__PURE__*/_react["default"].createElement(_portal.PortalProvider, _ref3.cn("PortalProvider", {
+    "value": ref
+  }), /*#__PURE__*/_react["default"].createElement(Children, _ref3.cn("Children", {}))))));
+}
+PopperPopper.enhance = [(0, _keyboardFocusEnhance["default"])()];
+var _default = (0, _core["default"])(Popper, {
+  Trigger: Trigger,
+  Popper: PopperPopper
+});
+exports["default"] = _default;
+//# sourceMappingURL=Popper.js.map