0.2.0 - Mid migration

web/node_modules/react-popper/lib/cjs/Manager.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ManagerReferenceNodeSetterContext = exports.ManagerReferenceNodeContext = void 0;
+
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _createReactContext = _interopRequireDefault(require("@hypnosphi/create-react-context"));
+
+var ManagerReferenceNodeContext = (0, _createReactContext.default)();
+exports.ManagerReferenceNodeContext = ManagerReferenceNodeContext;
+var ManagerReferenceNodeSetterContext = (0, _createReactContext.default)();
+exports.ManagerReferenceNodeSetterContext = ManagerReferenceNodeSetterContext;
+
+var Manager =
+/*#__PURE__*/
+function (_React$Component) {
+  (0, _inheritsLoose2.default)(Manager, _React$Component);
+
+  function Manager() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "referenceNode", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "setReferenceNode", function (newReferenceNode) {
+      if (newReferenceNode && _this.referenceNode !== newReferenceNode) {
+        _this.referenceNode = newReferenceNode;
+
+        _this.forceUpdate();
+      }
+    });
+    return _this;
+  }
+
+  var _proto = Manager.prototype;
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.referenceNode = null;
+  };
+
+  _proto.render = function render() {
+    return React.createElement(ManagerReferenceNodeContext.Provider, {
+      value: this.referenceNode
+    }, React.createElement(ManagerReferenceNodeSetterContext.Provider, {
+      value: this.setReferenceNode
+    }, this.props.children));
+  };
+
+  return Manager;
+}(React.Component);
+
+exports.default = Manager;

web/node_modules/react-popper/lib/cjs/Manager.js.flow

@@ -0,0 +1,38 @@
+// @flow
+import * as React from 'react';
+import createContext, { type Context } from '@hypnosphi/create-react-context';
+export const ManagerReferenceNodeContext: Context<?HTMLElement> = createContext();
+export const ManagerReferenceNodeSetterContext: Context<
+  void | ((?HTMLElement) => void)
+> = createContext();
+
+export type ManagerProps = {
+  children: React.Node,
+};
+
+export default class Manager extends React.Component<ManagerProps> {
+  referenceNode: ?HTMLElement;
+
+  setReferenceNode = (newReferenceNode: ?HTMLElement) => {
+    if (newReferenceNode && this.referenceNode !== newReferenceNode) {
+      this.referenceNode = newReferenceNode;
+      this.forceUpdate();
+    }
+  };
+
+  componentWillUnmount() {
+    this.referenceNode = null;
+  }
+
+  render() {
+    return (
+      <ManagerReferenceNodeContext.Provider value={this.referenceNode}>
+        <ManagerReferenceNodeSetterContext.Provider
+          value={this.setReferenceNode}
+        >
+          {this.props.children}
+        </ManagerReferenceNodeSetterContext.Provider>
+      </ManagerReferenceNodeContext.Provider>
+    );
+  }
+}

