@elliemae/ds-popper 1.60.0 → 2.0.0-alpha.12

package/cjs/PopperImpl.js

@@ -2,119 +2,112 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var _jsx = require('@babel/runtime/helpers/jsx');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _createClass = require('@babel/runtime/helpers/createClass');
-var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
-var _inherits = require('@babel/runtime/helpers/inherits');
-var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
-var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
-var React = require('react');
+var react = require('react');
 var dsUtilities = require('@elliemae/ds-utilities');
 var reactPopper = require('react-popper');
 var memoizeOne = require('memoize-one');
 var PopperContent = require('./PopperContent.js');
 var interaction = require('./interaction.js');
-require('@babel/runtime/helpers/extends');
-require('react-spring/renderprops.cjs');
-require('@elliemae/ds-overlay');
-require('./getArrowStylesBySize.js');
+var jsxRuntime = require('react/jsx-runtime');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
 var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _assertThisInitialized__default = /*#__PURE__*/_interopDefaultLegacy(_assertThisInitialized);
-var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
-var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
-var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var memoizeOne__default = /*#__PURE__*/_interopDefaultLegacy(memoizeOne);
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty__default['default'](target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf__default['default'](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default['default'](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default['default'](this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-var PopperImpl = /*#__PURE__*/function (_Component) {
-  _inherits__default['default'](PopperImpl, _Component);
-
-  var _super = _createSuper(PopperImpl);
-
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+class PopperImpl extends react.Component {
   // we use safeIsMounted because isMounted is not allowed by React.
-  function PopperImpl(props) {
-    var _this;
-
-    _classCallCheck__default['default'](this, PopperImpl);
-
-    _this = _super.call(this, props);
-    _this.safeIsMounted = false;
-    _this.handlePopperPlacementChange = memoizeOne__default['default'](function (placement) {
-      var onPlacementChange = _this.props.onPlacementChange;
+  constructor(props) {
+    super(props);
+    this.safeIsMounted = false;
+    this.handlePopperPlacementChange = memoizeOne__default["default"](placement => {
+      const {
+        onPlacementChange
+      } = this.props;
       onPlacementChange(placement);
     });
-    _this.state = {
+    this.state = {
       isOpen: false,
       destroyed: true
     }; // TODO: Fix the autobinding to remove this!!
 
-    _this.handleMouseEnter = _this.handleMouseEnter.bind(_assertThisInitialized__default['default'](_this));
-    _this.handleMouseLeave = _this.handleMouseLeave.bind(_assertThisInitialized__default['default'](_this));
-    _this.handleTriggerClick = _this.handleTriggerClick.bind(_assertThisInitialized__default['default'](_this));
-    _this.renderTarget = _this.renderTarget.bind(_assertThisInitialized__default['default'](_this));
-    _this.updatePopoverState = _this.updatePopoverState.bind(_assertThisInitialized__default['default'](_this));
-    _this.handlePopperPlacementChange = _this.handlePopperPlacementChange.bind(_assertThisInitialized__default['default'](_this));
-    _this.handleDestroyContent = _this.handleDestroyContent.bind(_assertThisInitialized__default['default'](_this));
-    _this.handleContentMouseEnter = _this.handleContentMouseEnter.bind(_assertThisInitialized__default['default'](_this));
-    _this.handleContentMouseLeave = _this.handleContentMouseLeave.bind(_assertThisInitialized__default['default'](_this));
-    return _this;
+    this.handleMouseEnter = this.handleMouseEnter.bind(this);
+    this.handleMouseLeave = this.handleMouseLeave.bind(this);
+    this.handleTriggerClick = this.handleTriggerClick.bind(this);
+    this.renderTarget = this.renderTarget.bind(this);
+    this.updatePopoverState = this.updatePopoverState.bind(this);
+    this.handlePopperPlacementChange = this.handlePopperPlacementChange.bind(this);
+    this.handleDestroyContent = this.handleDestroyContent.bind(this);
+    this.handleContentMouseEnter = this.handleContentMouseEnter.bind(this);
+    this.handleContentMouseLeave = this.handleContentMouseLeave.bind(this);
   } // this is needed to prevent setState on unmounted components
 
 
-  _createClass__default['default'](PopperImpl, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      this.safeIsMounted = true;
-    }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate() {
-      var _this$state = this.state,
-          isOpen = _this$state.isOpen,
-          destroyed = _this$state.destroyed;
-
-      if (isOpen === true && destroyed === true) {
-        // eslint-disable-next-line react/no-did-update-set-state
-        this.setState({
-          destroyed: false
-        });
-      }
+  componentDidMount() {
+    this.safeIsMounted = true;
+  }
+
+  componentDidUpdate() {
+    const {
+      isOpen,
+      destroyed
+    } = this.state;
+
+    if (isOpen === true && destroyed === true) {
+      // eslint-disable-next-line react/no-did-update-set-state
+      this.setState({
+        destroyed: false
+      });
     }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.safeIsMounted = false;
+  }
+
+  componentWillUnmount() {
+    this.safeIsMounted = false;
+  }
+
+  static getDerivedStateFromProps(nextProps, prevState) {
+    const {
+      isOpen
+    } = nextProps;
+    const {
+      prevPropIsOpen
+    } = prevState; // todo: this causes multiple rerenders
+
+    if (isOpen !== prevPropIsOpen) {
+      return {
+        isOpen,
+        prevPropIsOpen: isOpen
+      };
     }
-  }, {
-    key: "getInteractionObject",
-    value: function getInteractionObject(interaction$1) {
-      var _Interaction$CLICK$In;
-
-      var referenceProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var isOpen = this.props.isOpen;
-      if (isOpen !== undefined) return {};
-      return (_Interaction$CLICK$In = {}, _defineProperty__default['default'](_Interaction$CLICK$In, interaction.Interaction.CLICK, {
+
+    return null;
+  }
+
+  getInteractionObject(interaction$1) {
+    let referenceProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      isOpen
+    } = this.props;
+    if (isOpen !== undefined) return {};
+    return {
+      [interaction.Interaction.CLICK]: {
         handlers: {
           onClick: this.handleTriggerClick
         },
-        canClose: function canClose() {
-          return true;
-        }
-      }), _defineProperty__default['default'](_Interaction$CLICK$In, interaction.Interaction.HOVER, {
+        canClose: () => true
+      },
+      [interaction.Interaction.HOVER]: {
         handlers: {
           onMouseEnter: referenceProps.onMouseEnter || this.handleMouseEnter,
           onPointerEnter: referenceProps.onMouseEnter || this.handleMouseEnter,
@@ -122,263 +115,221 @@ var PopperImpl = /*#__PURE__*/function (_Component) {
           onPointerLeave: referenceProps.onMouseLeave || this.handleMouseLeave,
           onClick: this.handleTriggerClick
         },
-        canClose: function canClose(isOnTrigger, isOnPopper) {
-          return !isOnTrigger && !isOnPopper;
-        }
-      }), _Interaction$CLICK$In)[interaction$1] || {
-        handlers: {},
-        canClose: function canClose() {
-          return true;
-        }
-      };
-    }
-  }, {
-    key: "setOpen",
-    value: function setOpen(opening) {
-      var onOpen = this.props.onOpen;
-      var prevPropIsOpen = this.state.prevPropIsOpen;
-      if (!this.safeIsMounted) return;
-
-      if (prevPropIsOpen === undefined) {
-        this.setState({
-          isOpen: opening,
-          destroyed: false
-        });
+        canClose: (isOnTrigger, isOnPopper) => !isOnTrigger && !isOnPopper
       }
+    }[interaction$1] || {
+      handlers: {},
+      canClose: () => true
+    };
+  }
 
-      onOpen(opening);
-    }
-  }, {
-    key: "open",
-    value: function open() {
-      var _this2 = this;
-
-      clearTimeout(this.closeTimer);
-      var delayOpen = this.props.delayOpen;
-      this.openTimer = setTimeout(function () {
-        return _this2.setOpen(true);
-      }, delayOpen);
-    }
-  }, {
-    key: "close",
-    value: function close() {
-      var _this3 = this;
-
-      clearTimeout(this.openTimer);
-      var _this$props = this.props,
-          delayClose = _this$props.delayClose,
-          _this$props$onClose = _this$props.onClose,
-          onClose = _this$props$onClose === void 0 ? function () {
-        return null;
-      } : _this$props$onClose;
-      this.closeTimer = setTimeout(function () {
-        _this3.setOpen(false);
-
-        onClose();
-      }, delayClose);
-    }
-  }, {
-    key: "handleTriggerClick",
-    value: function handleTriggerClick(e) {
-      var triggerComponent = this.props.triggerComponent;
-
-      var _ref = dsUtilities.get(triggerComponent, 'props') || {},
-          onClick = _ref.onClick;
+  setOpen(opening) {
+    const {
+      onOpen
+    } = this.props;
+    const {
+      prevPropIsOpen
+    } = this.state;
+    if (!this.safeIsMounted) return;
 
-      this.open();
-      if (dsUtilities.isFunction(onClick)) onClick(e);
-    }
-  }, {
-    key: "handleContentMouseEnter",
-    value: function handleContentMouseEnter() {
-      this.isMouseOverContent = true;
-    }
-  }, {
-    key: "handleContentMouseLeave",
-    value: function handleContentMouseLeave() {
-      var _this4 = this;
-
-      this.isMouseOverContent = false;
-      var _this$props$onClose2 = this.props.onClose,
-          onClose = _this$props$onClose2 === void 0 ? function () {
-        return null;
-      } : _this$props$onClose2;
-      setTimeout(function () {
-        if (!_this4.isMouseOverTarget) {
-          _this4.setOpen(false);
-
-          onClose();
-        }
-      }, 10);
-    }
-  }, {
-    key: "handleMouseEnter",
-    value: function handleMouseEnter() {
-      this.isMouseOverTarget = true;
-      this.open();
-    }
-  }, {
-    key: "handleMouseLeave",
-    value: function handleMouseLeave() {
-      var _this5 = this;
-
-      this.isMouseOverTarget = false;
-      setTimeout(function () {
-        if (!_this5.isMouseOverContent) {
-          _this5.close();
-        }
-      }, 10);
-    }
-  }, {
-    key: "updatePopoverState",
-    value: function updatePopoverState(popperData) {
-      this.handlePopperPlacementChange(popperData.placement);
-      return popperData;
-    }
-  }, {
-    key: "handleDestroyContent",
-    value: function handleDestroyContent() {
+    if (prevPropIsOpen === undefined) {
       this.setState({
-        destroyed: true
+        isOpen: opening,
+        destroyed: false
       });
     }
-  }, {
-    key: "renderTarget",
-    value: function renderTarget(_ref2) {
-      var ref = _ref2.ref;
-      var isOpen = this.state.isOpen;
-      var _this$props2 = this.props,
-          triggerComponent = _this$props2.triggerComponent,
-          interactionType = _this$props2.interactionType,
-          renderReference = _this$props2.renderReference;
-      var componentInnerRef = dsUtilities.get(triggerComponent, ['props', 'innerRef'], function () {
-        return null;
-      });
-      var compRef = dsUtilities.isDOMTypeElement(triggerComponent) ? {
-        ref: ref
-      } : {
-        innerRef: dsUtilities.mergeRefs(ref, componentInnerRef)
-      };
-      var triggerHandler = this.getInteractionObject(interactionType, triggerComponent.props).handlers;
 
-      var targetProps = _objectSpread(_objectSpread(_objectSpread({}, triggerHandler), compRef), {}, {
-        'aria-haspopup': true,
-        'aria-expanded': isOpen
-      });
+    onOpen(opening);
+  }
+
+  open() {
+    clearTimeout(this.closeTimer);
+    const {
+      delayOpen
+    } = this.props;
+    this.openTimer = setTimeout(() => this.setOpen(true), delayOpen);
+  }
+
+  close() {
+    clearTimeout(this.openTimer);
+    const {
+      delayClose,
+      onClose = () => null
+    } = this.props;
+    this.closeTimer = setTimeout(() => {
+      this.setOpen(false);
+      onClose();
+    }, delayClose);
+  }
+
+  handleTriggerClick(e) {
+    const {
+      triggerComponent
+    } = this.props;
+    const {
+      onClick
+    } = dsUtilities.get(triggerComponent, 'props') || {};
+    this.open();
+    if (dsUtilities.isFunction(onClick)) onClick(e);
+  }
+
+  handleContentMouseEnter() {
+    this.isMouseOverContent = true;
+  }
 
-      if (renderReference) {
-        return renderReference(_objectSpread({
-          ref: ref
-        }, targetProps));
+  handleContentMouseLeave() {
+    this.isMouseOverContent = false;
+    const {
+      onClose = () => null
+    } = this.props;
+    setTimeout(() => {
+      if (!this.isMouseOverTarget) {
+        this.setOpen(false);
+        onClose();
       }
+    }, 10);
+  }
 
-      return dsUtilities.getComponentFromProps(triggerComponent, targetProps);
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this6 = this;
-
-      var _this$state2 = this.state,
-          isOpen = _this$state2.isOpen,
-          destroyed = _this$state2.destroyed;
-      var _this$props3 = this.props,
-          placement = _this$props3.placement,
-          interactionType = _this$props3.interactionType,
-          showArrow = _this$props3.showArrow,
-          arrowSize = _this$props3.arrowSize,
-          arrowGap = _this$props3.arrowGap,
-          preventOverflow = _this$props3.preventOverflow,
-          customPopper = _this$props3.children,
-          usePortal = _this$props3.usePortal,
-          blockName = _this$props3.blockName,
-          contentComponent = _this$props3.contentComponent,
-          openAnimationConfig = _this$props3.openAnimationConfig,
-          closeAnimationConfig = _this$props3.closeAnimationConfig,
-          modifiers = _this$props3.modifiers,
-          referenceNode = _this$props3.referenceNode,
-          containerProps = _this$props3.containerProps,
-          zIndex = _this$props3.zIndex,
-          hideIfNotVisible = _this$props3.hideIfNotVisible;
-
-      var allModifiers = _objectSpread({
-        offset: {
-          enabled: showArrow,
-          offset: "0, ".concat(arrowSize + arrowGap)
-        },
-        preventOverflow: {
-          enabled: true,
-          padding: 0,
-          boundariesElement: preventOverflow
-        },
-        updatePopoverState: {
-          enabled: true,
-          fn: this.updatePopoverState,
-          order: 900
-        }
-      }, modifiers);
-
-      var triggerHandler = this.getInteractionObject(interactionType).handlers;
-      var popperContentProps = {
-        hideIfNotVisible: hideIfNotVisible,
-        containerProps: containerProps,
-        isOpen: isOpen,
-        destroyed: isOpen ? false : destroyed,
-        arrowSize: arrowSize,
-        blockName: blockName,
-        showArrow: showArrow,
-        modifiers: allModifiers,
-        contentComponent: contentComponent,
-        onContentDestroyed: this.handleDestroyContent,
-        onClickOutside: function onClickOutside() {
-          return _this6.close();
-        },
-        placement: placement,
-        usePortal: usePortal,
-        openAnimationConfig: openAnimationConfig,
-        closeAnimationConfig: closeAnimationConfig,
-        onMouseEnter: interactionType === interaction.Interaction.HOVER ? this.handleContentMouseEnter : undefined,
-        onMouseLeave: interactionType === interaction.Interaction.HOVER ? this.handleContentMouseLeave : undefined,
-        referenceNode: referenceNode,
-        zIndex: zIndex
-      };
+  handleMouseEnter() {
+    this.isMouseOverTarget = true;
+    this.open();
+  }
 
-      if (customPopper && typeof customPopper === 'function') {
-        return /*#__PURE__*/React__default['default'].createElement(reactPopper.Manager, null, customPopper({
-          Reference: reactPopper.Reference,
-          triggerHandler: triggerHandler,
-          content: /*#__PURE__*/React__default['default'].createElement(PopperContent, popperContentProps)
-        }));
+  handleMouseLeave() {
+    this.isMouseOverTarget = false;
+    setTimeout(() => {
+      if (!this.isMouseOverContent) {
+        this.close();
       }
+    }, 10);
+  }
+
+  updatePopoverState(popperData) {
+    this.handlePopperPlacementChange(popperData.placement);
+    return popperData;
+  }
+
+  handleDestroyContent() {
+    this.setState({
+      destroyed: true
+    });
+  }
 
-      return /*#__PURE__*/React__default['default'].createElement(reactPopper.Manager, null, /*#__PURE__*/React__default['default'].createElement(reactPopper.Reference, null, this.renderTarget), /*#__PURE__*/React__default['default'].createElement(PopperContent, popperContentProps));
+  renderTarget(_ref) {
+    let {
+      ref
+    } = _ref;
+    const {
+      isOpen
+    } = this.state;
+    const {
+      triggerComponent,
+      interactionType,
+      renderReference
+    } = this.props;
+    const componentInnerRef = dsUtilities.get(triggerComponent, ['props', 'innerRef'], () => null);
+    const compRef = dsUtilities.isDOMTypeElement(triggerComponent) ? {
+      ref
+    } : {
+      innerRef: dsUtilities.mergeRefs(ref, componentInnerRef)
+    };
+    const triggerHandler = this.getInteractionObject(interactionType, triggerComponent.props).handlers;
+
+    const targetProps = _objectSpread(_objectSpread(_objectSpread({}, triggerHandler), compRef), {}, {
+      'aria-haspopup': true,
+      'aria-expanded': isOpen
+    });
+
+    if (renderReference) {
+      return renderReference(_objectSpread({
+        ref
+      }, targetProps));
     }
-  }], [{
-    key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(nextProps, prevState) {
-      var isOpen = nextProps.isOpen;
-      var prevPropIsOpen = prevState.prevPropIsOpen; // todo: this causes multiple rerenders
-
-      if (isOpen !== prevPropIsOpen) {
-        return {
-          isOpen: isOpen,
-          prevPropIsOpen: isOpen
-        };
-      }
 
-      return null;
+    return dsUtilities.getComponentFromProps(triggerComponent, targetProps);
+  }
+
+  render() {
+    const {
+      isOpen,
+      destroyed
+    } = this.state;
+    const {
+      placement,
+      interactionType,
+      showArrow,
+      arrowSize,
+      arrowGap,
+      preventOverflow,
+      children: customPopper,
+      usePortal,
+      blockName,
+      contentComponent,
+      openAnimationConfig,
+      closeAnimationConfig,
+      modifiers,
+      referenceNode,
+      containerProps,
+      zIndex,
+      hideIfNotVisible
+    } = this.props;
+
+    const allModifiers = _objectSpread({
+      offset: {
+        enabled: showArrow,
+        offset: "0, ".concat(arrowSize + arrowGap)
+      },
+      preventOverflow: {
+        enabled: true,
+        padding: 0,
+        boundariesElement: preventOverflow
+      },
+      updatePopoverState: {
+        enabled: true,
+        fn: this.updatePopoverState,
+        order: 900
+      }
+    }, modifiers);
+
+    const triggerHandler = this.getInteractionObject(interactionType).handlers;
+    const popperContentProps = {
+      hideIfNotVisible,
+      containerProps,
+      isOpen,
+      destroyed: isOpen ? false : destroyed,
+      arrowSize,
+      blockName,
+      showArrow,
+      modifiers: allModifiers,
+      contentComponent,
+      onContentDestroyed: this.handleDestroyContent,
+      onClickOutside: () => this.close(),
+      placement,
+      usePortal,
+      openAnimationConfig,
+      closeAnimationConfig,
+      onMouseEnter: interactionType === interaction.Interaction.HOVER ? this.handleContentMouseEnter : undefined,
+      onMouseLeave: interactionType === interaction.Interaction.HOVER ? this.handleContentMouseLeave : undefined,
+      referenceNode,
+      zIndex
+    };
+
+    if (customPopper && typeof customPopper === 'function') {
+      return /*#__PURE__*/_jsx__default["default"](reactPopper.Manager, {}, void 0, customPopper({
+        Reference: reactPopper.Reference,
+        triggerHandler,
+        content: /*#__PURE__*/jsxRuntime.jsx(PopperContent, _objectSpread({}, popperContentProps))
+      }));
     }
-  }]);
 
-  return PopperImpl;
-}(React.Component);
+    return /*#__PURE__*/_jsx__default["default"](reactPopper.Manager, {}, void 0, /*#__PURE__*/_jsx__default["default"](reactPopper.Reference, {}, void 0, this.renderTarget), /*#__PURE__*/jsxRuntime.jsx(PopperContent, _objectSpread({}, popperContentProps)));
+  }
+
+}
 
 Object.defineProperty(exports, 'Reference', {
   enumerable: true,
-  get: function () {
-    return reactPopper.Reference;
-  }
+  get: function () { return reactPopper.Reference; }
 });
 exports.PopperContent = PopperContent;
-exports['default'] = PopperImpl;
-//# sourceMappingURL=PopperImpl.js.map
+exports["default"] = PopperImpl;