@dartcom/ui-kit 3.4.1 → 3.4.3

package/dist/node_modules/react-is/cjs/react-is.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-is.production.js","sources":["../../../../node_modules/react-is/cjs/react-is.production.js"],"sourcesContent":["/**\n * @license React\n * react-is.production.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\"use strict\";\nvar REACT_ELEMENT_TYPE = Symbol.for(\"react.transitional.element\"),\n  REACT_PORTAL_TYPE = Symbol.for(\"react.portal\"),\n  REACT_FRAGMENT_TYPE = Symbol.for(\"react.fragment\"),\n  REACT_STRICT_MODE_TYPE = Symbol.for(\"react.strict_mode\"),\n  REACT_PROFILER_TYPE = Symbol.for(\"react.profiler\"),\n  REACT_CONSUMER_TYPE = Symbol.for(\"react.consumer\"),\n  REACT_CONTEXT_TYPE = Symbol.for(\"react.context\"),\n  REACT_FORWARD_REF_TYPE = Symbol.for(\"react.forward_ref\"),\n  REACT_SUSPENSE_TYPE = Symbol.for(\"react.suspense\"),\n  REACT_SUSPENSE_LIST_TYPE = Symbol.for(\"react.suspense_list\"),\n  REACT_MEMO_TYPE = Symbol.for(\"react.memo\"),\n  REACT_LAZY_TYPE = Symbol.for(\"react.lazy\"),\n  REACT_VIEW_TRANSITION_TYPE = Symbol.for(\"react.view_transition\"),\n  REACT_CLIENT_REFERENCE = Symbol.for(\"react.client.reference\");\nfunction typeOf(object) {\n  if (\"object\" === typeof object && null !== object) {\n    var $$typeof = object.$$typeof;\n    switch ($$typeof) {\n      case REACT_ELEMENT_TYPE:\n        switch (((object = object.type), object)) {\n          case REACT_FRAGMENT_TYPE:\n          case REACT_PROFILER_TYPE:\n          case REACT_STRICT_MODE_TYPE:\n          case REACT_SUSPENSE_TYPE:\n          case REACT_SUSPENSE_LIST_TYPE:\n          case REACT_VIEW_TRANSITION_TYPE:\n            return object;\n          default:\n            switch (((object = object && object.$$typeof), object)) {\n              case REACT_CONTEXT_TYPE:\n              case REACT_FORWARD_REF_TYPE:\n              case REACT_LAZY_TYPE:\n              case REACT_MEMO_TYPE:\n                return object;\n              case REACT_CONSUMER_TYPE:\n                return object;\n              default:\n                return $$typeof;\n            }\n        }\n      case REACT_PORTAL_TYPE:\n        return $$typeof;\n    }\n  }\n}\nexports.ContextConsumer = REACT_CONSUMER_TYPE;\nexports.ContextProvider = REACT_CONTEXT_TYPE;\nexports.Element = REACT_ELEMENT_TYPE;\nexports.ForwardRef = REACT_FORWARD_REF_TYPE;\nexports.Fragment = REACT_FRAGMENT_TYPE;\nexports.Lazy = REACT_LAZY_TYPE;\nexports.Memo = REACT_MEMO_TYPE;\nexports.Portal = REACT_PORTAL_TYPE;\nexports.Profiler = REACT_PROFILER_TYPE;\nexports.StrictMode = REACT_STRICT_MODE_TYPE;\nexports.Suspense = REACT_SUSPENSE_TYPE;\nexports.SuspenseList = REACT_SUSPENSE_LIST_TYPE;\nexports.isContextConsumer = function (object) {\n  return typeOf(object) === REACT_CONSUMER_TYPE;\n};\nexports.isContextProvider = function (object) {\n  return typeOf(object) === REACT_CONTEXT_TYPE;\n};\nexports.isElement = function (object) {\n  return (\n    \"object\" === typeof object &&\n    null !== object &&\n    object.$$typeof === REACT_ELEMENT_TYPE\n  );\n};\nexports.isForwardRef = function (object) {\n  return typeOf(object) === REACT_FORWARD_REF_TYPE;\n};\nexports.isFragment = function (object) {\n  return typeOf(object) === REACT_FRAGMENT_TYPE;\n};\nexports.isLazy = function (object) {\n  return typeOf(object) === REACT_LAZY_TYPE;\n};\nexports.isMemo = function (object) {\n  return typeOf(object) === REACT_MEMO_TYPE;\n};\nexports.isPortal = function (object) {\n  return typeOf(object) === REACT_PORTAL_TYPE;\n};\nexports.isProfiler = function (object) {\n  return typeOf(object) === REACT_PROFILER_TYPE;\n};\nexports.isStrictMode = function (object) {\n  return typeOf(object) === REACT_STRICT_MODE_TYPE;\n};\nexports.isSuspense = function (object) {\n  return typeOf(object) === REACT_SUSPENSE_TYPE;\n};\nexports.isSuspenseList = function (object) {\n  return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;\n};\nexports.isValidElementType = function (type) {\n  return \"string\" === typeof type ||\n    \"function\" === typeof type ||\n    type === REACT_FRAGMENT_TYPE ||\n    type === REACT_PROFILER_TYPE ||\n    type === REACT_STRICT_MODE_TYPE ||\n    type === REACT_SUSPENSE_TYPE ||\n    type === REACT_SUSPENSE_LIST_TYPE ||\n    (\"object\" === typeof type &&\n      null !== type &&\n      (type.$$typeof === REACT_LAZY_TYPE ||\n        type.$$typeof === REACT_MEMO_TYPE ||\n        type.$$typeof === REACT_CONTEXT_TYPE ||\n        type.$$typeof === REACT_CONSUMER_TYPE ||\n        type.$$typeof === REACT_FORWARD_REF_TYPE ||\n        type.$$typeof === REACT_CLIENT_REFERENCE ||\n        void 0 !== type.getModuleId))\n    ? !0\n    : !1;\n};\nexports.typeOf = typeOf;\n"],"names":["reactIs_production"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/react-is/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var index = require('../../_virtual/index4.js');
+var reactIs_production = require('./cjs/react-is.production.js');
+var reactIs_development = require('./cjs/react-is.development.js');
+
+var hasRequiredReactIs;
+
+function requireReactIs () {
+	if (hasRequiredReactIs) return index.__module.exports;
+	hasRequiredReactIs = 1;
+
+	if (process.env.NODE_ENV === 'production') {
+	  index.__module.exports = /*@__PURE__*/ reactIs_production.__require();
+	} else {
+	  index.__module.exports = /*@__PURE__*/ reactIs_development.__require();
+	}
+	return index.__module.exports;
+}
+
+exports.__require = requireReactIs;
+//# sourceMappingURL=index.js.map