web/node_modules/react-popper/lib/cjs/Popper.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Popper;
+exports.placements = exports.InnerPopper = void 0;
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _deepEqual = _interopRequireDefault(require("deep-equal"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _popper = _interopRequireDefault(require("popper.js"));
+
+var _Manager = require("./Manager");
+
+var _utils = require("./utils");
+
+var initialStyle = {
+  position: 'absolute',
+  top: 0,
+  left: 0,
+  opacity: 0,
+  pointerEvents: 'none'
+};
+var initialArrowStyle = {};
+
+var InnerPopper =
+/*#__PURE__*/
+function (_React$Component) {
+  (0, _inheritsLoose2.default)(InnerPopper, _React$Component);
+
+  function InnerPopper() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "state", {
+      data: undefined,
+      placement: undefined
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "popperInstance", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "popperNode", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "arrowNode", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "setPopperNode", function (popperNode) {
+      if (!popperNode || _this.popperNode === popperNode) return;
+      (0, _utils.setRef)(_this.props.innerRef, popperNode);
+      _this.popperNode = popperNode;
+
+      _this.updatePopperInstance();
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "setArrowNode", function (arrowNode) {
+      _this.arrowNode = arrowNode;
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "updateStateModifier", {
+      enabled: true,
+      order: 900,
+      fn: function fn(data) {
+        var placement = data.placement;
+
+        _this.setState({
+          data: data,
+          placement: placement
+        });
+
+        return data;
+      }
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "getOptions", function () {
+      return {
+        placement: _this.props.placement,
+        eventsEnabled: _this.props.eventsEnabled,
+        positionFixed: _this.props.positionFixed,
+        modifiers: (0, _extends2.default)({}, _this.props.modifiers, {
+          arrow: (0, _extends2.default)({}, _this.props.modifiers && _this.props.modifiers.arrow, {
+            enabled: !!_this.arrowNode,
+            element: _this.arrowNode
+          }),
+          applyStyle: {
+            enabled: false
+          },
+          updateStateModifier: _this.updateStateModifier
+        })
+      };
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "getPopperStyle", function () {
+      return !_this.popperNode || !_this.state.data ? initialStyle : (0, _extends2.default)({
+        position: _this.state.data.offsets.popper.position
+      }, _this.state.data.styles);
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "getPopperPlacement", function () {
+      return !_this.state.data ? undefined : _this.state.placement;
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "getArrowStyle", function () {
+      return !_this.arrowNode || !_this.state.data ? initialArrowStyle : _this.state.data.arrowStyles;
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "getOutOfBoundariesState", function () {
+      return _this.state.data ? _this.state.data.hide : undefined;
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "destroyPopperInstance", function () {
+      if (!_this.popperInstance) return;
+
+      _this.popperInstance.destroy();
+
+      _this.popperInstance = null;
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "updatePopperInstance", function () {
+      _this.destroyPopperInstance();
+
+      var _assertThisInitialize = (0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)),
+          popperNode = _assertThisInitialize.popperNode;
+
+      var referenceElement = _this.props.referenceElement;
+      if (!referenceElement || !popperNode) return;
+      _this.popperInstance = new _popper.default(referenceElement, popperNode, _this.getOptions());
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "scheduleUpdate", function () {
+      if (_this.popperInstance) {
+        _this.popperInstance.scheduleUpdate();
+      }
+    });
+    return _this;
+  }
+
+  var _proto = InnerPopper.prototype;
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
+    // If the Popper.js options have changed, update the instance (destroy + create)
+    if (this.props.placement !== prevProps.placement || this.props.referenceElement !== prevProps.referenceElement || this.props.positionFixed !== prevProps.positionFixed || !(0, _deepEqual.default)(this.props.modifiers, prevProps.modifiers, {
+      strict: true
+    })) {
+      // develop only check that modifiers isn't being updated needlessly
+      if (process.env.NODE_ENV === "development") {
+        if (this.props.modifiers !== prevProps.modifiers && this.props.modifiers != null && prevProps.modifiers != null && (0, _utils.shallowEqual)(this.props.modifiers, prevProps.modifiers)) {
+          console.warn("'modifiers' prop reference updated even though all values appear the same.\nConsider memoizing the 'modifiers' object to avoid needless rendering.");
+        }
+      }
+
+      this.updatePopperInstance();
+    } else if (this.props.eventsEnabled !== prevProps.eventsEnabled && this.popperInstance) {
+      this.props.eventsEnabled ? this.popperInstance.enableEventListeners() : this.popperInstance.disableEventListeners();
+    } // A placement difference in state means popper determined a new placement
+    // apart from the props value. By the time the popper element is rendered with
+    // the new position Popper has already measured it, if the place change triggers
+    // a size change it will result in a misaligned popper. So we schedule an update to be sure.
+
+
+    if (prevState.placement !== this.state.placement) {
+      this.scheduleUpdate();
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    (0, _utils.setRef)(this.props.innerRef, null);
+    this.destroyPopperInstance();
+  };
+
+  _proto.render = function render() {
+    return (0, _utils.unwrapArray)(this.props.children)({
+      ref: this.setPopperNode,
+      style: this.getPopperStyle(),
+      placement: this.getPopperPlacement(),
+      outOfBoundaries: this.getOutOfBoundariesState(),
+      scheduleUpdate: this.scheduleUpdate,
+      arrowProps: {
+        ref: this.setArrowNode,
+        style: this.getArrowStyle()
+      }
+    });
+  };
+
+  return InnerPopper;
+}(React.Component);
+
+exports.InnerPopper = InnerPopper;
+(0, _defineProperty2.default)(InnerPopper, "defaultProps", {
+  placement: 'bottom',
+  eventsEnabled: true,
+  referenceElement: undefined,
+  positionFixed: false
+});
+var placements = _popper.default.placements;
+exports.placements = placements;
+
+function Popper(_ref) {
+  var referenceElement = _ref.referenceElement,
+      props = (0, _objectWithoutPropertiesLoose2.default)(_ref, ["referenceElement"]);
+  return React.createElement(_Manager.ManagerReferenceNodeContext.Consumer, null, function (referenceNode) {
+    return React.createElement(InnerPopper, (0, _extends2.default)({
+      referenceElement: referenceElement !== undefined ? referenceElement : referenceNode
+    }, props));
+  });
+}

web/node_modules/react-popper/lib/cjs/Popper.js.flow

@@ -0,0 +1,239 @@
+// @flow
+import deepEqual from "deep-equal";
+import * as React from 'react';
+import PopperJS, {
+  type Placement,
+  type Instance,
+  type Data,
+  type Modifiers,
+  type ReferenceObject,
+} from 'popper.js';
+import type { Style } from 'typed-styles';
+import { ManagerReferenceNodeContext } from './Manager';
+import { unwrapArray, setRef, shallowEqual } from './utils';
+import { type Ref } from "./RefTypes";
+
+type ReferenceElement = ReferenceObject | HTMLElement | null;
+type StyleOffsets = { top: number, left: number };
+type StylePosition = { position: 'absolute' | 'fixed' };
+
+export type PopperArrowProps = {
+  ref: Ref,
+  style: StyleOffsets & Style,
+};
+export type PopperChildrenProps = {|
+  ref: Ref,
+  style: StyleOffsets & StylePosition & Style,
+  placement: Placement,
+  outOfBoundaries: ?boolean,
+  scheduleUpdate: () => void,
+  arrowProps: PopperArrowProps,
+|};
+export type PopperChildren = PopperChildrenProps => React.Node;
+
+export type PopperProps = {
+  children: PopperChildren,
+  eventsEnabled?: boolean,
+  innerRef?: Ref,
+  modifiers?: Modifiers,
+  placement?: Placement,
+  positionFixed?: boolean,
+  referenceElement?: ReferenceElement,
+};
+
+type PopperState = {
+  data: ?Data,
+  placement: ?Placement,
+};
+
+const initialStyle = {
+  position: 'absolute',
+  top: 0,
+  left: 0,
+  opacity: 0,
+  pointerEvents: 'none',
+};
+
+const initialArrowStyle = {};
+
+export class InnerPopper extends React.Component<PopperProps, PopperState> {
+  static defaultProps = {
+    placement: 'bottom',
+    eventsEnabled: true,
+    referenceElement: undefined,
+    positionFixed: false,
+  };
+
+  state = {
+    data: undefined,
+    placement: undefined,
+  };
+
+  popperInstance: ?Instance;
+
+  popperNode: ?HTMLElement = null;
+  arrowNode: ?HTMLElement = null;
+
+  setPopperNode = (popperNode: ?HTMLElement) => {
+    if (!popperNode || this.popperNode === popperNode) return;
+
+    setRef(this.props.innerRef, popperNode);
+    this.popperNode = popperNode;
+
+    this.updatePopperInstance();
+  };
+
+  setArrowNode = (arrowNode: ?HTMLElement) => {
+    this.arrowNode = arrowNode;
+  };
+
+  updateStateModifier = {
+    enabled: true,
+    order: 900,
+    fn: (data: Object) => {
+      const { placement } = data;
+      this.setState({ data, placement });
+      return data;
+    },
+  };
+
+  getOptions = () => ({
+    placement: this.props.placement,
+    eventsEnabled: this.props.eventsEnabled,
+    positionFixed: this.props.positionFixed,
+    modifiers: {
+      ...this.props.modifiers,
+      arrow: {
+        ...(this.props.modifiers && this.props.modifiers.arrow),
+        enabled: !!this.arrowNode,
+        element: this.arrowNode,
+      },
+      applyStyle: { enabled: false },
+      updateStateModifier: this.updateStateModifier,
+    },
+  });
+
+  getPopperStyle = () =>
+    !this.popperNode || !this.state.data
+      ? initialStyle
+      : {
+          position: this.state.data.offsets.popper.position,
+          ...this.state.data.styles,
+        };
+
+  getPopperPlacement = () =>
+    !this.state.data ? undefined : this.state.placement;
+
+  getArrowStyle = () =>
+    !this.arrowNode || !this.state.data
+      ? initialArrowStyle
+      : this.state.data.arrowStyles;
+
+  getOutOfBoundariesState = () =>
+    this.state.data ? this.state.data.hide : undefined;
+
+  destroyPopperInstance = () => {
+    if (!this.popperInstance) return;
+
+    this.popperInstance.destroy();
+    this.popperInstance = null;
+  };
+
+  updatePopperInstance = () => {
+    this.destroyPopperInstance();
+
+    const { popperNode } = this;
+    const { referenceElement } = this.props;
+
+    if (!referenceElement || !popperNode) return;
+
+    this.popperInstance = new PopperJS(
+      referenceElement,
+      popperNode,
+      this.getOptions()
+    );
+  };
+
+  scheduleUpdate = () => {
+    if (this.popperInstance) {
+      this.popperInstance.scheduleUpdate();
+    }
+  };
+
+  componentDidUpdate(prevProps: PopperProps, prevState: PopperState) {
+    // If the Popper.js options have changed, update the instance (destroy + create)
+    if (
+      this.props.placement !== prevProps.placement ||
+      this.props.referenceElement !== prevProps.referenceElement ||
+      this.props.positionFixed !== prevProps.positionFixed ||
+      !deepEqual(this.props.modifiers, prevProps.modifiers, {strict: true})
+    ) {
+
+      // develop only check that modifiers isn't being updated needlessly
+      if (process.env.NODE_ENV === "development") {
+        if (
+          this.props.modifiers !== prevProps.modifiers &&
+          this.props.modifiers != null &&
+          prevProps.modifiers != null &&
+          shallowEqual(this.props.modifiers, prevProps.modifiers)
+        ) {
+          console.warn("'modifiers' prop reference updated even though all values appear the same.\nConsider memoizing the 'modifiers' object to avoid needless rendering.");
+        }
+      }
+
+      this.updatePopperInstance();
+    } else if (
+      this.props.eventsEnabled !== prevProps.eventsEnabled &&
+      this.popperInstance
+    ) {
+      this.props.eventsEnabled
+        ? this.popperInstance.enableEventListeners()
+        : this.popperInstance.disableEventListeners();
+    }
+
+    // A placement difference in state means popper determined a new placement
+    // apart from the props value. By the time the popper element is rendered with
+    // the new position Popper has already measured it, if the place change triggers
+    // a size change it will result in a misaligned popper. So we schedule an update to be sure.
+    if (prevState.placement !== this.state.placement) {
+      this.scheduleUpdate();
+    }
+  }
+
+  componentWillUnmount() {
+    setRef(this.props.innerRef, null)
+    this.destroyPopperInstance();
+  }
+
+  render() {
+    return unwrapArray(this.props.children)({
+      ref: this.setPopperNode,
+      style: this.getPopperStyle(),
+      placement: this.getPopperPlacement(),
+      outOfBoundaries: this.getOutOfBoundariesState(),
+      scheduleUpdate: this.scheduleUpdate,
+      arrowProps: {
+        ref: this.setArrowNode,
+        style: this.getArrowStyle(),
+      },
+    });
+  }
+}
+
+const placements = PopperJS.placements;
+export { placements };
+
+export default function Popper({ referenceElement, ...props }: PopperProps) {
+  return (
+    <ManagerReferenceNodeContext.Consumer>
+      {(referenceNode) => (
+        <InnerPopper
+          referenceElement={
+            referenceElement !== undefined ? referenceElement : referenceNode
+          }
+          {...props}
+        />
+      )}
+    </ManagerReferenceNodeContext.Consumer>
+  );
+}

web/node_modules/react-popper/lib/cjs/RefTypes.js

@@ -0,0 +1 @@
+"use strict";

web/node_modules/react-popper/lib/cjs/RefTypes.js.flow

@@ -0,0 +1,4 @@
+type RefHandler = (?HTMLElement) => void;
+type RefObject = { current?: HTMLElement};
+
+export type Ref = RefHandler | RefObject;

web/node_modules/react-popper/lib/cjs/Reference.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Reference;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _warning = _interopRequireDefault(require("warning"));
+
+var _Manager = require("./Manager");
+
+var _utils = require("./utils");
+
+var InnerReference =
+/*#__PURE__*/
+function (_React$Component) {
+  (0, _inheritsLoose2.default)(InnerReference, _React$Component);
+
+  function InnerReference() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "refHandler", function (node) {
+      (0, _utils.setRef)(_this.props.innerRef, node);
+      (0, _utils.safeInvoke)(_this.props.setReferenceNode, node);
+    });
+    return _this;
+  }
+
+  var _proto = InnerReference.prototype;
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    (0, _utils.setRef)(this.props.innerRef, null);
+  };
+
+  _proto.render = function render() {
+    (0, _warning.default)(Boolean(this.props.setReferenceNode), '`Reference` should not be used outside of a `Manager` component.');
+    return (0, _utils.unwrapArray)(this.props.children)({
+      ref: this.refHandler
+    });
+  };
+
+  return InnerReference;
+}(React.Component);
+
+function Reference(props) {
+  return React.createElement(_Manager.ManagerReferenceNodeSetterContext.Consumer, null, function (setReferenceNode) {
+    return React.createElement(InnerReference, (0, _extends2.default)({
+      setReferenceNode: setReferenceNode
+    }, props));
+  });
+}

web/node_modules/react-popper/lib/cjs/Reference.js.flow

@@ -0,0 +1,47 @@
+// @flow
+import * as React from 'react';
+import warning from 'warning';
+import { ManagerReferenceNodeSetterContext } from './Manager';
+import { safeInvoke, unwrapArray, setRef } from './utils';
+import { type Ref } from "./RefTypes";
+
+export type ReferenceChildrenProps = { ref: Ref };
+export type ReferenceProps = {
+  children: ReferenceChildrenProps => React.Node,
+  innerRef?: Ref,
+};
+
+type InnerReferenceProps = {
+  setReferenceNode?: (?HTMLElement) => void,
+};
+
+class InnerReference extends React.Component<
+  ReferenceProps & InnerReferenceProps
+> {
+  refHandler = (node: ?HTMLElement) => {
+    setRef(this.props.innerRef, node)
+    safeInvoke(this.props.setReferenceNode, node);
+  };
+
+  componentWillUnmount() {
+    setRef(this.props.innerRef, null)
+  }
+
+  render() {
+    warning(
+      Boolean(this.props.setReferenceNode),
+      '`Reference` should not be used outside of a `Manager` component.'
+    );
+    return unwrapArray(this.props.children)({ ref: this.refHandler });
+  }
+}
+
+export default function Reference(props: ReferenceProps) {
+  return (
+    <ManagerReferenceNodeSetterContext.Consumer>
+      {(setReferenceNode) => (
+        <InnerReference setReferenceNode={setReferenceNode} {...props} />
+      )}
+    </ManagerReferenceNodeSetterContext.Consumer>
+  );
+}

web/node_modules/react-popper/lib/cjs/__typings__/main-test.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Test = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _ = require("..");
+
+// Please remember to update also the TypeScript test files that can
+// be found under `/typings/tests` please. Thanks! 🤗
+var Test = function Test() {
+  var _React$createElement;
+
+  return _react.default.createElement(_.Manager, null, _react.default.createElement(_.Reference, null), _react.default.createElement(_.Reference, null, function (_ref) {
+    var ref = _ref.ref;
+    return _react.default.createElement("div", {
+      ref: ref
+    });
+  }), _react.default.createElement(_.Popper // $FlowExpectError: should be boolean
+  , (_React$createElement = {
+    eventsEnabled: "foo"
+  }, _React$createElement["eventsEnabled"] = true, _React$createElement.positionFixed = 2, _React$createElement["positionFixed"] = true, _React$createElement.modifiers = {
+    flip: {
+      enabled: 'bar',
+      order: 'foo'
+    }
+  }, _React$createElement["modifiers"] = {
+    flip: {
+      enabled: false
+    }
+  }, _React$createElement), function (_ref2) {
+    var ref = _ref2.ref,
+        style = _ref2.style,
+        placement = _ref2.placement,
+        outOfBoundaries = _ref2.outOfBoundaries,
+        scheduleUpdate = _ref2.scheduleUpdate,
+        arrowProps = _ref2.arrowProps;
+    return _react.default.createElement("div", {
+      ref: ref,
+      style: (0, _extends2.default)({}, style, {
+        opacity: outOfBoundaries ? 0 : 1
+      }),
+      "data-placement": placement,
+      onClick: function onClick() {
+        return scheduleUpdate();
+      }
+    }, "Popper", _react.default.createElement("div", {
+      ref: arrowProps.ref,
+      style: arrowProps.style
+    }));
+  }), _react.default.createElement(_.Popper, null, function (_ref3) {
+    var ref = _ref3.ref,
+        style = _ref3.style,
+        placement = _ref3.placement;
+    return _react.default.createElement("div", {
+      ref: ref,
+      style: style,
+      "data-placement": placement
+    }, "Popper");
+  }));
+};
+
+exports.Test = Test;

web/node_modules/react-popper/lib/cjs/__typings__/main-test.js.flow

@@ -0,0 +1,52 @@
+// @flow
+
+// Please remember to update also the TypeScript test files that can
+// be found under `/typings/tests` please. Thanks! 🤗
+
+import React from 'react';
+import { Manager, Reference, Popper } from '..';
+
+export const Test = () => (
+  <Manager>
+    {/* $FlowExpectError: empty children */}
+    <Reference />
+    <Reference>{({ ref }) => <div ref={ref} />}</Reference>
+    <Popper
+      // $FlowExpectError: should be boolean
+      eventsEnabled="foo"
+      eventsEnabled
+      // $FlowExpectError: should be boolean
+      positionFixed={2}
+      positionFixed
+      // $FlowExpectError: enabled should be boolean, order number
+      modifiers={{ flip: { enabled: 'bar', order: 'foo' } }}
+      modifiers={{ flip: { enabled: false } }}
+    >
+      {({
+        ref,
+        style,
+        placement,
+        outOfBoundaries,
+        scheduleUpdate,
+        arrowProps,
+      }) => (
+        <div
+          ref={ref}
+          style={{ ...style, opacity: outOfBoundaries ? 0 : 1 }}
+          data-placement={placement}
+          onClick={() => scheduleUpdate()}
+        >
+          Popper
+          <div ref={arrowProps.ref} style={arrowProps.style} />
+        </div>
+      )}
+    </Popper>
+    <Popper>
+      {({ ref, style, placement }) => (
+        <div ref={ref} style={style} data-placement={placement}>
+          Popper
+        </div>
+      )}
+    </Popper>
+  </Manager>
+);

web/node_modules/react-popper/lib/cjs/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Popper", {
+  enumerable: true,
+  get: function get() {
+    return _Popper.default;
+  }
+});
+Object.defineProperty(exports, "placements", {
+  enumerable: true,
+  get: function get() {
+    return _Popper.placements;
+  }
+});
+Object.defineProperty(exports, "Manager", {
+  enumerable: true,
+  get: function get() {
+    return _Manager.default;
+  }
+});
+Object.defineProperty(exports, "Reference", {
+  enumerable: true,
+  get: function get() {
+    return _Reference.default;
+  }
+});
+
+var _Popper = _interopRequireWildcard(require("./Popper"));
+
+var _Manager = _interopRequireDefault(require("./Manager"));
+
+var _Reference = _interopRequireDefault(require("./Reference"));

web/node_modules/react-popper/lib/cjs/index.js.flow

@@ -0,0 +1,26 @@
+// @flow
+
+// Public components
+import Popper, { placements } from './Popper';
+import Manager from './Manager';
+import Reference from './Reference';
+export { Popper, placements, Manager, Reference };
+
+// Public types
+import type { Placement } from 'popper.js';
+import type { ManagerProps } from './Manager';
+import type { ReferenceProps, ReferenceChildrenProps } from './Reference';
+import type {
+  PopperChildrenProps,
+  PopperArrowProps,
+  PopperProps,
+} from './Popper';
+export type {
+  Placement,
+  ManagerProps,
+  ReferenceProps,
+  ReferenceChildrenProps,
+  PopperChildrenProps,
+  PopperArrowProps,
+  PopperProps,
+};

web/node_modules/react-popper/lib/cjs/utils.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setRef = exports.shallowEqual = exports.safeInvoke = exports.unwrapArray = void 0;
+
+/**
+ * Takes an argument and if it's an array, returns the first item in the array,
+ * otherwise returns the argument. Used for Preact compatibility.
+ */
+var unwrapArray = function unwrapArray(arg) {
+  return Array.isArray(arg) ? arg[0] : arg;
+};
+/**
+ * Takes a maybe-undefined function and arbitrary args and invokes the function
+ * only if it is defined.
+ */
+
+
+exports.unwrapArray = unwrapArray;
+
+var safeInvoke = function safeInvoke(fn) {
+  if (typeof fn === "function") {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    return fn.apply(void 0, args);
+  }
+};
+/**
+ * Does a shallow equality check of two objects by comparing the reference
+ * equality of each value.
+ */
+
+
+exports.safeInvoke = safeInvoke;
+
+var shallowEqual = function shallowEqual(objA, objB) {
+  var aKeys = Object.keys(objA);
+  var bKeys = Object.keys(objB);
+
+  if (bKeys.length !== aKeys.length) {
+    return false;
+  }
+
+  for (var i = 0; i < bKeys.length; i++) {
+    var key = aKeys[i];
+
+    if (objA[key] !== objB[key]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+/**
+ * Sets a ref using either a ref callback or a ref object
+ */
+
+
+exports.shallowEqual = shallowEqual;
+
+var setRef = function setRef(ref, node) {
+  // if its a function call it
+  if (typeof ref === "function") {
+    return safeInvoke(ref, node);
+  } // otherwise we should treat it as a ref object
+  else if (ref != null) {
+      ref.current = node;
+    }
+};
+
+exports.setRef = setRef;

web/node_modules/react-popper/lib/cjs/utils.js.flow

@@ -0,0 +1,56 @@
+// @flow
+
+import { type Ref } from "./RefTypes";
+
+/**
+ * Takes an argument and if it's an array, returns the first item in the array,
+ * otherwise returns the argument. Used for Preact compatibility.
+ */
+export const unwrapArray = (arg: *): * => (Array.isArray(arg) ? arg[0] : arg);
+
+/**
+ * Takes a maybe-undefined function and arbitrary args and invokes the function
+ * only if it is defined.
+ */
+export const safeInvoke = (fn: ?Function, ...args: *) => {
+  if (typeof fn === "function") {
+    return fn(...args);
+  }
+}
+
+/**
+ * Does a shallow equality check of two objects by comparing the reference
+ * equality of each value.
+ */
+export const shallowEqual = (objA: { [key: string]: any}, objB: { [key: string]: any}): boolean => {
+  var aKeys = Object.keys(objA);
+  var bKeys = Object.keys(objB);
+
+  if (bKeys.length !== aKeys.length) {
+    return false;
+  }
+
+  for (var i = 0; i < bKeys.length; i++) {
+    var key = aKeys[i];
+
+    if (objA[key] !== objB[key]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Sets a ref using either a ref callback or a ref object
+ */
+export const setRef = (ref: ?Ref, node: ?HTMLElement) => {
+  // if its a function call it
+  if (typeof ref === "function") {
+    return safeInvoke(ref, node);
+  }
+  // otherwise we should treat it as a ref object
+  else if (ref != null) {
+    ref.current = node;
+  }
+}

web/node_modules/react-popper/lib/esm/Manager.js

@@ -0,0 +1,53 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import * as React from 'react';
+import createContext from '@hypnosphi/create-react-context';
+export var ManagerReferenceNodeContext = createContext();
+export var ManagerReferenceNodeSetterContext = createContext();
+
+var Manager =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Manager, _React$Component);
+
+  function Manager() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "referenceNode", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "setReferenceNode", function (newReferenceNode) {
+      if (newReferenceNode && _this.referenceNode !== newReferenceNode) {
+        _this.referenceNode = newReferenceNode;
+
+        _this.forceUpdate();
+      }
+    });
+
+    return _this;
+  }
+
+  var _proto = Manager.prototype;
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.referenceNode = null;
+  };
+
+  _proto.render = function render() {
+    return React.createElement(ManagerReferenceNodeContext.Provider, {
+      value: this.referenceNode
+    }, React.createElement(ManagerReferenceNodeSetterContext.Provider, {
+      value: this.setReferenceNode
+    }, this.props.children));
+  };
+
+  return Manager;
+}(React.Component);
+
+export { Manager as default };

web/node_modules/react-popper/lib/esm/Popper.js

@@ -0,0 +1,203 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import deepEqual from "deep-equal";
+import * as React from 'react';
+import PopperJS from 'popper.js';
+import { ManagerReferenceNodeContext } from './Manager';
+import { unwrapArray, setRef, shallowEqual } from './utils';
+var initialStyle = {
+  position: 'absolute',
+  top: 0,
+  left: 0,
+  opacity: 0,
+  pointerEvents: 'none'
+};
+var initialArrowStyle = {};
+export var InnerPopper =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(InnerPopper, _React$Component);
+
+  function InnerPopper() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "state", {
+      data: undefined,
+      placement: undefined
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "popperInstance", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "popperNode", null);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "arrowNode", null);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "setPopperNode", function (popperNode) {
+      if (!popperNode || _this.popperNode === popperNode) return;
+      setRef(_this.props.innerRef, popperNode);
+      _this.popperNode = popperNode;
+
+      _this.updatePopperInstance();
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "setArrowNode", function (arrowNode) {
+      _this.arrowNode = arrowNode;
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "updateStateModifier", {
+      enabled: true,
+      order: 900,
+      fn: function fn(data) {
+        var placement = data.placement;
+
+        _this.setState({
+          data: data,
+          placement: placement
+        });
+
+        return data;
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "getOptions", function () {
+      return {
+        placement: _this.props.placement,
+        eventsEnabled: _this.props.eventsEnabled,
+        positionFixed: _this.props.positionFixed,
+        modifiers: _extends({}, _this.props.modifiers, {
+          arrow: _extends({}, _this.props.modifiers && _this.props.modifiers.arrow, {
+            enabled: !!_this.arrowNode,
+            element: _this.arrowNode
+          }),
+          applyStyle: {
+            enabled: false
+          },
+          updateStateModifier: _this.updateStateModifier
+        })
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "getPopperStyle", function () {
+      return !_this.popperNode || !_this.state.data ? initialStyle : _extends({
+        position: _this.state.data.offsets.popper.position
+      }, _this.state.data.styles);
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "getPopperPlacement", function () {
+      return !_this.state.data ? undefined : _this.state.placement;
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "getArrowStyle", function () {
+      return !_this.arrowNode || !_this.state.data ? initialArrowStyle : _this.state.data.arrowStyles;
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "getOutOfBoundariesState", function () {
+      return _this.state.data ? _this.state.data.hide : undefined;
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "destroyPopperInstance", function () {
+      if (!_this.popperInstance) return;
+
+      _this.popperInstance.destroy();
+
+      _this.popperInstance = null;
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "updatePopperInstance", function () {
+      _this.destroyPopperInstance();
+
+      var _assertThisInitialize = _assertThisInitialized(_assertThisInitialized(_this)),
+          popperNode = _assertThisInitialize.popperNode;
+
+      var referenceElement = _this.props.referenceElement;
+      if (!referenceElement || !popperNode) return;
+      _this.popperInstance = new PopperJS(referenceElement, popperNode, _this.getOptions());
+    });
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "scheduleUpdate", function () {
+      if (_this.popperInstance) {
+        _this.popperInstance.scheduleUpdate();
+      }
+    });
+
+    return _this;
+  }
+
+  var _proto = InnerPopper.prototype;
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
+    // If the Popper.js options have changed, update the instance (destroy + create)
+    if (this.props.placement !== prevProps.placement || this.props.referenceElement !== prevProps.referenceElement || this.props.positionFixed !== prevProps.positionFixed || !deepEqual(this.props.modifiers, prevProps.modifiers, {
+      strict: true
+    })) {
+      // develop only check that modifiers isn't being updated needlessly
+      if (process.env.NODE_ENV === "development") {
+        if (this.props.modifiers !== prevProps.modifiers && this.props.modifiers != null && prevProps.modifiers != null && shallowEqual(this.props.modifiers, prevProps.modifiers)) {
+          console.warn("'modifiers' prop reference updated even though all values appear the same.\nConsider memoizing the 'modifiers' object to avoid needless rendering.");
+        }
+      }
+
+      this.updatePopperInstance();
+    } else if (this.props.eventsEnabled !== prevProps.eventsEnabled && this.popperInstance) {
+      this.props.eventsEnabled ? this.popperInstance.enableEventListeners() : this.popperInstance.disableEventListeners();
+    } // A placement difference in state means popper determined a new placement
+    // apart from the props value. By the time the popper element is rendered with
+    // the new position Popper has already measured it, if the place change triggers
+    // a size change it will result in a misaligned popper. So we schedule an update to be sure.
+
+
+    if (prevState.placement !== this.state.placement) {
+      this.scheduleUpdate();
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    setRef(this.props.innerRef, null);
+    this.destroyPopperInstance();
+  };
+
+  _proto.render = function render() {
+    return unwrapArray(this.props.children)({
+      ref: this.setPopperNode,
+      style: this.getPopperStyle(),
+      placement: this.getPopperPlacement(),
+      outOfBoundaries: this.getOutOfBoundariesState(),
+      scheduleUpdate: this.scheduleUpdate,
+      arrowProps: {
+        ref: this.setArrowNode,
+        style: this.getArrowStyle()
+      }
+    });
+  };
+
+  return InnerPopper;
+}(React.Component);
+
+_defineProperty(InnerPopper, "defaultProps", {
+  placement: 'bottom',
+  eventsEnabled: true,
+  referenceElement: undefined,
+  positionFixed: false
+});
+
+var placements = PopperJS.placements;
+export { placements };
+export default function Popper(_ref) {
+  var referenceElement = _ref.referenceElement,
+      props = _objectWithoutPropertiesLoose(_ref, ["referenceElement"]);
+
+  return React.createElement(ManagerReferenceNodeContext.Consumer, null, function (referenceNode) {
+    return React.createElement(InnerPopper, _extends({
+      referenceElement: referenceElement !== undefined ? referenceElement : referenceNode
+    }, props));
+  });
+}

web/node_modules/react-popper/lib/esm/Reference.js

@@ -0,0 +1,54 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import * as React from 'react';
+import warning from 'warning';
+import { ManagerReferenceNodeSetterContext } from './Manager';
+import { safeInvoke, unwrapArray, setRef } from './utils';
+
+var InnerReference =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(InnerReference, _React$Component);
+
+  function InnerReference() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "refHandler", function (node) {
+      setRef(_this.props.innerRef, node);
+      safeInvoke(_this.props.setReferenceNode, node);
+    });
+
+    return _this;
+  }
+
+  var _proto = InnerReference.prototype;
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    setRef(this.props.innerRef, null);
+  };
+
+  _proto.render = function render() {
+    warning(Boolean(this.props.setReferenceNode), '`Reference` should not be used outside of a `Manager` component.');
+    return unwrapArray(this.props.children)({
+      ref: this.refHandler
+    });
+  };
+
+  return InnerReference;
+}(React.Component);
+
+export default function Reference(props) {
+  return React.createElement(ManagerReferenceNodeSetterContext.Consumer, null, function (setReferenceNode) {
+    return React.createElement(InnerReference, _extends({
+      setReferenceNode: setReferenceNode
+    }, props));
+  });
+}

web/node_modules/react-popper/lib/esm/__typings__/main-test.js

@@ -0,0 +1,56 @@
+import _extends from "@babel/runtime/helpers/extends";
+// Please remember to update also the TypeScript test files that can
+// be found under `/typings/tests` please. Thanks! 🤗
+import React from 'react';
+import { Manager, Reference, Popper } from '..';
+export var Test = function Test() {
+  var _React$createElement;
+
+  return React.createElement(Manager, null, React.createElement(Reference, null), React.createElement(Reference, null, function (_ref) {
+    var ref = _ref.ref;
+    return React.createElement("div", {
+      ref: ref
+    });
+  }), React.createElement(Popper // $FlowExpectError: should be boolean
+  , (_React$createElement = {
+    eventsEnabled: "foo"
+  }, _React$createElement["eventsEnabled"] = true, _React$createElement.positionFixed = 2, _React$createElement["positionFixed"] = true, _React$createElement.modifiers = {
+    flip: {
+      enabled: 'bar',
+      order: 'foo'
+    }
+  }, _React$createElement["modifiers"] = {
+    flip: {
+      enabled: false
+    }
+  }, _React$createElement), function (_ref2) {
+    var ref = _ref2.ref,
+        style = _ref2.style,
+        placement = _ref2.placement,
+        outOfBoundaries = _ref2.outOfBoundaries,
+        scheduleUpdate = _ref2.scheduleUpdate,
+        arrowProps = _ref2.arrowProps;
+    return React.createElement("div", {
+      ref: ref,
+      style: _extends({}, style, {
+        opacity: outOfBoundaries ? 0 : 1
+      }),
+      "data-placement": placement,
+      onClick: function onClick() {
+        return scheduleUpdate();
+      }
+    }, "Popper", React.createElement("div", {
+      ref: arrowProps.ref,
+      style: arrowProps.style
+    }));
+  }), React.createElement(Popper, null, function (_ref3) {
+    var ref = _ref3.ref,
+        style = _ref3.style,
+        placement = _ref3.placement;
+    return React.createElement("div", {
+      ref: ref,
+      style: style,
+      "data-placement": placement
+    }, "Popper");
+  }));
+};

web/node_modules/react-popper/lib/esm/index.js

@@ -0,0 +1,5 @@
+// Public components
+import Popper, { placements } from './Popper';
+import Manager from './Manager';
+import Reference from './Reference';
+export { Popper, placements, Manager, Reference }; // Public types

web/node_modules/react-popper/lib/esm/utils.js

@@ -0,0 +1,57 @@
+/**
+ * Takes an argument and if it's an array, returns the first item in the array,
+ * otherwise returns the argument. Used for Preact compatibility.
+ */
+export var unwrapArray = function unwrapArray(arg) {
+  return Array.isArray(arg) ? arg[0] : arg;
+};
+/**
+ * Takes a maybe-undefined function and arbitrary args and invokes the function
+ * only if it is defined.
+ */
+
+export var safeInvoke = function safeInvoke(fn) {
+  if (typeof fn === "function") {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    return fn.apply(void 0, args);
+  }
+};
+/**
+ * Does a shallow equality check of two objects by comparing the reference
+ * equality of each value.
+ */
+
+export var shallowEqual = function shallowEqual(objA, objB) {
+  var aKeys = Object.keys(objA);
+  var bKeys = Object.keys(objB);
+
+  if (bKeys.length !== aKeys.length) {
+    return false;
+  }
+
+  for (var i = 0; i < bKeys.length; i++) {
+    var key = aKeys[i];
+
+    if (objA[key] !== objB[key]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+/**
+ * Sets a ref using either a ref callback or a ref object
+ */
+
+export var setRef = function setRef(ref, node) {
+  // if its a function call it
+  if (typeof ref === "function") {
+    return safeInvoke(ref, node);
+  } // otherwise we should treat it as a ref object
+  else if (ref != null) {
+      ref.current = node;
+    }
+};