feat: 氧化铝数字孪生系统监控大屏完成

node_modules/react-popper/CHANGELOG.md

@@ -0,0 +1,152 @@
+## CHANGELOG
+
+Here are listed the changelogs until 0.8.2, if you are looking for more recent releases changelog please refer to the dedicated GitHub [releases](https://github.com/souporserious/react-popper/releases) page, where you will find all the releases plus the changelog for each of them.
+
+
+----------
+
+### 0.8.2
+
+fix es5 build [#90](https://github.com/souporserious/react-popper/pull/90)
+
+### 0.8.1
+
+Move back to controlling DOM updates through React
+
+Update & clean dependencies [#89](https://github.com/souporserious/react-popper/pull/89)
+
+### 0.8.0
+
+Upgrade PopperJS dependency to `1.12.9`
+
+Fix `Popper` ref getting called too many times [#81](https://github.com/souporserious/react-popper/issues/81)
+
+Let PopperJS style DOM for better performance as described in [vjeux's talk](https://speakerdeck.com/vjeux/react-rally-animated-react-performance-toolbox).
+
+### 0.7.5
+
+Fix PopperJS instantiation [#77](https://github.com/souporserious/react-popper/pull/77)
+
+### 0.7.4
+
+Allow React 16 as a peerDependency [#59](https://github.com/souporserious/react-popper/pull/59)
+
+Updates TypeScript definition for IPopperChildrenProps [#61](https://github.com/souporserious/react-popper/pull/61)
+
+Made scripts platform independent [#63](https://github.com/souporserious/react-popper/pull/63)
+
+### 0.7.3
+
+Upgraded dependencies [#44](https://github.com/souporserious/react-popper/pull/44)
+
+Fix missing data-x-out-of-boundaries attribute [#45](https://github.com/souporserious/react-popper/pull/45)
+
+Update how react-popper.d.ts imports PopperJS [#51](https://github.com/souporserious/react-popper/pull/51)
+
+### 0.7.2
+
+Fix `top` and `left` arrow calculation. Disregard the note below about changing the CSS positioning, this was an error on `react-popper`'s part.
+
+### 0.7.1
+
+Support `top` and `left` arrow offsets together, be aware this most likely broke any prior CSS positioning your arrows [#37](https://github.com/souporserious/react-popper/pull/37)
+
+Fix `scheduleUpdate` call if `this._popper` does not exist [#38](https://github.com/souporserious/react-popper/pull/38)
+
+Add typescript definitions [#40](https://github.com/souporserious/react-popper/pull/40)
+
+Upgrade to Popper.js 1.10.8
+
+### 0.7.0
+
+Change `Target`, `Popper`, and `Arrow` component's `tag` prop to `component` to allow custom components to be passed in.
+
+Upgrade PopperJS 1.10.2
+
+### 0.6.6
+
+Upgrade PopperJS to 1.9.9
+
+### 0.6.5
+
+Call `innerRef` in _all_ component child functions
+
+### 0.6.4
+
+Call `innerRef` in child function as well
+
+### 0.6.3
+
+Upgrade PopperJS to 1.9.5
+
+### 0.6.2
+
+Replace `lodash.isequal` with `is-equal-shallow`
+
+### 0.6.1
+
+Pass down `scheduleUpdate` to `Popper` child function to allow programatic updates
+
+Upgrade to Popper.js 1.9.4
+
+Fix `modifier.function` is deprecated, use `modifier.fn` [#22](https://github.com/souporserious/react-popper/pull/22)
+
+### 0.6.0
+
+Make sure to pass props from above down to child function, fixes [#13](https://github.com/souporserious/react-popper/issues/13)
+
+Recalculate size of `Popper` when children change, fixes [#15](https://github.com/souporserious/react-popper/issues/15)
+
+### 0.5.0
+
+Use `prop-types` package instead of React PropTypes [#9](https://github.com/souporserious/react-popper/pull/9)
+
+Make updateState modifier return data object [#11](https://github.com/souporserious/react-popper/pull/11)
+
+Removed `findDOMNode` 🎉
+
+Moved back to `tag` instead of `component`. Use a child function now for custom components and pass down the provided ref to the proper component.
+
+Removed default classNames for `popper` and `popper__arrow` so we can be unopinionated about styling.
+
+### 0.4.3
+
+Allow passing children through to components
+
+### 0.4.2
+
+Move back to `translate3d` and round values since half pixel placement was the culprit for causing blurry text
+
+### 0.4.1
+
+Don't use `translate3d` since it causes blurry text on lower res displays
+
+### 0.4.0
+
+Remove `getRef` function since it seems to be causing problems.
+
+Move functional components to classes so we can get nodes more reliably.
+
+Spread modifier styles inside `_getPopperStyle` [#6](https://github.com/souporserious/react-popper/pull/6)
+
+### 0.3.0
+
+Renamed `PopperManager` -> `Manager`
+
+Added `getRef` prop to `Target`, `Popper`, and `Arrow` components
+
+### 0.2.2
+
+Bundle popper.js with dist build
+
+### 0.2.1
+
+Remove React ARIA from demos for now
+
+### 0.2.0
+
+New API see README for full docs
+
+### 0.1.0
+
+Initial release

node_modules/react-popper/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 React Popper authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/react-popper/README.md

@@ -0,0 +1,63 @@
+# React Popper
+
+[![Unit Tests](https://github.com/popperjs/react-popper/workflows/Unit%20Tests/badge.svg)](https://github.com/popperjs/react-popper/actions?query=workflow%3A%22Unit+Tests%22)
+[![npm version](https://img.shields.io/npm/v/react-popper.svg)](https://www.npmjs.com/package/react-popper)
+[![npm downloads](https://img.shields.io/npm/dm/react-popper.svg)](https://www.npmjs.com/package/react-popper)
+[![Dependency Status](https://david-dm.org/souporserious/react-popper.svg)](https://david-dm.org/souporserious/react-popper)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
+[![Get support or discuss](https://img.shields.io/badge/chat-on_spectrum-6833F9.svg?logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyBpZD0iTGl2ZWxsb18xIiBkYXRhLW5hbWU9IkxpdmVsbG8gMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB2aWV3Qm94PSIwIDAgMTAgOCI%2BPGRlZnM%2BPHN0eWxlPi5jbHMtMXtmaWxsOiNmZmY7fTwvc3R5bGU%2BPC9kZWZzPjx0aXRsZT5zcGVjdHJ1bTwvdGl0bGU%2BPHBhdGggY2xhc3M9ImNscy0xIiBkPSJNNSwwQy40MiwwLDAsLjYzLDAsMy4zNGMwLDEuODQuMTksMi43MiwxLjc0LDMuMWgwVjcuNThhLjQ0LjQ0LDAsMCwwLC42OC4zNUw0LjM1LDYuNjlINWM0LjU4LDAsNS0uNjMsNS0zLjM1UzkuNTgsMCw1LDBaTTIuODMsNC4xOGEuNjMuNjMsMCwxLDEsLjY1LS42M0EuNjQuNjQsMCwwLDEsMi44Myw0LjE4Wk01LDQuMThhLjYzLjYzLDAsMSwxLC42NS0uNjNBLjY0LjY0LDAsMCwxLDUsNC4xOFptMi4xNywwYS42My42MywwLDEsMSwuNjUtLjYzQS42NC42NCwwLDAsMSw3LjE3LDQuMThaIi8%2BPC9zdmc%2B)](https://spectrum.chat/popper-js/react-popper)
+
+React wrapper around [Popper](https://popper.js.org).
+
+**important note:** Popper is **not** a tooltip library, it's a _positioning
+engine_ to be used to build features such as (but not restricted to) tooltips.
+
+## Install
+
+Via package managers:
+
+```bash
+# With npm
+npm i react-popper @popperjs/core
+
+# With Yarn
+yarn add react-popper @popperjs/core
+```
+
+**Note:** `@popperjs/core` must be installed in your project in order for
+`react-popper` to work.
+
+Via `script` tag (UMD library exposed as `ReactPopper`):
+
+```html
+<script src="https://unpkg.com/react-popper/dist/index.umd.js"></script>
+```
+
+## Documentation
+
+The full documentation can be found on the official Popper website:
+
+http://popper.js.org/react-popper
+
+
+## Running Locally
+
+#### clone repo
+
+`git clone git@github.com:popperjs/react-popper.git`
+
+#### move into folder
+
+`cd ~/react-popper`
+
+#### install dependencies
+
+`npm install` or `yarn`
+
+#### run dev mode
+
+`npm run demo:dev` or `yarn demo:dev`
+
+#### open your browser and visit:
+
+`http://localhost:1234/`

node_modules/react-popper/dist/index.umd.js

@@ -0,0 +1,469 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-dom'), require('@popperjs/core')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-dom', '@popperjs/core'], factory) :
+  (global = global || self, factory(global.ReactPopper = {}, global.React, global.ReactDOM, global.Popper));
+}(this, (function (exports, React, ReactDOM, core) { 'use strict';
+
+  var ManagerReferenceNodeContext = React.createContext();
+  var ManagerReferenceNodeSetterContext = React.createContext();
+  function Manager(_ref) {
+    var children = _ref.children;
+
+    var _React$useState = React.useState(null),
+        referenceNode = _React$useState[0],
+        setReferenceNode = _React$useState[1];
+
+    var hasUnmounted = React.useRef(false);
+    React.useEffect(function () {
+      return function () {
+        hasUnmounted.current = true;
+      };
+    }, []);
+    var handleSetReferenceNode = React.useCallback(function (node) {
+      if (!hasUnmounted.current) {
+        setReferenceNode(node);
+      }
+    }, []);
+    return /*#__PURE__*/React.createElement(ManagerReferenceNodeContext.Provider, {
+      value: referenceNode
+    }, /*#__PURE__*/React.createElement(ManagerReferenceNodeSetterContext.Provider, {
+      value: handleSetReferenceNode
+    }, children));
+  }
+
+  /**
+   * 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.
+   */
+
+  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);
+    }
+  };
+  /**
+   * Sets a ref using either a ref callback or a ref object
+   */
+
+  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;
+      }
+  };
+  /**
+   * Simple ponyfill for Object.fromEntries
+   */
+
+  var fromEntries = function fromEntries(entries) {
+    return entries.reduce(function (acc, _ref) {
+      var key = _ref[0],
+          value = _ref[1];
+      acc[key] = value;
+      return acc;
+    }, {});
+  };
+  /**
+   * Small wrapper around `useLayoutEffect` to get rid of the warning on SSR envs
+   */
+
+  var useIsomorphicLayoutEffect = typeof window !== 'undefined' && window.document && window.document.createElement ? React.useLayoutEffect : React.useEffect;
+
+  /* global Map:readonly, Set:readonly, ArrayBuffer:readonly */
+
+  var hasElementType = typeof Element !== 'undefined';
+  var hasMap = typeof Map === 'function';
+  var hasSet = typeof Set === 'function';
+  var hasArrayBuffer = typeof ArrayBuffer === 'function';
+
+  // Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js
+
+  function equal(a, b) {
+    // START: fast-deep-equal es6/index.js 3.1.1
+    if (a === b) return true;
+
+    if (a && b && typeof a == 'object' && typeof b == 'object') {
+      if (a.constructor !== b.constructor) return false;
+
+      var length, i, keys;
+      if (Array.isArray(a)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0;)
+          if (!equal(a[i], b[i])) return false;
+        return true;
+      }
+
+      // START: Modifications:
+      // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code
+      //    to co-exist with es5.
+      // 2. Replace `for of` with es5 compliant iteration using `for`.
+      //    Basically, take:
+      //
+      //    ```js
+      //    for (i of a.entries())
+      //      if (!b.has(i[0])) return false;
+      //    ```
+      //
+      //    ... and convert to:
+      //
+      //    ```js
+      //    it = a.entries();
+      //    while (!(i = it.next()).done)
+      //      if (!b.has(i.value[0])) return false;
+      //    ```
+      //
+      //    **Note**: `i` access switches to `i.value`.
+      var it;
+      if (hasMap && (a instanceof Map) && (b instanceof Map)) {
+        if (a.size !== b.size) return false;
+        it = a.entries();
+        while (!(i = it.next()).done)
+          if (!b.has(i.value[0])) return false;
+        it = a.entries();
+        while (!(i = it.next()).done)
+          if (!equal(i.value[1], b.get(i.value[0]))) return false;
+        return true;
+      }
+
+      if (hasSet && (a instanceof Set) && (b instanceof Set)) {
+        if (a.size !== b.size) return false;
+        it = a.entries();
+        while (!(i = it.next()).done)
+          if (!b.has(i.value[0])) return false;
+        return true;
+      }
+      // END: Modifications
+
+      if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0;)
+          if (a[i] !== b[i]) return false;
+        return true;
+      }
+
+      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+      if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+      if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+
+      keys = Object.keys(a);
+      length = keys.length;
+      if (length !== Object.keys(b).length) return false;
+
+      for (i = length; i-- !== 0;)
+        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+      // END: fast-deep-equal
+
+      // START: react-fast-compare
+      // custom handling for DOM elements
+      if (hasElementType && a instanceof Element) return false;
+
+      // custom handling for React
+      for (i = length; i-- !== 0;) {
+        if (keys[i] === '_owner' && a.$$typeof) {
+          // React-specific: avoid traversing React elements' _owner.
+          //  _owner contains circular references
+          // and is not needed when comparing the actual elements (and not their owners)
+          // .$$typeof and ._store on just reasonable markers of a react element
+          continue;
+        }
+
+        // all other properties should be traversed as usual
+        if (!equal(a[keys[i]], b[keys[i]])) return false;
+      }
+      // END: react-fast-compare
+
+      // START: fast-deep-equal
+      return true;
+    }
+
+    return a !== a && b !== b;
+  }
+  // end fast-deep-equal
+
+  var reactFastCompare = function isEqual(a, b) {
+    try {
+      return equal(a, b);
+    } catch (error) {
+      if (((error.message || '').match(/stack|recursion/i))) {
+        // warn on circular references, don't crash
+        // browsers give this different errors name and messages:
+        // chrome/safari: "RangeError", "Maximum call stack size exceeded"
+        // firefox: "InternalError", too much recursion"
+        // edge: "Error", "Out of stack space"
+        console.warn('react-fast-compare cannot handle circular refs');
+        return false;
+      }
+      // some other error. we should definitely know about these
+      throw error;
+    }
+  };
+
+  var EMPTY_MODIFIERS = [];
+  var usePopper = function usePopper(referenceElement, popperElement, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    var prevOptions = React.useRef(null);
+    var optionsWithDefaults = {
+      onFirstUpdate: options.onFirstUpdate,
+      placement: options.placement || 'bottom',
+      strategy: options.strategy || 'absolute',
+      modifiers: options.modifiers || EMPTY_MODIFIERS
+    };
+
+    var _React$useState = React.useState({
+      styles: {
+        popper: {
+          position: optionsWithDefaults.strategy,
+          left: '0',
+          top: '0'
+        },
+        arrow: {
+          position: 'absolute'
+        }
+      },
+      attributes: {}
+    }),
+        state = _React$useState[0],
+        setState = _React$useState[1];
+
+    var updateStateModifier = React.useMemo(function () {
+      return {
+        name: 'updateState',
+        enabled: true,
+        phase: 'write',
+        fn: function fn(_ref) {
+          var state = _ref.state;
+          var elements = Object.keys(state.elements);
+          ReactDOM.flushSync(function () {
+            setState({
+              styles: fromEntries(elements.map(function (element) {
+                return [element, state.styles[element] || {}];
+              })),
+              attributes: fromEntries(elements.map(function (element) {
+                return [element, state.attributes[element]];
+              }))
+            });
+          });
+        },
+        requires: ['computeStyles']
+      };
+    }, []);
+    var popperOptions = React.useMemo(function () {
+      var newOptions = {
+        onFirstUpdate: optionsWithDefaults.onFirstUpdate,
+        placement: optionsWithDefaults.placement,
+        strategy: optionsWithDefaults.strategy,
+        modifiers: [].concat(optionsWithDefaults.modifiers, [updateStateModifier, {
+          name: 'applyStyles',
+          enabled: false
+        }])
+      };
+
+      if (reactFastCompare(prevOptions.current, newOptions)) {
+        return prevOptions.current || newOptions;
+      } else {
+        prevOptions.current = newOptions;
+        return newOptions;
+      }
+    }, [optionsWithDefaults.onFirstUpdate, optionsWithDefaults.placement, optionsWithDefaults.strategy, optionsWithDefaults.modifiers, updateStateModifier]);
+    var popperInstanceRef = React.useRef();
+    useIsomorphicLayoutEffect(function () {
+      if (popperInstanceRef.current) {
+        popperInstanceRef.current.setOptions(popperOptions);
+      }
+    }, [popperOptions]);
+    useIsomorphicLayoutEffect(function () {
+      if (referenceElement == null || popperElement == null) {
+        return;
+      }
+
+      var createPopper = options.createPopper || core.createPopper;
+      var popperInstance = createPopper(referenceElement, popperElement, popperOptions);
+      popperInstanceRef.current = popperInstance;
+      return function () {
+        popperInstance.destroy();
+        popperInstanceRef.current = null;
+      };
+    }, [referenceElement, popperElement, options.createPopper]);
+    return {
+      state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
+      styles: state.styles,
+      attributes: state.attributes,
+      update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
+      forceUpdate: popperInstanceRef.current ? popperInstanceRef.current.forceUpdate : null
+    };
+  };
+
+  var NOOP = function NOOP() {
+    return void 0;
+  };
+
+  var NOOP_PROMISE = function NOOP_PROMISE() {
+    return Promise.resolve(null);
+  };
+
+  var EMPTY_MODIFIERS$1 = [];
+  function Popper(_ref) {
+    var _ref$placement = _ref.placement,
+        placement = _ref$placement === void 0 ? 'bottom' : _ref$placement,
+        _ref$strategy = _ref.strategy,
+        strategy = _ref$strategy === void 0 ? 'absolute' : _ref$strategy,
+        _ref$modifiers = _ref.modifiers,
+        modifiers = _ref$modifiers === void 0 ? EMPTY_MODIFIERS$1 : _ref$modifiers,
+        referenceElement = _ref.referenceElement,
+        onFirstUpdate = _ref.onFirstUpdate,
+        innerRef = _ref.innerRef,
+        children = _ref.children;
+    var referenceNode = React.useContext(ManagerReferenceNodeContext);
+
+    var _React$useState = React.useState(null),
+        popperElement = _React$useState[0],
+        setPopperElement = _React$useState[1];
+
+    var _React$useState2 = React.useState(null),
+        arrowElement = _React$useState2[0],
+        setArrowElement = _React$useState2[1];
+
+    React.useEffect(function () {
+      setRef(innerRef, popperElement);
+    }, [innerRef, popperElement]);
+    var options = React.useMemo(function () {
+      return {
+        placement: placement,
+        strategy: strategy,
+        onFirstUpdate: onFirstUpdate,
+        modifiers: [].concat(modifiers, [{
+          name: 'arrow',
+          enabled: arrowElement != null,
+          options: {
+            element: arrowElement
+          }
+        }])
+      };
+    }, [placement, strategy, onFirstUpdate, modifiers, arrowElement]);
+
+    var _usePopper = usePopper(referenceElement || referenceNode, popperElement, options),
+        state = _usePopper.state,
+        styles = _usePopper.styles,
+        forceUpdate = _usePopper.forceUpdate,
+        update = _usePopper.update;
+
+    var childrenProps = React.useMemo(function () {
+      return {
+        ref: setPopperElement,
+        style: styles.popper,
+        placement: state ? state.placement : placement,
+        hasPopperEscaped: state && state.modifiersData.hide ? state.modifiersData.hide.hasPopperEscaped : null,
+        isReferenceHidden: state && state.modifiersData.hide ? state.modifiersData.hide.isReferenceHidden : null,
+        arrowProps: {
+          style: styles.arrow,
+          ref: setArrowElement
+        },
+        forceUpdate: forceUpdate || NOOP,
+        update: update || NOOP_PROMISE
+      };
+    }, [setPopperElement, setArrowElement, placement, state, styles, update, forceUpdate]);
+    return unwrapArray(children)(childrenProps);
+  }
+
+  /**
+   * Copyright (c) 2014-present, Facebook, Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+  var warning = function() {};
+
+  {
+    var printWarning = function printWarning(format, args) {
+      var len = arguments.length;
+      args = new Array(len > 1 ? len - 1 : 0);
+      for (var key = 1; key < len; key++) {
+        args[key - 1] = arguments[key];
+      }
+      var argIndex = 0;
+      var message = 'Warning: ' +
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        });
+      if (typeof console !== 'undefined') {
+        console.error(message);
+      }
+      try {
+        // --- Welcome to debugging React ---
+        // This error was thrown as a convenience so that you can use this stack
+        // to find the callsite that caused this warning to fire.
+        throw new Error(message);
+      } catch (x) {}
+    };
+
+    warning = function(condition, format, args) {
+      var len = arguments.length;
+      args = new Array(len > 2 ? len - 2 : 0);
+      for (var key = 2; key < len; key++) {
+        args[key - 2] = arguments[key];
+      }
+      if (format === undefined) {
+        throw new Error(
+            '`warning(condition, format, ...args)` requires a warning ' +
+            'message argument'
+        );
+      }
+      if (!condition) {
+        printWarning.apply(null, [format].concat(args));
+      }
+    };
+  }
+
+  var warning_1 = warning;
+
+  function Reference(_ref) {
+    var children = _ref.children,
+        innerRef = _ref.innerRef;
+    var setReferenceNode = React.useContext(ManagerReferenceNodeSetterContext);
+    var refHandler = React.useCallback(function (node) {
+      setRef(innerRef, node);
+      safeInvoke(setReferenceNode, node);
+    }, [innerRef, setReferenceNode]); // ran on unmount
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+
+    React.useEffect(function () {
+      return function () {
+        return setRef(innerRef, null);
+      };
+    }, []);
+    React.useEffect(function () {
+      warning_1(Boolean(setReferenceNode), '`Reference` should not be used outside of a `Manager` component.');
+    }, [setReferenceNode]);
+    return unwrapArray(children)({
+      ref: refHandler
+    });
+  }
+
+  exports.Manager = Manager;
+  exports.Popper = Popper;
+  exports.Reference = Reference;
+  exports.usePopper = usePopper;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

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

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Manager = Manager;
+exports.ManagerReferenceNodeSetterContext = exports.ManagerReferenceNodeContext = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var ManagerReferenceNodeContext = React.createContext();
+exports.ManagerReferenceNodeContext = ManagerReferenceNodeContext;
+var ManagerReferenceNodeSetterContext = React.createContext();
+exports.ManagerReferenceNodeSetterContext = ManagerReferenceNodeSetterContext;
+
+function Manager(_ref) {
+  var children = _ref.children;
+
+  var _React$useState = React.useState(null),
+      referenceNode = _React$useState[0],
+      setReferenceNode = _React$useState[1];
+
+  var hasUnmounted = React.useRef(false);
+  React.useEffect(function () {
+    return function () {
+      hasUnmounted.current = true;
+    };
+  }, []);
+  var handleSetReferenceNode = React.useCallback(function (node) {
+    if (!hasUnmounted.current) {
+      setReferenceNode(node);
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(ManagerReferenceNodeContext.Provider, {
+    value: referenceNode
+  }, /*#__PURE__*/React.createElement(ManagerReferenceNodeSetterContext.Provider, {
+    value: handleSetReferenceNode
+  }, children));
+}

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

@@ -0,0 +1,38 @@
+// @flow strict
+import * as React from 'react';
+
+export const ManagerReferenceNodeContext: React.Context<?Element>  = React.createContext();
+export const ManagerReferenceNodeSetterContext: React.Context<
+  void | ((?Element) => void)
+> = React.createContext();
+
+export type ManagerProps = $ReadOnly<{
+  children: React.Node,
+}>;
+
+export function Manager({ children }: ManagerProps): React.Node {
+  const [referenceNode, setReferenceNode] = React.useState<?Element>(null);
+
+  const hasUnmounted = React.useRef(false);
+  React.useEffect(() => {
+    return () => {
+      hasUnmounted.current = true;
+    };
+  }, []);
+
+  const handleSetReferenceNode = React.useCallback((node) => {
+    if (!hasUnmounted.current) {
+      setReferenceNode(node);
+    }
+  }, []);
+
+  return (
+    <ManagerReferenceNodeContext.Provider value={referenceNode}>
+      <ManagerReferenceNodeSetterContext.Provider
+        value={handleSetReferenceNode}
+      >
+        {children}
+      </ManagerReferenceNodeSetterContext.Provider>
+    </ManagerReferenceNodeContext.Provider>
+  );
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Popper = Popper;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Manager = require("./Manager");
+
+var _utils = require("./utils");
+
+var _usePopper2 = require("./usePopper");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var NOOP = function NOOP() {
+  return void 0;
+};
+
+var NOOP_PROMISE = function NOOP_PROMISE() {
+  return Promise.resolve(null);
+};
+
+var EMPTY_MODIFIERS = [];
+
+function Popper(_ref) {
+  var _ref$placement = _ref.placement,
+      placement = _ref$placement === void 0 ? 'bottom' : _ref$placement,
+      _ref$strategy = _ref.strategy,
+      strategy = _ref$strategy === void 0 ? 'absolute' : _ref$strategy,
+      _ref$modifiers = _ref.modifiers,
+      modifiers = _ref$modifiers === void 0 ? EMPTY_MODIFIERS : _ref$modifiers,
+      referenceElement = _ref.referenceElement,
+      onFirstUpdate = _ref.onFirstUpdate,
+      innerRef = _ref.innerRef,
+      children = _ref.children;
+  var referenceNode = React.useContext(_Manager.ManagerReferenceNodeContext);
+
+  var _React$useState = React.useState(null),
+      popperElement = _React$useState[0],
+      setPopperElement = _React$useState[1];
+
+  var _React$useState2 = React.useState(null),
+      arrowElement = _React$useState2[0],
+      setArrowElement = _React$useState2[1];
+
+  React.useEffect(function () {
+    (0, _utils.setRef)(innerRef, popperElement);
+  }, [innerRef, popperElement]);
+  var options = React.useMemo(function () {
+    return {
+      placement: placement,
+      strategy: strategy,
+      onFirstUpdate: onFirstUpdate,
+      modifiers: [].concat(modifiers, [{
+        name: 'arrow',
+        enabled: arrowElement != null,
+        options: {
+          element: arrowElement
+        }
+      }])
+    };
+  }, [placement, strategy, onFirstUpdate, modifiers, arrowElement]);
+
+  var _usePopper = (0, _usePopper2.usePopper)(referenceElement || referenceNode, popperElement, options),
+      state = _usePopper.state,
+      styles = _usePopper.styles,
+      forceUpdate = _usePopper.forceUpdate,
+      update = _usePopper.update;
+
+  var childrenProps = React.useMemo(function () {
+    return {
+      ref: setPopperElement,
+      style: styles.popper,
+      placement: state ? state.placement : placement,
+      hasPopperEscaped: state && state.modifiersData.hide ? state.modifiersData.hide.hasPopperEscaped : null,
+      isReferenceHidden: state && state.modifiersData.hide ? state.modifiersData.hide.isReferenceHidden : null,
+      arrowProps: {
+        style: styles.arrow,
+        ref: setArrowElement
+      },
+      forceUpdate: forceUpdate || NOOP,
+      update: update || NOOP_PROMISE
+    };
+  }, [setPopperElement, setArrowElement, placement, state, styles, update, forceUpdate]);
+  return (0, _utils.unwrapArray)(children)(childrenProps);
+}

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

@@ -0,0 +1,124 @@
+// @flow strict
+import * as React from 'react';
+import {
+  type State,
+  type Placement,
+  type PositioningStrategy,
+  type VirtualElement,
+  type StrictModifiers,
+  type Modifier,
+} from '@popperjs/core/lib';
+import { ManagerReferenceNodeContext } from './Manager';
+import type { Ref } from './RefTypes';
+import { unwrapArray, setRef } from './utils';
+import { usePopper } from './usePopper';
+
+type ReferenceElement = ?(VirtualElement | HTMLElement);
+type Modifiers = Array<StrictModifiers | $Shape<Modifier<string, {}>>>;
+
+export type PopperArrowProps = {|
+  ref: Ref,
+  style: CSSStyleDeclaration,
+|};
+export type PopperChildrenProps = {|
+  ref: Ref,
+  style: CSSStyleDeclaration,
+
+  placement: Placement,
+  isReferenceHidden: ?boolean,
+  hasPopperEscaped: ?boolean,
+
+  update: () => Promise<null | $Shape<State>>,
+  forceUpdate: () => void,
+  arrowProps: PopperArrowProps,
+|};
+export type PopperChildren = (PopperChildrenProps) => React.Node;
+
+export type PopperProps = $ReadOnly<{|
+  children: PopperChildren,
+  innerRef?: Ref,
+  modifiers?: Modifiers,
+  placement?: Placement,
+  strategy?: PositioningStrategy,
+  referenceElement?: ReferenceElement,
+  onFirstUpdate?: ($Shape<State>) => void,
+|}>;
+
+const NOOP = () => void 0;
+const NOOP_PROMISE = () => Promise.resolve(null);
+const EMPTY_MODIFIERS = [];
+
+export function Popper({
+  placement = 'bottom',
+  strategy = 'absolute',
+  modifiers = EMPTY_MODIFIERS,
+  referenceElement,
+  onFirstUpdate,
+  innerRef,
+  children,
+}: PopperProps): React.Node {
+  const referenceNode = React.useContext(ManagerReferenceNodeContext);
+
+  const [popperElement, setPopperElement] = React.useState(null);
+  const [arrowElement, setArrowElement] = React.useState(null);
+
+  React.useEffect(() => {
+    setRef(innerRef, popperElement)
+  }, [innerRef, popperElement]);
+
+  const options = React.useMemo(
+    () => ({
+      placement,
+      strategy,
+      onFirstUpdate,
+      modifiers: [
+        ...modifiers,
+        {
+          name: 'arrow',
+          enabled: arrowElement != null,
+          options: { element: arrowElement },
+        },
+      ],
+    }),
+    [placement, strategy, onFirstUpdate, modifiers, arrowElement]
+  );
+
+  const { state, styles, forceUpdate, update } = usePopper(
+    referenceElement || referenceNode,
+    popperElement,
+    options
+  );
+
+  const childrenProps = React.useMemo(
+    () => ({
+      ref: setPopperElement,
+      style: styles.popper,
+      placement: state ? state.placement : placement,
+      hasPopperEscaped:
+        state && state.modifiersData.hide
+          ? state.modifiersData.hide.hasPopperEscaped
+          : null,
+      isReferenceHidden:
+        state && state.modifiersData.hide
+          ? state.modifiersData.hide.isReferenceHidden
+          : null,
+      arrowProps: {
+        style: styles.arrow,
+        ref: setArrowElement,
+      },
+      forceUpdate: forceUpdate || NOOP,
+      update: update || NOOP_PROMISE,
+    }),
+    [
+      setPopperElement,
+      setArrowElement,
+      placement,
+      state,
+      styles,
+      update,
+      forceUpdate,
+    ]
+  );
+
+  return unwrapArray(children)(childrenProps);
+}

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

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

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Reference = Reference;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _warning = _interopRequireDefault(require("warning"));
+
+var _Manager = require("./Manager");
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function Reference(_ref) {
+  var children = _ref.children,
+      innerRef = _ref.innerRef;
+  var setReferenceNode = React.useContext(_Manager.ManagerReferenceNodeSetterContext);
+  var refHandler = React.useCallback(function (node) {
+    (0, _utils.setRef)(innerRef, node);
+    (0, _utils.safeInvoke)(setReferenceNode, node);
+  }, [innerRef, setReferenceNode]); // ran on unmount
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  React.useEffect(function () {
+    return function () {
+      return (0, _utils.setRef)(innerRef, null);
+    };
+  }, []);
+  React.useEffect(function () {
+    (0, _warning["default"])(Boolean(setReferenceNode), '`Reference` should not be used outside of a `Manager` component.');
+  }, [setReferenceNode]);
+  return (0, _utils.unwrapArray)(children)({
+    ref: refHandler
+  });
+}

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

@@ -0,0 +1,37 @@
+// @flow strict
+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 = $ReadOnly<{ ref: Ref }>;
+export type ReferenceProps = $ReadOnly<{|
+  children: (ReferenceChildrenProps) => React.Node,
+  innerRef?: Ref,
+|}>;
+
+export function Reference({ children, innerRef }: ReferenceProps): React.Node {
+  const setReferenceNode = React.useContext(ManagerReferenceNodeSetterContext);
+
+  const refHandler = React.useCallback(
+    (node: ?HTMLElement) => {
+      setRef(innerRef, node);
+      safeInvoke(setReferenceNode, node);
+    },
+    [innerRef, setReferenceNode]
+  );
+
+  // ran on unmount
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  React.useEffect(() => () => setRef(innerRef, null), []);
+
+  React.useEffect(() => {
+    warning(
+      Boolean(setReferenceNode),
+      '`Reference` should not be used outside of a `Manager` component.'
+    );
+  }, [setReferenceNode]);
+
+  return unwrapArray(children)({ ref: refHandler });
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Test = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _ = require("..");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+var Test = function Test() {
+  var _React$createElement;
+
+  return /*#__PURE__*/React.createElement(_.Manager, null, /*#__PURE__*/React.createElement(_.Reference, null), /*#__PURE__*/React.createElement(_.Reference, null, function (_ref) {
+    var ref = _ref.ref;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref
+    });
+  }), /*#__PURE__*/React.createElement(_.Popper // $FlowExpectError: should be one of allowed placements
+  , (_React$createElement = {
+    placement: "custom"
+  }, _React$createElement["placement"] = "top", _React$createElement.strategy = "custom", _React$createElement["strategy"] = "fixed", _React$createElement.modifiers = [{
+    name: 'flip',
+    enabled: 'bar',
+    order: 'foo'
+  }], _React$createElement["modifiers"] = [{
+    name: 'flip',
+    enabled: false
+  }], _React$createElement), function (_ref2) {
+    var ref = _ref2.ref,
+        style = _ref2.style,
+        placement = _ref2.placement,
+        isReferenceHidden = _ref2.isReferenceHidden,
+        hasPopperEscaped = _ref2.hasPopperEscaped,
+        update = _ref2.update,
+        arrowProps = _ref2.arrowProps;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref,
+      style: _extends({}, style, {
+        opacity: isReferenceHidden === true || hasPopperEscaped === true ? 0 : 1
+      }),
+      "data-placement": placement,
+      onClick: function onClick() {
+        return update();
+      }
+    }, "Popper", /*#__PURE__*/React.createElement("div", {
+      ref: arrowProps.ref,
+      style: arrowProps.style
+    }));
+  }), /*#__PURE__*/React.createElement(_.Popper, null, function (_ref3) {
+    var ref = _ref3.ref,
+        style = _ref3.style,
+        placement = _ref3.placement;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref,
+      style: style,
+      "data-placement": placement
+    }, "Popper");
+  }));
+};
+
+exports.Test = Test;

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

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Popper", {
+  enumerable: true,
+  get: function get() {
+    return _Popper.Popper;
+  }
+});
+Object.defineProperty(exports, "Manager", {
+  enumerable: true,
+  get: function get() {
+    return _Manager.Manager;
+  }
+});
+Object.defineProperty(exports, "Reference", {
+  enumerable: true,
+  get: function get() {
+    return _Reference.Reference;
+  }
+});
+Object.defineProperty(exports, "usePopper", {
+  enumerable: true,
+  get: function get() {
+    return _usePopper.usePopper;
+  }
+});
+
+var _Popper = require("./Popper");
+
+var _Manager = require("./Manager");
+
+var _Reference = require("./Reference");
+
+var _usePopper = require("./usePopper");

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

@@ -0,0 +1,25 @@
+// @flow strict
+
+// Public components
+import { Popper } from './Popper';
+import { Manager } from './Manager';
+import { Reference } from './Reference';
+import { usePopper } from './usePopper';
+export { Popper, Manager, Reference, usePopper };
+
+// Public types
+import type { ManagerProps } from './Manager';
+import type { ReferenceProps, ReferenceChildrenProps } from './Reference';
+import type {
+  PopperChildrenProps,
+  PopperArrowProps,
+  PopperProps,
+} from './Popper';
+export type {
+  ManagerProps,
+  ReferenceProps,
+  ReferenceChildrenProps,
+  PopperChildrenProps,
+  PopperArrowProps,
+  PopperProps,
+};

node_modules/react-popper/lib/cjs/usePopper.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePopper = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var ReactDOM = _interopRequireWildcard(require("react-dom"));
+
+var _core = require("@popperjs/core");
+
+var _reactFastCompare = _interopRequireDefault(require("react-fast-compare"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var EMPTY_MODIFIERS = [];
+
+var usePopper = function usePopper(referenceElement, popperElement, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var prevOptions = React.useRef(null);
+  var optionsWithDefaults = {
+    onFirstUpdate: options.onFirstUpdate,
+    placement: options.placement || 'bottom',
+    strategy: options.strategy || 'absolute',
+    modifiers: options.modifiers || EMPTY_MODIFIERS
+  };
+
+  var _React$useState = React.useState({
+    styles: {
+      popper: {
+        position: optionsWithDefaults.strategy,
+        left: '0',
+        top: '0'
+      },
+      arrow: {
+        position: 'absolute'
+      }
+    },
+    attributes: {}
+  }),
+      state = _React$useState[0],
+      setState = _React$useState[1];
+
+  var updateStateModifier = React.useMemo(function () {
+    return {
+      name: 'updateState',
+      enabled: true,
+      phase: 'write',
+      fn: function fn(_ref) {
+        var state = _ref.state;
+        var elements = Object.keys(state.elements);
+        ReactDOM.flushSync(function () {
+          setState({
+            styles: (0, _utils.fromEntries)(elements.map(function (element) {
+              return [element, state.styles[element] || {}];
+            })),
+            attributes: (0, _utils.fromEntries)(elements.map(function (element) {
+              return [element, state.attributes[element]];
+            }))
+          });
+        });
+      },
+      requires: ['computeStyles']
+    };
+  }, []);
+  var popperOptions = React.useMemo(function () {
+    var newOptions = {
+      onFirstUpdate: optionsWithDefaults.onFirstUpdate,
+      placement: optionsWithDefaults.placement,
+      strategy: optionsWithDefaults.strategy,
+      modifiers: [].concat(optionsWithDefaults.modifiers, [updateStateModifier, {
+        name: 'applyStyles',
+        enabled: false
+      }])
+    };
+
+    if ((0, _reactFastCompare["default"])(prevOptions.current, newOptions)) {
+      return prevOptions.current || newOptions;
+    } else {
+      prevOptions.current = newOptions;
+      return newOptions;
+    }
+  }, [optionsWithDefaults.onFirstUpdate, optionsWithDefaults.placement, optionsWithDefaults.strategy, optionsWithDefaults.modifiers, updateStateModifier]);
+  var popperInstanceRef = React.useRef();
+  (0, _utils.useIsomorphicLayoutEffect)(function () {
+    if (popperInstanceRef.current) {
+      popperInstanceRef.current.setOptions(popperOptions);
+    }
+  }, [popperOptions]);
+  (0, _utils.useIsomorphicLayoutEffect)(function () {
+    if (referenceElement == null || popperElement == null) {
+      return;
+    }
+
+    var createPopper = options.createPopper || _core.createPopper;
+    var popperInstance = createPopper(referenceElement, popperElement, popperOptions);
+    popperInstanceRef.current = popperInstance;
+    return function () {
+      popperInstance.destroy();
+      popperInstanceRef.current = null;
+    };
+  }, [referenceElement, popperElement, options.createPopper]);
+  return {
+    state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
+    styles: state.styles,
+    attributes: state.attributes,
+    update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
+    forceUpdate: popperInstanceRef.current ? popperInstanceRef.current.forceUpdate : null
+  };
+};
+
+exports.usePopper = usePopper;

node_modules/react-popper/lib/cjs/usePopper.js.flow

@@ -0,0 +1,157 @@
+// @flow strict
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import {
+  createPopper as defaultCreatePopper,
+  type Options as PopperOptions,
+  type VirtualElement,
+  type State as PopperState,
+  type Instance as PopperInstance,
+} from '@popperjs/core';
+import isEqual from 'react-fast-compare';
+import { fromEntries, useIsomorphicLayoutEffect } from './utils';
+
+type Options = $Shape<{
+  ...PopperOptions,
+  createPopper: typeof defaultCreatePopper,
+}>;
+
+type Styles = {
+  [key: string]: $Shape<CSSStyleDeclaration>,
+};
+
+type Attributes = {
+  [key: string]: { [key: string]: string },
+};
+
+type State = {
+  styles: Styles,
+  attributes: Attributes,
+};
+
+const EMPTY_MODIFIERS = [];
+
+type UsePopperResult = $ReadOnly<{
+  state: ?PopperState,
+  styles: Styles,
+  attributes: Attributes,
+  update: ?$PropertyType<PopperInstance, 'update'>,
+  forceUpdate: ?$PropertyType<PopperInstance, 'forceUpdate'>,
+}>;
+
+export const usePopper = (
+  referenceElement: ?(Element | VirtualElement),
+  popperElement: ?HTMLElement,
+  options: Options = {}
+): UsePopperResult => {
+  const prevOptions = React.useRef<?PopperOptions>(null);
+
+  const optionsWithDefaults = {
+    onFirstUpdate: options.onFirstUpdate,
+    placement: options.placement || 'bottom',
+    strategy: options.strategy || 'absolute',
+    modifiers: options.modifiers || EMPTY_MODIFIERS,
+  };
+
+  const [state, setState] = React.useState<State>({
+    styles: {
+      popper: {
+        position: optionsWithDefaults.strategy,
+        left: '0',
+        top: '0',
+      },
+      arrow: {
+        position: 'absolute',
+      },
+    },
+    attributes: {},
+  });
+
+  const updateStateModifier = React.useMemo(
+    () => ({
+      name: 'updateState',
+      enabled: true,
+      phase: 'write',
+      fn: ({ state }) => {
+        const elements = Object.keys(state.elements);
+
+        ReactDOM.flushSync(() => {
+          setState({
+            styles: fromEntries(
+              elements.map((element) => [element, state.styles[element] || {}])
+            ),
+            attributes: fromEntries(
+              elements.map((element) => [element, state.attributes[element]])
+            ),
+          });
+        });
+      },
+      requires: ['computeStyles'],
+    }),
+    []
+  );
+
+  const popperOptions = React.useMemo(() => {
+    const newOptions = {
+      onFirstUpdate: optionsWithDefaults.onFirstUpdate,
+      placement: optionsWithDefaults.placement,
+      strategy: optionsWithDefaults.strategy,
+      modifiers: [
+        ...optionsWithDefaults.modifiers,
+        updateStateModifier,
+        { name: 'applyStyles', enabled: false },
+      ],
+    };
+
+    if (isEqual(prevOptions.current, newOptions)) {
+      return prevOptions.current || newOptions;
+    } else {
+      prevOptions.current = newOptions;
+      return newOptions;
+    }
+  }, [
+    optionsWithDefaults.onFirstUpdate,
+    optionsWithDefaults.placement,
+    optionsWithDefaults.strategy,
+    optionsWithDefaults.modifiers,
+    updateStateModifier,
+  ]);
+
+  const popperInstanceRef = React.useRef();
+
+  useIsomorphicLayoutEffect(() => {
+    if (popperInstanceRef.current) {
+      popperInstanceRef.current.setOptions(popperOptions);
+    }
+  }, [popperOptions]);
+
+  useIsomorphicLayoutEffect(() => {
+    if (referenceElement == null || popperElement == null) {
+      return;
+    }
+
+    const createPopper = options.createPopper || defaultCreatePopper;
+    const popperInstance = createPopper(
+      referenceElement,
+      popperElement,
+      popperOptions
+    );
+
+    popperInstanceRef.current = popperInstance;
+
+    return () => {
+      popperInstance.destroy();
+      popperInstanceRef.current = null;
+    };
+  }, [referenceElement, popperElement, options.createPopper]);
+
+  return {
+    state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
+    styles: state.styles,
+    attributes: state.attributes,
+    update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
+    forceUpdate: popperInstanceRef.current
+      ? popperInstanceRef.current.forceUpdate
+      : null,
+  };
+};

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

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsomorphicLayoutEffect = exports.fromEntries = exports.setRef = exports.safeInvoke = exports.unwrapArray = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * 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);
+  }
+};
+/**
+ * Sets a ref using either a ref callback or a ref object
+ */
+
+
+exports.safeInvoke = safeInvoke;
+
+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;
+    }
+};
+/**
+ * Simple ponyfill for Object.fromEntries
+ */
+
+
+exports.setRef = setRef;
+
+var fromEntries = function fromEntries(entries) {
+  return entries.reduce(function (acc, _ref) {
+    var key = _ref[0],
+        value = _ref[1];
+    acc[key] = value;
+    return acc;
+  }, {});
+};
+/**
+ * Small wrapper around `useLayoutEffect` to get rid of the warning on SSR envs
+ */
+
+
+exports.fromEntries = fromEntries;
+var useIsomorphicLayoutEffect = typeof window !== 'undefined' && window.document && window.document.createElement ? React.useLayoutEffect : React.useEffect;
+exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;

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

@@ -0,0 +1,59 @@
+// @flow strict
+import * as React from 'react';
+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 = <F: Function>(
+  fn: ?F,
+  ...args: Array<mixed>
+): $Call<F> => {
+  if (typeof fn === 'function') {
+    return fn(...args);
+  }
+};
+
+/**
+ * Sets a ref using either a ref callback or a ref object
+ */
+export const setRef = (ref: ?Ref, node: ?HTMLElement): void => {
+  // 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;
+  }
+};
+
+/**
+ * Simple ponyfill for Object.fromEntries
+ */
+export const fromEntries = (
+  entries: Array<[string, any]>
+): { [key: string]: any } =>
+  entries.reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+  }, {});
+
+/**
+ * Small wrapper around `useLayoutEffect` to get rid of the warning on SSR envs
+ */
+export const useIsomorphicLayoutEffect:
+  | typeof React.useEffect
+  | typeof React.useLayoutEffect =
+  typeof window !== 'undefined' &&
+  window.document &&
+  window.document.createElement
+    ? React.useLayoutEffect
+    : React.useEffect;

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

@@ -0,0 +1,27 @@
+import * as React from 'react';
+export var ManagerReferenceNodeContext = React.createContext();
+export var ManagerReferenceNodeSetterContext = React.createContext();
+export function Manager(_ref) {
+  var children = _ref.children;
+
+  var _React$useState = React.useState(null),
+      referenceNode = _React$useState[0],
+      setReferenceNode = _React$useState[1];
+
+  var hasUnmounted = React.useRef(false);
+  React.useEffect(function () {
+    return function () {
+      hasUnmounted.current = true;
+    };
+  }, []);
+  var handleSetReferenceNode = React.useCallback(function (node) {
+    if (!hasUnmounted.current) {
+      setReferenceNode(node);
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(ManagerReferenceNodeContext.Provider, {
+    value: referenceNode
+  }, /*#__PURE__*/React.createElement(ManagerReferenceNodeSetterContext.Provider, {
+    value: handleSetReferenceNode
+  }, children));
+}

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

@@ -0,0 +1,76 @@
+import * as React from 'react';
+import { ManagerReferenceNodeContext } from './Manager';
+import { unwrapArray, setRef } from './utils';
+import { usePopper } from './usePopper';
+
+var NOOP = function NOOP() {
+  return void 0;
+};
+
+var NOOP_PROMISE = function NOOP_PROMISE() {
+  return Promise.resolve(null);
+};
+
+var EMPTY_MODIFIERS = [];
+export function Popper(_ref) {
+  var _ref$placement = _ref.placement,
+      placement = _ref$placement === void 0 ? 'bottom' : _ref$placement,
+      _ref$strategy = _ref.strategy,
+      strategy = _ref$strategy === void 0 ? 'absolute' : _ref$strategy,
+      _ref$modifiers = _ref.modifiers,
+      modifiers = _ref$modifiers === void 0 ? EMPTY_MODIFIERS : _ref$modifiers,
+      referenceElement = _ref.referenceElement,
+      onFirstUpdate = _ref.onFirstUpdate,
+      innerRef = _ref.innerRef,
+      children = _ref.children;
+  var referenceNode = React.useContext(ManagerReferenceNodeContext);
+
+  var _React$useState = React.useState(null),
+      popperElement = _React$useState[0],
+      setPopperElement = _React$useState[1];
+
+  var _React$useState2 = React.useState(null),
+      arrowElement = _React$useState2[0],
+      setArrowElement = _React$useState2[1];
+
+  React.useEffect(function () {
+    setRef(innerRef, popperElement);
+  }, [innerRef, popperElement]);
+  var options = React.useMemo(function () {
+    return {
+      placement: placement,
+      strategy: strategy,
+      onFirstUpdate: onFirstUpdate,
+      modifiers: [].concat(modifiers, [{
+        name: 'arrow',
+        enabled: arrowElement != null,
+        options: {
+          element: arrowElement
+        }
+      }])
+    };
+  }, [placement, strategy, onFirstUpdate, modifiers, arrowElement]);
+
+  var _usePopper = usePopper(referenceElement || referenceNode, popperElement, options),
+      state = _usePopper.state,
+      styles = _usePopper.styles,
+      forceUpdate = _usePopper.forceUpdate,
+      update = _usePopper.update;
+
+  var childrenProps = React.useMemo(function () {
+    return {
+      ref: setPopperElement,
+      style: styles.popper,
+      placement: state ? state.placement : placement,
+      hasPopperEscaped: state && state.modifiersData.hide ? state.modifiersData.hide.hasPopperEscaped : null,
+      isReferenceHidden: state && state.modifiersData.hide ? state.modifiersData.hide.isReferenceHidden : null,
+      arrowProps: {
+        style: styles.arrow,
+        ref: setArrowElement
+      },
+      forceUpdate: forceUpdate || NOOP,
+      update: update || NOOP_PROMISE
+    };
+  }, [setPopperElement, setArrowElement, placement, state, styles, update, forceUpdate]);
+  return unwrapArray(children)(childrenProps);
+}

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

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import warning from 'warning';
+import { ManagerReferenceNodeSetterContext } from './Manager';
+import { safeInvoke, unwrapArray, setRef } from './utils';
+export function Reference(_ref) {
+  var children = _ref.children,
+      innerRef = _ref.innerRef;
+  var setReferenceNode = React.useContext(ManagerReferenceNodeSetterContext);
+  var refHandler = React.useCallback(function (node) {
+    setRef(innerRef, node);
+    safeInvoke(setReferenceNode, node);
+  }, [innerRef, setReferenceNode]); // ran on unmount
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  React.useEffect(function () {
+    return function () {
+      return setRef(innerRef, null);
+    };
+  }, []);
+  React.useEffect(function () {
+    warning(Boolean(setReferenceNode), '`Reference` should not be used outside of a `Manager` component.');
+  }, [setReferenceNode]);
+  return unwrapArray(children)({
+    ref: refHandler
+  });
+}

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

@@ -0,0 +1,56 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+// Please remember to update also the TypeScript test files that can
+// be found under `/typings/tests` please. Thanks! 🤗
+import * as React from 'react';
+import { Manager, Reference, Popper } from '..';
+export var Test = function Test() {
+  var _React$createElement;
+
+  return /*#__PURE__*/React.createElement(Manager, null, /*#__PURE__*/React.createElement(Reference, null), /*#__PURE__*/React.createElement(Reference, null, function (_ref) {
+    var ref = _ref.ref;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref
+    });
+  }), /*#__PURE__*/React.createElement(Popper // $FlowExpectError: should be one of allowed placements
+  , (_React$createElement = {
+    placement: "custom"
+  }, _React$createElement["placement"] = "top", _React$createElement.strategy = "custom", _React$createElement["strategy"] = "fixed", _React$createElement.modifiers = [{
+    name: 'flip',
+    enabled: 'bar',
+    order: 'foo'
+  }], _React$createElement["modifiers"] = [{
+    name: 'flip',
+    enabled: false
+  }], _React$createElement), function (_ref2) {
+    var ref = _ref2.ref,
+        style = _ref2.style,
+        placement = _ref2.placement,
+        isReferenceHidden = _ref2.isReferenceHidden,
+        hasPopperEscaped = _ref2.hasPopperEscaped,
+        update = _ref2.update,
+        arrowProps = _ref2.arrowProps;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref,
+      style: _extends({}, style, {
+        opacity: isReferenceHidden === true || hasPopperEscaped === true ? 0 : 1
+      }),
+      "data-placement": placement,
+      onClick: function onClick() {
+        return update();
+      }
+    }, "Popper", /*#__PURE__*/React.createElement("div", {
+      ref: arrowProps.ref,
+      style: arrowProps.style
+    }));
+  }), /*#__PURE__*/React.createElement(Popper, null, function (_ref3) {
+    var ref = _ref3.ref,
+        style = _ref3.style,
+        placement = _ref3.placement;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref,
+      style: style,
+      "data-placement": placement
+    }, "Popper");
+  }));
+};

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

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

node_modules/react-popper/lib/esm/usePopper.js

@@ -0,0 +1,102 @@
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { createPopper as defaultCreatePopper } from '@popperjs/core';
+import isEqual from 'react-fast-compare';
+import { fromEntries, useIsomorphicLayoutEffect } from './utils';
+var EMPTY_MODIFIERS = [];
+export var usePopper = function usePopper(referenceElement, popperElement, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var prevOptions = React.useRef(null);
+  var optionsWithDefaults = {
+    onFirstUpdate: options.onFirstUpdate,
+    placement: options.placement || 'bottom',
+    strategy: options.strategy || 'absolute',
+    modifiers: options.modifiers || EMPTY_MODIFIERS
+  };
+
+  var _React$useState = React.useState({
+    styles: {
+      popper: {
+        position: optionsWithDefaults.strategy,
+        left: '0',
+        top: '0'
+      },
+      arrow: {
+        position: 'absolute'
+      }
+    },
+    attributes: {}
+  }),
+      state = _React$useState[0],
+      setState = _React$useState[1];
+
+  var updateStateModifier = React.useMemo(function () {
+    return {
+      name: 'updateState',
+      enabled: true,
+      phase: 'write',
+      fn: function fn(_ref) {
+        var state = _ref.state;
+        var elements = Object.keys(state.elements);
+        ReactDOM.flushSync(function () {
+          setState({
+            styles: fromEntries(elements.map(function (element) {
+              return [element, state.styles[element] || {}];
+            })),
+            attributes: fromEntries(elements.map(function (element) {
+              return [element, state.attributes[element]];
+            }))
+          });
+        });
+      },
+      requires: ['computeStyles']
+    };
+  }, []);
+  var popperOptions = React.useMemo(function () {
+    var newOptions = {
+      onFirstUpdate: optionsWithDefaults.onFirstUpdate,
+      placement: optionsWithDefaults.placement,
+      strategy: optionsWithDefaults.strategy,
+      modifiers: [].concat(optionsWithDefaults.modifiers, [updateStateModifier, {
+        name: 'applyStyles',
+        enabled: false
+      }])
+    };
+
+    if (isEqual(prevOptions.current, newOptions)) {
+      return prevOptions.current || newOptions;
+    } else {
+      prevOptions.current = newOptions;
+      return newOptions;
+    }
+  }, [optionsWithDefaults.onFirstUpdate, optionsWithDefaults.placement, optionsWithDefaults.strategy, optionsWithDefaults.modifiers, updateStateModifier]);
+  var popperInstanceRef = React.useRef();
+  useIsomorphicLayoutEffect(function () {
+    if (popperInstanceRef.current) {
+      popperInstanceRef.current.setOptions(popperOptions);
+    }
+  }, [popperOptions]);
+  useIsomorphicLayoutEffect(function () {
+    if (referenceElement == null || popperElement == null) {
+      return;
+    }
+
+    var createPopper = options.createPopper || defaultCreatePopper;
+    var popperInstance = createPopper(referenceElement, popperElement, popperOptions);
+    popperInstanceRef.current = popperInstance;
+    return function () {
+      popperInstance.destroy();
+      popperInstanceRef.current = null;
+    };
+  }, [referenceElement, popperElement, options.createPopper]);
+  return {
+    state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
+    styles: state.styles,
+    attributes: state.attributes,
+    update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
+    forceUpdate: popperInstanceRef.current ? popperInstanceRef.current.forceUpdate : null
+  };
+};

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

@@ -0,0 +1,53 @@
+import * as React from 'react';
+
+/**
+ * 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);
+  }
+};
+/**
+ * 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;
+    }
+};
+/**
+ * Simple ponyfill for Object.fromEntries
+ */
+
+export var fromEntries = function fromEntries(entries) {
+  return entries.reduce(function (acc, _ref) {
+    var key = _ref[0],
+        value = _ref[1];
+    acc[key] = value;
+    return acc;
+  }, {});
+};
+/**
+ * Small wrapper around `useLayoutEffect` to get rid of the warning on SSR envs
+ */
+
+export var useIsomorphicLayoutEffect = typeof window !== 'undefined' && window.document && window.document.createElement ? React.useLayoutEffect : React.useEffect;

node_modules/react-popper/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "react-popper",
+  "version": "2.3.0",
+  "description": "Official library to use Popper on React projects",
+  "license": "MIT",
+  "author": "Travis Arnold <travis@souporserious.com> (http://souporserious.com)",
+  "contributors": [
+    "Federico Zivolo <federico.zivolo@gmail.com> (https://fezvrasta.github.io)"
+  ],
+  "homepage": "https://popper.js.org/react-popper",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "typings": "typings/react-popper.d.ts",
+  "sideEffects": false,
+  "files": [
+    "/dist",
+    "/lib",
+    "/typings/react-popper.d.ts"
+  ],
+  "scripts": {
+    "build": "yarn build:clean && yarn build:esm && yarn build:cjs && yarn build:umd && yarn build:flow",
+    "build:clean": "rimraf dist/ && rimraf lib/",
+    "build:umd": "rollup -c && rimraf dist/index.esm.js",
+    "build:esm": "cross-env BABEL_ENV=esm babel src --out-dir lib/esm",
+    "build:cjs": "cross-env BABEL_ENV=cjs babel src --out-dir lib/cjs",
+    "build:flow": "flow-copy-source --ignore '{__typings__/*,*.test}.js' src lib/cjs",
+    "demo:dev": "parcel --out-dir demo/dist demo/index.html",
+    "demo:build": "parcel build --out-dir demo/dist demo/index.html --public-url=/react-popper",
+    "demo:deploy": "yarn demo:build && gh-pages -d demo/dist",
+    "test": "yarn test:eslint && yarn test:flow && yarn test:ts && yarn test:jest",
+    "test:ts": "tsc --project ./typings/tests",
+    "test:flow": "flow check",
+    "test:jest": "jest",
+    "test:eslint": "eslint src",
+    "prepare": "yarn build",
+    "precommit": "pretty-quick --staged && test",
+    "prepublishOnly": "git-branch-is master"
+  },
+  "jest": {
+    "setupFilesAfterEnv": [
+      "<rootDir>jest.setup.js"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/popperjs/react-popper"
+  },
+  "bugs": {
+    "url": "https://github.com/popperjs/react-popper/issues"
+  },
+  "keywords": [
+    "react",
+    "react-popper",
+    "popperjs",
+    "component",
+    "drop",
+    "tooltip",
+    "popover"
+  ],
+  "peerDependencies": {
+    "@popperjs/core": "^2.0.0",
+    "react": "^16.8.0 || ^17 || ^18",
+    "react-dom": "^16.8.0 || ^17 || ^18"
+  },
+  "dependencies": {
+    "react-fast-compare": "^3.0.1",
+    "warning": "^4.0.2"
+  },
+  "devDependencies": {
+    "@atomico/rollup-plugin-sizes": "^1.1.3",
+    "@babel/cli": "^7.8.4",
+    "@babel/core": "^7.9.0",
+    "@babel/plugin-transform-modules-commonjs": "^7.9.0",
+    "@babel/polyfill": "^7.8.7",
+    "@babel/preset-env": "^7.9.0",
+    "@babel/preset-flow": "^7.9.0",
+    "@babel/preset-react": "^7.9.4",
+    "@emotion/core": "^10.0.28",
+    "@emotion/styled": "^10.0.27",
+    "@popperjs/core": "^2.3.3",
+    "@rollup/plugin-commonjs": "^11.0.2",
+    "@rollup/plugin-node-resolve": "^7.1.1",
+    "@rollup/plugin-replace": "^2.3.1",
+    "@testing-library/react": "^13.1.1",
+    "@testing-library/react-hooks": "^8.0.0",
+    "@types/react": "^16.9.29",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^25.2.4",
+    "cross-env": "^7.0.2",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.10.1",
+    "eslint-plugin-flowtype": "^4.7.0",
+    "eslint-plugin-jest": "^23.8.2",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-react": "^7.19.0",
+    "eslint-plugin-react-hooks": "^3.0.0",
+    "flow-bin": "^0.176.2",
+    "flow-copy-source": "^2.0.9",
+    "gh-pages": "^2.2.0",
+    "git-branch-is": "^3.1.0",
+    "jest": "^25.2.4",
+    "parcel-bundler": "^1.12.4",
+    "prettier": "^2.0.2",
+    "pretty-quick": "^2.0.1",
+    "react": "18.0.0",
+    "react-dom": "^18.0.0",
+    "react-spring": "^8.0.27",
+    "react-test-renderer": "^18.0.0",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.3.1",
+    "rollup-plugin-babel": "^4.4.0",
+    "rollup-plugin-terser": "^5.3.0",
+    "typescript": "^3.8.3"
+  }
+}

node_modules/react-popper/typings/react-popper.d.ts

@@ -0,0 +1,85 @@
+import * as PopperJS from '@popperjs/core';
+import * as React from 'react';
+
+// Utility type
+type UnionWhere<U, M> = U extends M ? U : never;
+
+interface ManagerProps {
+  children: React.ReactNode;
+}
+export class Manager extends React.Component<ManagerProps, {}> {}
+
+export type RefHandler = (ref: HTMLElement | null) => void;
+
+interface ReferenceChildrenProps {
+  // React refs are supposed to be contravariant (allows a more general type to be passed rather than a more specific one)
+  // However, Typescript currently can't infer that fact for refs
+  // See https://github.com/microsoft/TypeScript/issues/30748 for more information
+  ref: React.Ref<any>;
+}
+
+interface ReferenceProps {
+  children: (props: ReferenceChildrenProps) => React.ReactNode;
+  innerRef?: React.Ref<any>;
+}
+export class Reference extends React.Component<ReferenceProps, {}> {}
+
+export interface PopperArrowProps {
+  ref: React.Ref<any>;
+  style: React.CSSProperties;
+}
+
+export interface PopperChildrenProps {
+  ref: React.Ref<any>;
+  style: React.CSSProperties;
+
+  placement: PopperJS.Placement;
+  isReferenceHidden?: boolean;
+  hasPopperEscaped?: boolean;
+
+  update: () => Promise<null | Partial<PopperJS.State>>;
+  forceUpdate: () => Partial<PopperJS.State>;
+  arrowProps: PopperArrowProps;
+}
+
+type StrictModifierNames = NonNullable<PopperJS.StrictModifiers['name']>;
+
+export type StrictModifier<
+  Name extends StrictModifierNames = StrictModifierNames
+> = UnionWhere<PopperJS.StrictModifiers, { name?: Name }>;
+
+export type Modifier<
+  Name,
+  Options extends object = object
+> = Name extends StrictModifierNames
+  ? StrictModifier<Name>
+  : Partial<PopperJS.Modifier<Name, Options>>;
+
+export interface PopperProps<Modifiers> {
+  children: (props: PopperChildrenProps) => React.ReactNode;
+  innerRef?: React.Ref<any>;
+  modifiers?: ReadonlyArray<Modifier<Modifiers>>;
+  placement?: PopperJS.Placement;
+  strategy?: PopperJS.PositioningStrategy;
+  referenceElement?: HTMLElement | PopperJS.VirtualElement;
+  onFirstUpdate?: (state: Partial<PopperJS.State>) => void;
+}
+export class Popper<Modifiers> extends React.Component<
+  PopperProps<Modifiers>,
+  {}
+> {}
+
+export function usePopper<Modifiers>(
+  referenceElement?: Element | PopperJS.VirtualElement | null,
+  popperElement?: HTMLElement | null,
+  options?: Omit<Partial<PopperJS.Options>, 'modifiers'> & {
+    createPopper?: typeof PopperJS.createPopper;
+    modifiers?: ReadonlyArray<Modifier<Modifiers>>;
+  }
+): {
+  styles: { [key: string]: React.CSSProperties };
+  attributes: { [key: string]: { [key: string]: string } | undefined };
+  state: PopperJS.State | null;
+  update: PopperJS.Instance['update'] | null;
+  forceUpdate: PopperJS.Instance['forceUpdate'] | null;
+};