package/dist/node_modules/react-is/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../node_modules/react-is/index.js"],"sourcesContent":["'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n"],"names":["reactIsModule","require$$0","require$$1"],"mappings":";;;;;;;;;;;;AAEA,CAAA,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,EAAE;GACzCA,cAAA,CAAA,OAAc,iBAAGC,4BAAA,EAAuC;AAC1D,CAAA,CAAC,MAAM;GACLD,cAAA,CAAA,OAAc,iBAAGE,6BAAA,EAAwC;AAC3D,CAAA;;;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/react-leaflet/lib/hooks.js

@@ -0,0 +1,11 @@
+'use strict';
+
+require('react');
+var context = require('../../@react-leaflet/core/lib/context.js');
+
+function useMap() {
+    return context.useLeafletContext().map;
+}
+
+exports.useMap = useMap;
+//# sourceMappingURL=hooks.js.map

package/dist/node_modules/react-leaflet/lib/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sources":["../../../../node_modules/react-leaflet/lib/hooks.js"],"sourcesContent":["import { useLeafletContext } from '@react-leaflet/core';\nimport { useEffect } from 'react';\nexport function useMap() {\n    return useLeafletContext().map;\n}\nexport function useMapEvent(type, handler) {\n    const map = useMap();\n    useEffect(function addMapEventHandler() {\n        // @ts-ignore event type\n        map.on(type, handler);\n        return function removeMapEventHandler() {\n            // @ts-ignore event type\n            map.off(type, handler);\n        };\n    }, [\n        map,\n        type,\n        handler\n    ]);\n    return map;\n}\nexport function useMapEvents(handlers) {\n    const map = useMap();\n    useEffect(function addMapEventHandlers() {\n        map.on(handlers);\n        return function removeMapEventHandlers() {\n            map.off(handlers);\n        };\n    }, [\n        map,\n        handlers\n    ]);\n    return map;\n}\n"],"names":["useLeafletContext"],"mappings":";;;;;AAEO,SAAS,MAAM,GAAG;AACzB,IAAI,OAAOA,yBAAiB,EAAE,CAAC,GAAG;AAClC;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/react-transition-group/esm/Transition.js

@@ -0,0 +1,637 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var objectWithoutPropertiesLoose = require('../../@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js');
+var inheritsLoose = require('../../@babel/runtime/helpers/esm/inheritsLoose.js');
+var index = require('../../../_virtual/index.js');
+var React = require('react');
+var ReactDOM = require('react-dom');
+var config = require('./config.js');
+var PropTypes = require('./utils/PropTypes.js');
+var TransitionGroupContext = require('./TransitionGroupContext.js');
+var reflow = require('./utils/reflow.js');
+
+var UNMOUNTED = 'unmounted';
+var EXITED = 'exited';
+var ENTERING = 'entering';
+var ENTERED = 'entered';
+var EXITING = 'exiting';
+/**
+ * The Transition component lets you describe a transition from one component
+ * state to another _over time_ with a simple declarative API. Most commonly
+ * it's used to animate the mounting and unmounting of a component, but can also
+ * be used to describe in-place transition states as well.
+ *
+ * ---
+ *
+ * **Note**: `Transition` is a platform-agnostic base component. If you're using
+ * transitions in CSS, you'll probably want to use
+ * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)
+ * instead. It inherits all the features of `Transition`, but contains
+ * additional features necessary to play nice with CSS transitions (hence the
+ * name of the component).
+ *
+ * ---
+ *
+ * By default the `Transition` component does not alter the behavior of the
+ * component it renders, it only tracks "enter" and "exit" states for the
+ * components. It's up to you to give meaning and effect to those states. For
+ * example we can add styles to a component when it enters or exits:
+ *
+ * ```jsx
+ * import { Transition } from 'react-transition-group';
+ *
+ * const duration = 300;
+ *
+ * const defaultStyle = {
+ *   transition: `opacity ${duration}ms ease-in-out`,
+ *   opacity: 0,
+ * }
+ *
+ * const transitionStyles = {
+ *   entering: { opacity: 1 },
+ *   entered:  { opacity: 1 },
+ *   exiting:  { opacity: 0 },
+ *   exited:  { opacity: 0 },
+ * };
+ *
+ * const Fade = ({ in: inProp }) => (
+ *   <Transition in={inProp} timeout={duration}>
+ *     {state => (
+ *       <div style={{
+ *         ...defaultStyle,
+ *         ...transitionStyles[state]
+ *       }}>
+ *         I'm a fade Transition!
+ *       </div>
+ *     )}
+ *   </Transition>
+ * );
+ * ```
+ *
+ * There are 4 main states a Transition can be in:
+ *  - `'entering'`
+ *  - `'entered'`
+ *  - `'exiting'`
+ *  - `'exited'`
+ *
+ * Transition state is toggled via the `in` prop. When `true` the component
+ * begins the "Enter" stage. During this stage, the component will shift from
+ * its current transition state, to `'entering'` for the duration of the
+ * transition and then to the `'entered'` stage once it's complete. Let's take
+ * the following example (we'll use the
+ * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):
+ *
+ * ```jsx
+ * function App() {
+ *   const [inProp, setInProp] = useState(false);
+ *   return (
+ *     <div>
+ *       <Transition in={inProp} timeout={500}>
+ *         {state => (
+ *           // ...
+ *         )}
+ *       </Transition>
+ *       <button onClick={() => setInProp(true)}>
+ *         Click to Enter
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * When the button is clicked the component will shift to the `'entering'` state
+ * and stay there for 500ms (the value of `timeout`) before it finally switches
+ * to `'entered'`.
+ *
+ * When `in` is `false` the same thing happens except the state moves from
+ * `'exiting'` to `'exited'`.
+ */
+
+var Transition = /*#__PURE__*/function (_React$Component) {
+  inheritsLoose.default(Transition, _React$Component);
+
+  function Transition(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears
+
+    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;
+    var initialStatus;
+    _this.appearStatus = null;
+
+    if (props.in) {
+      if (appear) {
+        initialStatus = EXITED;
+        _this.appearStatus = ENTERING;
+      } else {
+        initialStatus = ENTERED;
+      }
+    } else {
+      if (props.unmountOnExit || props.mountOnEnter) {
+        initialStatus = UNMOUNTED;
+      } else {
+        initialStatus = EXITED;
+      }
+    }
+
+    _this.state = {
+      status: initialStatus
+    };
+    _this.nextCallback = null;
+    return _this;
+  }
+
+  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {
+    var nextIn = _ref.in;
+
+    if (nextIn && prevState.status === UNMOUNTED) {
+      return {
+        status: EXITED
+      };
+    }
+
+    return null;
+  } // getSnapshotBeforeUpdate(prevProps) {
+  //   let nextStatus = null
+  //   if (prevProps !== this.props) {
+  //     const { status } = this.state
+  //     if (this.props.in) {
+  //       if (status !== ENTERING && status !== ENTERED) {
+  //         nextStatus = ENTERING
+  //       }
+  //     } else {
+  //       if (status === ENTERING || status === ENTERED) {
+  //         nextStatus = EXITING
+  //       }
+  //     }
+  //   }
+  //   return { nextStatus }
+  // }
+  ;
+
+  var _proto = Transition.prototype;
+
+  _proto.componentDidMount = function componentDidMount() {
+    this.updateStatus(true, this.appearStatus);
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    var nextStatus = null;
+
+    if (prevProps !== this.props) {
+      var status = this.state.status;
+
+      if (this.props.in) {
+        if (status !== ENTERING && status !== ENTERED) {
+          nextStatus = ENTERING;
+        }
+      } else {
+        if (status === ENTERING || status === ENTERED) {
+          nextStatus = EXITING;
+        }
+      }
+    }
+
+    this.updateStatus(false, nextStatus);
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.cancelNextCallback();
+  };
+
+  _proto.getTimeouts = function getTimeouts() {
+    var timeout = this.props.timeout;
+    var exit, enter, appear;
+    exit = enter = appear = timeout;
+
+    if (timeout != null && typeof timeout !== 'number') {
+      exit = timeout.exit;
+      enter = timeout.enter; // TODO: remove fallback for next major
+
+      appear = timeout.appear !== undefined ? timeout.appear : enter;
+    }
+
+    return {
+      exit: exit,
+      enter: enter,
+      appear: appear
+    };
+  };
+
+  _proto.updateStatus = function updateStatus(mounting, nextStatus) {
+    if (mounting === void 0) {
+      mounting = false;
+    }
+
+    if (nextStatus !== null) {
+      // nextStatus will always be ENTERING or EXITING.
+      this.cancelNextCallback();
+
+      if (nextStatus === ENTERING) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749
+          // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.
+          // To make the animation happen,  we have to separate each rendering and avoid being processed as batched.
+
+          if (node) reflow.forceReflow(node);
+        }
+
+        this.performEnter(mounting);
+      } else {
+        this.performExit();
+      }
+    } else if (this.props.unmountOnExit && this.state.status === EXITED) {
+      this.setState({
+        status: UNMOUNTED
+      });
+    }
+  };
+
+  _proto.performEnter = function performEnter(mounting) {
+    var _this2 = this;
+
+    var enter = this.props.enter;
+    var appearing = this.context ? this.context.isMounting : mounting;
+
+    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],
+        maybeNode = _ref2[0],
+        maybeAppearing = _ref2[1];
+
+    var timeouts = this.getTimeouts();
+    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED
+    // if we are mounting and running this it means appear _must_ be set
+
+    if (!mounting && !enter || config.default.disabled) {
+      this.safeSetState({
+        status: ENTERED
+      }, function () {
+        _this2.props.onEntered(maybeNode);
+      });
+      return;
+    }
+
+    this.props.onEnter(maybeNode, maybeAppearing);
+    this.safeSetState({
+      status: ENTERING
+    }, function () {
+      _this2.props.onEntering(maybeNode, maybeAppearing);
+
+      _this2.onTransitionEnd(enterTimeout, function () {
+        _this2.safeSetState({
+          status: ENTERED
+        }, function () {
+          _this2.props.onEntered(maybeNode, maybeAppearing);
+        });
+      });
+    });
+  };
+
+  _proto.performExit = function performExit() {
+    var _this3 = this;
+
+    var exit = this.props.exit;
+    var timeouts = this.getTimeouts();
+    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED
+
+    if (!exit || config.default.disabled) {
+      this.safeSetState({
+        status: EXITED
+      }, function () {
+        _this3.props.onExited(maybeNode);
+      });
+      return;
+    }
+
+    this.props.onExit(maybeNode);
+    this.safeSetState({
+      status: EXITING
+    }, function () {
+      _this3.props.onExiting(maybeNode);
+
+      _this3.onTransitionEnd(timeouts.exit, function () {
+        _this3.safeSetState({
+          status: EXITED
+        }, function () {
+          _this3.props.onExited(maybeNode);
+        });
+      });
+    });
+  };
+
+  _proto.cancelNextCallback = function cancelNextCallback() {
+    if (this.nextCallback !== null) {
+      this.nextCallback.cancel();
+      this.nextCallback = null;
+    }
+  };
+
+  _proto.safeSetState = function safeSetState(nextState, callback) {
+    // This shouldn't be necessary, but there are weird race conditions with
+    // setState callbacks and unmounting in testing, so always make sure that
+    // we can cancel any pending setState callbacks after we unmount.
+    callback = this.setNextCallback(callback);
+    this.setState(nextState, callback);
+  };
+
+  _proto.setNextCallback = function setNextCallback(callback) {
+    var _this4 = this;
+
+    var active = true;
+
+    this.nextCallback = function (event) {
+      if (active) {
+        active = false;
+        _this4.nextCallback = null;
+        callback(event);
+      }
+    };
+
+    this.nextCallback.cancel = function () {
+      active = false;
+    };
+
+    return this.nextCallback;
+  };
+
+  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {
+    this.setNextCallback(handler);
+    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);
+    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;
+
+    if (!node || doesNotHaveTimeoutOrListener) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+
+    if (this.props.addEndListener) {
+      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],
+          maybeNode = _ref3[0],
+          maybeNextCallback = _ref3[1];
+
+      this.props.addEndListener(maybeNode, maybeNextCallback);
+    }
+
+    if (timeout != null) {
+      setTimeout(this.nextCallback, timeout);
+    }
+  };
+
+  _proto.render = function render() {
+    var status = this.state.status;
+
+    if (status === UNMOUNTED) {
+      return null;
+    }
+
+    var _this$props = this.props,
+        children = _this$props.children;
+        _this$props.in;
+        _this$props.mountOnEnter;
+        _this$props.unmountOnExit;
+        _this$props.appear;
+        _this$props.enter;
+        _this$props.exit;
+        _this$props.timeout;
+        _this$props.addEndListener;
+        _this$props.onEnter;
+        _this$props.onEntering;
+        _this$props.onEntered;
+        _this$props.onExit;
+        _this$props.onExiting;
+        _this$props.onExited;
+        _this$props.nodeRef;
+        var childProps = objectWithoutPropertiesLoose.default(_this$props, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+
+    return (
+      /*#__PURE__*/
+      // allows for nested Transitions
+      React.createElement(TransitionGroupContext.default.Provider, {
+        value: null
+      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))
+    );
+  };
+
+  return Transition;
+}(React.Component);
+
+Transition.contextType = TransitionGroupContext.default;
+Transition.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: index.default.shape({
+    current: typeof Element === 'undefined' ? index.default.any : function (propValue, key, componentName, location, propFullName, secret) {
+      var value = propValue[key];
+      return index.default.instanceOf(value && 'ownerDocument' in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);
+    }
+  }),
+
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: index.default.oneOfType([index.default.func.isRequired, index.default.element.isRequired]).isRequired,
+
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: index.default.bool,
+
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: index.default.bool,
+
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: index.default.bool,
+
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: index.default.bool,
+
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: index.default.bool,
+
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: index.default.bool,
+
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function timeout(props) {
+    var pt = PropTypes.timeoutsShape;
+    if (!props.addEndListener) pt = pt.isRequired;
+
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    return pt.apply(void 0, [props].concat(args));
+  },
+
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: index.default.func,
+
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: index.default.func,
+
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: index.default.func,
+
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: index.default.func,
+
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: index.default.func,
+
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: index.default.func,
+
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: index.default.func
+} : {}; // Name the function so it is clearer in the documentation
+
+function noop() {}
+
+Transition.defaultProps = {
+  in: false,
+  mountOnEnter: false,
+  unmountOnExit: false,
+  appear: false,
+  enter: true,
+  exit: true,
+  onEnter: noop,
+  onEntering: noop,
+  onEntered: noop,
+  onExit: noop,
+  onExiting: noop,
+  onExited: noop
+};
+Transition.UNMOUNTED = UNMOUNTED;
+Transition.EXITED = EXITED;
+Transition.ENTERING = ENTERING;
+Transition.ENTERED = ENTERED;
+Transition.EXITING = EXITING;
+
+exports.ENTERED = ENTERED;
+exports.ENTERING = ENTERING;
+exports.EXITED = EXITED;
+exports.EXITING = EXITING;
+exports.UNMOUNTED = UNMOUNTED;
+exports.default = Transition;
+//# sourceMappingURL=Transition.js.map