@appbaseio/reactivesearch-vue 3.0.0-rc.4 → 3.0.0-rc.5.alpha.2

package/dist/es/{install-0c7962bc.js → install-d7f59dee.js}

@@ -1,34 +1,31 @@
 import { helper, Actions, causes } from '@appbaseio/reactivecore';
-import { SEARCH_COMPONENTS_MODES, componentTypes, TREELIST_VALUES_PATH_SEPARATOR } from '@appbaseio/reactivecore/lib/utils/constants';
-import _transformOn from '@vue/babel-helper-vue-transform-on';
-import { _ as _taggedTemplateLiteralLoose, a as _extends } from './_rollupPluginBabelHelpers-ded08042.js';
+import { g as getComponent, h as hasCustomRenderer, S as SEARCH_COMPONENTS_MODES, j as decodeHtml, i as isQueryIdentical, u as updateDefaultQuery, a as componentTypes$1, k as updateCustomQuery, b as isFunction, l as isEmpty, p as parseFocusShortcuts, m as extractModifierKeysFromFocusShortcuts, c as connect, T as TREELIST_VALUES_PATH_SEPARATOR } from './index-b2212b15.js';
+import { _ as _transformOn } from './index-b9203a60.js';
+import { a as _taggedTemplateLiteralLoose, _ as _extends } from './_rollupPluginBabelHelpers-dac426db.js';
 import { createVNode, createTextVNode, defineComponent, isVNode, mergeProps, h } from 'vue';
 import VueTypes from 'vue-types';
-import { getQueryOptions, suggestionTypes, recLookup, getClassName as getClassName$2, updateCustomQuery as updateCustomQuery$1, updateDefaultQuery as updateDefaultQuery$1, transformTreeListLocalStateIntoQueryComptaibleFormat, isEqual as isEqual$1, transformRawTreeListData, setDeep, getComponent as getComponent$1, getOptionsFromQuery, checkValueChange as checkValueChange$1, getAggsQuery, updateInternalQuery, isFunction as isFunction$1 } from '@appbaseio/reactivecore/lib/utils/helper';
+import { g as getQueryOptions, s as suggestionTypes, r as recLookup, a as getClassName$2, u as updateCustomQuery$1, b as updateDefaultQuery$1, c as transformTreeListLocalStateIntoQueryComptaibleFormat, i as isEqual$1, d as transformRawTreeListData, e as setDeep, f as getComponent$1, h as getOptionsFromQuery, j as checkValueChange$1, k as getAggsQuery, l as updateInternalQuery, m as isFunction$1 } from './helper-39773859.js';
 import { styled, createGlobalStyle } from '@appbaseio/vue-emotion';
 import { css } from '@emotion/css';
-import { B as Button } from './Button-fd869491.js';
-import { t as types } from './vueTypes-f1923c72.js';
+import { B as Button } from './Button-a376dd9b.js';
+import { t as types$1 } from './vueTypes-f1923c72.js';
 import { RLConnected as ReactiveList } from './ReactiveList.js';
-import { getInternalComponentID } from '@appbaseio/reactivecore/lib/utils/transform';
-import { g as getComponent, h as hasCustomRenderer, f as decodeHtml, i as isQueryIdentical, u as updateDefaultQuery, j as updateCustomQuery, a as isFunction, k as isEmpty, p as parseFocusShortcuts, l as extractModifierKeysFromFocusShortcuts, c as connect } from './index-882489e1.js';
-import { C as ComponentWrapper } from './ComponentWrapper-8a3c388d.js';
-import { P as PreferencesConsumer } from './PreferencesConsumer-b058d14e.js';
-import { T as Title } from './Title-863dfa42.js';
-import { L as ListItem } from './ListItem-e3c6acf4.js';
-import { F as Flex } from './Flex-25792bc3.js';
+import { g as getInternalComponentID } from './transform-e41c9e5c.js';
+import { C as ComponentWrapper } from './ComponentWrapper-b43a546e.js';
+import { P as PreferencesConsumer } from './PreferencesConsumer-9a3b0bac.js';
+import { T as Title } from './Title-4b7614be.js';
+import { L as ListItem } from './ListItem-a25ed63a.js';
+import { F as Flex } from './Flex-651f2422.js';
 import ReactiveBase from './ReactiveBase.js';
 import hotkeys from 'hotkeys-js';
-import { I as IconWrapper, C as CancelSvg, a as IconGroup, D as Downshift, b as InputWrapper } from './DropDown-fc1fef02.js';
-import { n as noSuggestions, s as suggestionsContainer, I as Input, a as suggestions } from './Input-f7499ef8.js';
-import { C as Container } from './Container-d00219f7.js';
+import { I as IconWrapper, C as CancelSvg, a as IconGroup, D as Downshift, b as InputWrapper } from './DropDown-59c3fbc7.js';
+import { n as noSuggestions, s as suggestionsContainer, I as Input, a as suggestions } from './Input-3126d7b6.js';
+import { C as Container } from './Container-6c21a1e6.js';
 import Highlight from 'vue-highlight-words';
-import { replaceDiacritics } from '@appbaseio/reactivecore/lib/utils/suggestions';
-import { C as Checkbox, R as Radio } from './FormControlList-fe6eaee4.js';
-import { s as sanitizeObject } from './utils-d7dd4f4e.js';
+import { s as sanitizeObject, r as replaceDiacritics } from './utils-782d91c4.js';
+import { C as Checkbox, R as Radio } from './FormControlList-be0456b0.js';
 import { ListConnected as SingleList } from './SingleList.js';
 import { ListConnected as MultiList } from './MultiList.js';
-import types$1 from '@appbaseio/reactivecore/lib/utils/types';
 import { ListConnected as SingleDropdownList } from './SingleDropdownList.js';
 import { ListConnected as MultiDropdownList } from './MultiDropdownList.js';
 import { TBConnected as ToggleButton } from './ToggleButton.js';
@@ -59,9 +56,9 @@ var getClassName = helper.getClassName;
 var SuggestionWrapper = {
   name: 'SuggestionWrapper',
   props: {
-    innerClassName: types.string,
-    themePreset: types.themePreset,
-    innerClass: types.style
+    innerClassName: types$1.string,
+    themePreset: types$1.themePreset,
+    innerClass: types$1.style
   },
   render: function render() {
     var _this$$props = this.$props,
@@ -85,8 +82,8 @@ var PredictiveSuggestion = styled('span')(_templateObject$2 || (_templateObject$
 var SuggestionItem = {
   name: 'SuggestionItem',
   props: {
-    currentValue: types.string,
-    suggestion: types.any
+    currentValue: types$1.string,
+    suggestion: types$1.any
   },
   render: function render() {
     var _this = this;
@@ -488,15 +485,15 @@ var STATUS = {
 var Mic = {
   name: 'Mic',
   props: {
-    children: types.title,
+    children: types$1.title,
     lang: VueTypes.string.def('en-US'),
     iconPosition: VueTypes.string.def('left'),
-    handleResult: types.func,
-    onNoMatch: types.func,
-    onError: types.func,
-    getInstance: types.func,
-    render: types.func,
-    className: types.string,
+    handleResult: types$1.func,
+    onNoMatch: types$1.func,
+    onError: types$1.func,
+    getInstance: types$1.func,
+    render: types$1.func,
+    className: types$1.string,
     applyClearStyle: VueTypes.bool,
     showIcon: VueTypes.bool
   },
@@ -821,13 +818,13 @@ var SearchBox = defineComponent({
   props: {
     autoFocus: VueTypes.bool,
     autosuggest: VueTypes.bool.def(true),
-    beforeValueChange: types.func,
+    beforeValueChange: types$1.func,
     className: VueTypes.string.def(''),
-    clearIcon: types.children,
-    componentId: types.stringRequired,
-    customHighlight: types.func,
-    customQuery: types.func,
-    defaultQuery: types.func,
+    clearIcon: types$1.children,
+    componentId: types$1.stringRequired,
+    customHighlight: types$1.func,
+    customQuery: types$1.func,
+    defaultQuery: types$1.func,
     dataField: VueTypes.oneOfType([VueTypes.string, VueTypes.shape({
       field: VueTypes.string,
       weight: VueTypes.number
@@ -835,51 +832,51 @@ var SearchBox = defineComponent({
       field: VueTypes.string,
       weight: VueTypes.number
     })]),
-    aggregationField: types.string,
+    aggregationField: types$1.string,
     aggregationSize: VueTypes.number,
     size: VueTypes.number,
     debounce: VueTypes.number.def(0),
-    defaultValue: types.string,
-    excludeFields: types.excludeFields,
-    value: VueTypes.oneOfType([VueTypes.arrayOf(VueTypes.string), types.value]),
-    defaultSuggestions: types.suggestions,
+    defaultValue: types$1.string,
+    excludeFields: types$1.excludeFields,
+    value: VueTypes.oneOfType([VueTypes.arrayOf(VueTypes.string), types$1.value]),
+    defaultSuggestions: types$1.suggestions,
     enableSynonyms: VueTypes.bool.def(true),
     enableQuerySuggestions: VueTypes.bool.def(false),
     enablePopularSuggestions: VueTypes.bool.def(false),
     enableRecentSuggestions: VueTypes.bool.def(false),
-    fieldWeights: types.fieldWeights,
-    filterLabel: types.string,
-    fuzziness: types.fuzziness,
+    fieldWeights: types$1.fieldWeights,
+    filterLabel: types$1.string,
+    fuzziness: types$1.fuzziness,
     highlight: VueTypes.bool,
-    highlightField: types.stringOrArray,
-    icon: types.children,
+    highlightField: types$1.stringOrArray,
+    icon: types$1.children,
     iconPosition: VueTypes.oneOf(['left', 'right']).def('left'),
-    includeFields: types.includeFields,
-    innerClass: types.style,
+    includeFields: types$1.includeFields,
+    innerClass: types$1.style,
     innerRef: VueTypes.string.def('searchInputField'),
-    render: types.func,
-    renderNoSuggestion: types.title,
-    renderError: types.title,
+    render: types$1.func,
+    renderNoSuggestion: types$1.title,
+    renderError: types$1.title,
     placeholder: VueTypes.string.def('Search'),
     queryFormat: VueTypes.oneOf(['and', 'or']).def('or'),
-    react: types.react,
+    react: types$1.react,
     showClear: VueTypes.bool.def(true),
     showDistinctSuggestions: VueTypes.bool.def(true),
     showFilter: VueTypes.bool.def(true),
     showIcon: VueTypes.bool.def(true),
-    title: types.title,
+    title: types$1.title,
     URLParams: VueTypes.bool.def(false),
     strictSelection: VueTypes.bool.def(false),
-    nestedField: types.string,
+    nestedField: types$1.string,
     enablePredictiveSuggestions: VueTypes.bool.def(false),
     recentSearchesIcon: VueTypes.any,
     popularSearchesIcon: VueTypes.any,
     //	mic props
     showVoiceSearch: VueTypes.bool.def(false),
-    getMicInstance: types.func,
-    renderMic: types.func,
-    distinctField: types.string,
-    distinctFieldConfig: types.props,
+    getMicInstance: types$1.func,
+    renderMic: types$1.func,
+    distinctField: types$1.string,
+    distinctFieldConfig: types$1.props,
     //
     focusShortcuts: VueTypes.arrayOf(VueTypes.oneOfType([VueTypes.string, VueTypes.number])).def(['/']),
     addonBefore: VueTypes.any,
@@ -889,15 +886,15 @@ var SearchBox = defineComponent({
     popularSuggestionsConfig: VueTypes.object,
     recentSuggestionsConfig: VueTypes.object,
     applyStopwords: VueTypes.bool,
-    customStopwords: types.stringArray,
-    onData: types.func,
-    renderItem: types.func,
+    customStopwords: types$1.stringArray,
+    onData: types$1.func,
+    renderItem: types$1.func,
     enterButton: VueTypes.bool.def(false),
     renderEnterButton: VueTypes.any,
     mode: VueTypes.oneOf(['select', 'tag']).def('select'),
     renderSelectedTags: VueTypes.any,
     searchboxId: VueTypes.string,
-    endpoint: types.endpointConfig
+    endpoint: types$1.endpointConfig
   },
   mounted: function mounted() {
     this.listenForFocusShortcuts();
@@ -1139,7 +1136,7 @@ var SearchBox = defineComponent({
         componentId: this.internalComponent,
         query: query,
         value: value,
-        componentType: componentTypes.searchBox
+        componentType: componentTypes$1.searchBox
       });
     },
     triggerCustomQuery: function triggerCustomQuery(paramValue, categoryValue) {
@@ -1172,7 +1169,7 @@ var SearchBox = defineComponent({
         label: filterLabel,
         showFilter: showFilter,
         URLParams: URLParams,
-        componentType: componentTypes.searchBox,
+        componentType: componentTypes$1.searchBox,
         category: categoryValue
       });
     },
@@ -1849,7 +1846,7 @@ var mapDispatchToProps = {
   recordSuggestionClick: recordSuggestionClick
 };
 var SBConnected = PreferencesConsumer(ComponentWrapper(connect(mapStateToProps, mapDispatchToProps)(SearchBox), {
-  componentType: componentTypes.searchBox,
+  componentType: componentTypes$1.searchBox,
   internalComponent: true
 }));
 SBConnected.name = SearchBox.name;
@@ -1860,7 +1857,1326 @@ SBConnected.install = function (Vue) {
   Vue.component(SBConnected.name, SBConnected);
 };
 // Add componentType for SSR
-SBConnected.componentType = componentTypes.searchBox;
+SBConnected.componentType = componentTypes$1.searchBox;
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+var propTypes = {
+  exports: {}
+};
+var reactIs = {
+  exports: {}
+};
+var reactIs_production_min = {};
+var hasRequiredReactIs_production_min;
+function requireReactIs_production_min() {
+  if (hasRequiredReactIs_production_min) return reactIs_production_min;
+  hasRequiredReactIs_production_min = 1;
+  var b = "function" === typeof Symbol && Symbol["for"],
+    c = b ? Symbol["for"]("react.element") : 60103,
+    d = b ? Symbol["for"]("react.portal") : 60106,
+    e = b ? Symbol["for"]("react.fragment") : 60107,
+    f = b ? Symbol["for"]("react.strict_mode") : 60108,
+    g = b ? Symbol["for"]("react.profiler") : 60114,
+    h = b ? Symbol["for"]("react.provider") : 60109,
+    k = b ? Symbol["for"]("react.context") : 60110,
+    l = b ? Symbol["for"]("react.async_mode") : 60111,
+    m = b ? Symbol["for"]("react.concurrent_mode") : 60111,
+    n = b ? Symbol["for"]("react.forward_ref") : 60112,
+    p = b ? Symbol["for"]("react.suspense") : 60113,
+    q = b ? Symbol["for"]("react.suspense_list") : 60120,
+    r = b ? Symbol["for"]("react.memo") : 60115,
+    t = b ? Symbol["for"]("react.lazy") : 60116,
+    v = b ? Symbol["for"]("react.block") : 60121,
+    w = b ? Symbol["for"]("react.fundamental") : 60117,
+    x = b ? Symbol["for"]("react.responder") : 60118,
+    y = b ? Symbol["for"]("react.scope") : 60119;
+  function z(a) {
+    if ("object" === _typeof(a) && null !== a) {
+      var u = a.$$typeof;
+      switch (u) {
+        case c:
+          switch (a = a.type, a) {
+            case l:
+            case m:
+            case e:
+            case g:
+            case f:
+            case p:
+              return a;
+            default:
+              switch (a = a && a.$$typeof, a) {
+                case k:
+                case n:
+                case t:
+                case r:
+                case h:
+                  return a;
+                default:
+                  return u;
+              }
+          }
+        case d:
+          return u;
+      }
+    }
+  }
+  function A(a) {
+    return z(a) === m;
+  }
+  reactIs_production_min.AsyncMode = l;
+  reactIs_production_min.ConcurrentMode = m;
+  reactIs_production_min.ContextConsumer = k;
+  reactIs_production_min.ContextProvider = h;
+  reactIs_production_min.Element = c;
+  reactIs_production_min.ForwardRef = n;
+  reactIs_production_min.Fragment = e;
+  reactIs_production_min.Lazy = t;
+  reactIs_production_min.Memo = r;
+  reactIs_production_min.Portal = d;
+  reactIs_production_min.Profiler = g;
+  reactIs_production_min.StrictMode = f;
+  reactIs_production_min.Suspense = p;
+  reactIs_production_min.isAsyncMode = function (a) {
+    return A(a) || z(a) === l;
+  };
+  reactIs_production_min.isConcurrentMode = A;
+  reactIs_production_min.isContextConsumer = function (a) {
+    return z(a) === k;
+  };
+  reactIs_production_min.isContextProvider = function (a) {
+    return z(a) === h;
+  };
+  reactIs_production_min.isElement = function (a) {
+    return "object" === _typeof(a) && null !== a && a.$$typeof === c;
+  };
+  reactIs_production_min.isForwardRef = function (a) {
+    return z(a) === n;
+  };
+  reactIs_production_min.isFragment = function (a) {
+    return z(a) === e;
+  };
+  reactIs_production_min.isLazy = function (a) {
+    return z(a) === t;
+  };
+  reactIs_production_min.isMemo = function (a) {
+    return z(a) === r;
+  };
+  reactIs_production_min.isPortal = function (a) {
+    return z(a) === d;
+  };
+  reactIs_production_min.isProfiler = function (a) {
+    return z(a) === g;
+  };
+  reactIs_production_min.isStrictMode = function (a) {
+    return z(a) === f;
+  };
+  reactIs_production_min.isSuspense = function (a) {
+    return z(a) === p;
+  };
+  reactIs_production_min.isValidElementType = function (a) {
+    return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === _typeof(a) && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+  };
+  reactIs_production_min.typeOf = z;
+  return reactIs_production_min;
+}
+var reactIs_development = {};
+var hasRequiredReactIs_development;
+function requireReactIs_development() {
+  if (hasRequiredReactIs_development) return reactIs_development;
+  hasRequiredReactIs_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function () {
+      // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+      // nor polyfill, then a plain number is used for performance.
+      var hasSymbol = typeof Symbol === 'function' && Symbol["for"];
+      var REACT_ELEMENT_TYPE = hasSymbol ? Symbol["for"]('react.element') : 0xeac7;
+      var REACT_PORTAL_TYPE = hasSymbol ? Symbol["for"]('react.portal') : 0xeaca;
+      var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol["for"]('react.fragment') : 0xeacb;
+      var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol["for"]('react.strict_mode') : 0xeacc;
+      var REACT_PROFILER_TYPE = hasSymbol ? Symbol["for"]('react.profiler') : 0xead2;
+      var REACT_PROVIDER_TYPE = hasSymbol ? Symbol["for"]('react.provider') : 0xeacd;
+      var REACT_CONTEXT_TYPE = hasSymbol ? Symbol["for"]('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+      // (unstable) APIs that have been removed. Can we remove the symbols?
+
+      var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol["for"]('react.async_mode') : 0xeacf;
+      var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol["for"]('react.concurrent_mode') : 0xeacf;
+      var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol["for"]('react.forward_ref') : 0xead0;
+      var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol["for"]('react.suspense') : 0xead1;
+      var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol["for"]('react.suspense_list') : 0xead8;
+      var REACT_MEMO_TYPE = hasSymbol ? Symbol["for"]('react.memo') : 0xead3;
+      var REACT_LAZY_TYPE = hasSymbol ? Symbol["for"]('react.lazy') : 0xead4;
+      var REACT_BLOCK_TYPE = hasSymbol ? Symbol["for"]('react.block') : 0xead9;
+      var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol["for"]('react.fundamental') : 0xead5;
+      var REACT_RESPONDER_TYPE = hasSymbol ? Symbol["for"]('react.responder') : 0xead6;
+      var REACT_SCOPE_TYPE = hasSymbol ? Symbol["for"]('react.scope') : 0xead7;
+      function isValidElementType(type) {
+        return typeof type === 'string' || typeof type === 'function' ||
+        // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+        type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || _typeof(type) === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+      }
+      function typeOf(object) {
+        if (_typeof(object) === 'object' && object !== null) {
+          var $$typeof = object.$$typeof;
+          switch ($$typeof) {
+            case REACT_ELEMENT_TYPE:
+              var type = object.type;
+              switch (type) {
+                case REACT_ASYNC_MODE_TYPE:
+                case REACT_CONCURRENT_MODE_TYPE:
+                case REACT_FRAGMENT_TYPE:
+                case REACT_PROFILER_TYPE:
+                case REACT_STRICT_MODE_TYPE:
+                case REACT_SUSPENSE_TYPE:
+                  return type;
+                default:
+                  var $$typeofType = type && type.$$typeof;
+                  switch ($$typeofType) {
+                    case REACT_CONTEXT_TYPE:
+                    case REACT_FORWARD_REF_TYPE:
+                    case REACT_LAZY_TYPE:
+                    case REACT_MEMO_TYPE:
+                    case REACT_PROVIDER_TYPE:
+                      return $$typeofType;
+                    default:
+                      return $$typeof;
+                  }
+              }
+            case REACT_PORTAL_TYPE:
+              return $$typeof;
+          }
+        }
+        return undefined;
+      } // AsyncMode is deprecated along with isAsyncMode
+
+      var AsyncMode = REACT_ASYNC_MODE_TYPE;
+      var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+      var ContextConsumer = REACT_CONTEXT_TYPE;
+      var ContextProvider = REACT_PROVIDER_TYPE;
+      var Element = REACT_ELEMENT_TYPE;
+      var ForwardRef = REACT_FORWARD_REF_TYPE;
+      var Fragment = REACT_FRAGMENT_TYPE;
+      var Lazy = REACT_LAZY_TYPE;
+      var Memo = REACT_MEMO_TYPE;
+      var Portal = REACT_PORTAL_TYPE;
+      var Profiler = REACT_PROFILER_TYPE;
+      var StrictMode = REACT_STRICT_MODE_TYPE;
+      var Suspense = REACT_SUSPENSE_TYPE;
+      var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+      function isAsyncMode(object) {
+        {
+          if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+            hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+            console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+          }
+        }
+        return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+      }
+      function isConcurrentMode(object) {
+        return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+      }
+      function isContextConsumer(object) {
+        return typeOf(object) === REACT_CONTEXT_TYPE;
+      }
+      function isContextProvider(object) {
+        return typeOf(object) === REACT_PROVIDER_TYPE;
+      }
+      function isElement(object) {
+        return _typeof(object) === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      function isForwardRef(object) {
+        return typeOf(object) === REACT_FORWARD_REF_TYPE;
+      }
+      function isFragment(object) {
+        return typeOf(object) === REACT_FRAGMENT_TYPE;
+      }
+      function isLazy(object) {
+        return typeOf(object) === REACT_LAZY_TYPE;
+      }
+      function isMemo(object) {
+        return typeOf(object) === REACT_MEMO_TYPE;
+      }
+      function isPortal(object) {
+        return typeOf(object) === REACT_PORTAL_TYPE;
+      }
+      function isProfiler(object) {
+        return typeOf(object) === REACT_PROFILER_TYPE;
+      }
+      function isStrictMode(object) {
+        return typeOf(object) === REACT_STRICT_MODE_TYPE;
+      }
+      function isSuspense(object) {
+        return typeOf(object) === REACT_SUSPENSE_TYPE;
+      }
+      reactIs_development.AsyncMode = AsyncMode;
+      reactIs_development.ConcurrentMode = ConcurrentMode;
+      reactIs_development.ContextConsumer = ContextConsumer;
+      reactIs_development.ContextProvider = ContextProvider;
+      reactIs_development.Element = Element;
+      reactIs_development.ForwardRef = ForwardRef;
+      reactIs_development.Fragment = Fragment;
+      reactIs_development.Lazy = Lazy;
+      reactIs_development.Memo = Memo;
+      reactIs_development.Portal = Portal;
+      reactIs_development.Profiler = Profiler;
+      reactIs_development.StrictMode = StrictMode;
+      reactIs_development.Suspense = Suspense;
+      reactIs_development.isAsyncMode = isAsyncMode;
+      reactIs_development.isConcurrentMode = isConcurrentMode;
+      reactIs_development.isContextConsumer = isContextConsumer;
+      reactIs_development.isContextProvider = isContextProvider;
+      reactIs_development.isElement = isElement;
+      reactIs_development.isForwardRef = isForwardRef;
+      reactIs_development.isFragment = isFragment;
+      reactIs_development.isLazy = isLazy;
+      reactIs_development.isMemo = isMemo;
+      reactIs_development.isPortal = isPortal;
+      reactIs_development.isProfiler = isProfiler;
+      reactIs_development.isStrictMode = isStrictMode;
+      reactIs_development.isSuspense = isSuspense;
+      reactIs_development.isValidElementType = isValidElementType;
+      reactIs_development.typeOf = typeOf;
+    })();
+  }
+  return reactIs_development;
+}
+var hasRequiredReactIs;
+function requireReactIs() {
+  if (hasRequiredReactIs) return reactIs.exports;
+  hasRequiredReactIs = 1;
+  if (process.env.NODE_ENV === 'production') {
+    reactIs.exports = requireReactIs_production_min();
+  } else {
+    reactIs.exports = requireReactIs_development();
+  }
+  return reactIs.exports;
+}
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var objectAssign;
+var hasRequiredObjectAssign;
+function requireObjectAssign() {
+  if (hasRequiredObjectAssign) return objectAssign;
+  hasRequiredObjectAssign = 1;
+  /* eslint-disable no-unused-vars */
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+  function toObject(val) {
+    if (val === null || val === undefined) {
+      throw new TypeError('Object.assign cannot be called with null or undefined');
+    }
+    return Object(val);
+  }
+  function shouldUseNative() {
+    try {
+      if (!Object.assign) {
+        return false;
+      }
+
+      // Detect buggy property enumeration order in older V8 versions.
+
+      // https://bugs.chromium.org/p/v8/issues/detail?id=4118
+      var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
+      test1[5] = 'de';
+      if (Object.getOwnPropertyNames(test1)[0] === '5') {
+        return false;
+      }
+
+      // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+      var test2 = {};
+      for (var i = 0; i < 10; i++) {
+        test2['_' + String.fromCharCode(i)] = i;
+      }
+      var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+        return test2[n];
+      });
+      if (order2.join('') !== '0123456789') {
+        return false;
+      }
+
+      // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+      var test3 = {};
+      'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+        test3[letter] = letter;
+      });
+      if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') {
+        return false;
+      }
+      return true;
+    } catch (err) {
+      // We don't expect any of the above to throw, but better to be safe.
+      return false;
+    }
+  }
+  objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+    var from;
+    var to = toObject(target);
+    var symbols;
+    for (var s = 1; s < arguments.length; s++) {
+      from = Object(arguments[s]);
+      for (var key in from) {
+        if (hasOwnProperty.call(from, key)) {
+          to[key] = from[key];
+        }
+      }
+      if (getOwnPropertySymbols) {
+        symbols = getOwnPropertySymbols(from);
+        for (var i = 0; i < symbols.length; i++) {
+          if (propIsEnumerable.call(from, symbols[i])) {
+            to[symbols[i]] = from[symbols[i]];
+          }
+        }
+      }
+    }
+    return to;
+  };
+  return objectAssign;
+}
+
+/**
+ * Copyright (c) 2013-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 ReactPropTypesSecret_1;
+var hasRequiredReactPropTypesSecret;
+function requireReactPropTypesSecret() {
+  if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
+  hasRequiredReactPropTypesSecret = 1;
+  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+  ReactPropTypesSecret_1 = ReactPropTypesSecret;
+  return ReactPropTypesSecret_1;
+}
+var has;
+var hasRequiredHas;
+function requireHas() {
+  if (hasRequiredHas) return has;
+  hasRequiredHas = 1;
+  has = Function.call.bind(Object.prototype.hasOwnProperty);
+  return has;
+}
+var checkPropTypes_1;
+var hasRequiredCheckPropTypes;
+function requireCheckPropTypes() {
+  if (hasRequiredCheckPropTypes) return checkPropTypes_1;
+  hasRequiredCheckPropTypes = 1;
+  var printWarning = function printWarning() {};
+  if (process.env.NODE_ENV !== 'production') {
+    var ReactPropTypesSecret = requireReactPropTypesSecret();
+    var loggedTypeFailures = {};
+    var has = requireHas();
+    printWarning = function printWarning(text) {
+      var message = 'Warning: ' + text;
+      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) {/**/}
+    };
+  }
+
+  /**
+   * Assert that the values match with the type specs.
+   * Error messages are memorized and will only be shown once.
+   *
+   * @param {object} typeSpecs Map of name to a ReactPropType
+   * @param {object} values Runtime values that need to be type-checked
+   * @param {string} location e.g. "prop", "context", "child context"
+   * @param {string} componentName Name of the component for error messages.
+   * @param {?Function} getStack Returns the component stack.
+   * @private
+   */
+  function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+    if (process.env.NODE_ENV !== 'production') {
+      for (var typeSpecName in typeSpecs) {
+        if (has(typeSpecs, typeSpecName)) {
+          var error;
+          // Prop type validation may throw. In case they do, we don't want to
+          // fail the render phase where it didn't fail before. So we log it.
+          // After these have been cleaned up, we'll let them throw.
+          try {
+            // This is intentionally an invariant that gets caught. It's the same
+            // behavior as without this statement except with a better message.
+            if (typeof typeSpecs[typeSpecName] !== 'function') {
+              var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + _typeof(typeSpecs[typeSpecName]) + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
+              err.name = 'Invariant Violation';
+              throw err;
+            }
+            error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+          } catch (ex) {
+            error = ex;
+          }
+          if (error && !(error instanceof Error)) {
+            printWarning((componentName || 'React class') + ': type specification of ' + location + ' `' + typeSpecName + '` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a ' + _typeof(error) + '. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).');
+          }
+          if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+            // Only monitor this failure once because there tends to be a lot of the
+            // same error.
+            loggedTypeFailures[error.message] = true;
+            var stack = getStack ? getStack() : '';
+            printWarning('Failed ' + location + ' type: ' + error.message + (stack != null ? stack : ''));
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Resets warning cache when testing.
+   *
+   * @private
+   */
+  checkPropTypes.resetWarningCache = function () {
+    if (process.env.NODE_ENV !== 'production') {
+      loggedTypeFailures = {};
+    }
+  };
+  checkPropTypes_1 = checkPropTypes;
+  return checkPropTypes_1;
+}
+var factoryWithTypeCheckers;
+var hasRequiredFactoryWithTypeCheckers;
+function requireFactoryWithTypeCheckers() {
+  if (hasRequiredFactoryWithTypeCheckers) return factoryWithTypeCheckers;
+  hasRequiredFactoryWithTypeCheckers = 1;
+  var ReactIs = requireReactIs();
+  var assign = requireObjectAssign();
+  var ReactPropTypesSecret = requireReactPropTypesSecret();
+  var has = requireHas();
+  var checkPropTypes = requireCheckPropTypes();
+  var printWarning = function printWarning() {};
+  if (process.env.NODE_ENV !== 'production') {
+    printWarning = function printWarning(text) {
+      var message = 'Warning: ' + text;
+      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) {}
+    };
+  }
+  function emptyFunctionThatReturnsNull() {
+    return null;
+  }
+  factoryWithTypeCheckers = function factoryWithTypeCheckers(isValidElement, throwOnDirectAccess) {
+    /* global Symbol */
+    var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+    var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+    /**
+     * Returns the iterator method function contained on the iterable object.
+     *
+     * Be sure to invoke the function with the iterable as context:
+     *
+     *     var iteratorFn = getIteratorFn(myIterable);
+     *     if (iteratorFn) {
+     *       var iterator = iteratorFn.call(myIterable);
+     *       ...
+     *     }
+     *
+     * @param {?object} maybeIterable
+     * @return {?function}
+     */
+    function getIteratorFn(maybeIterable) {
+      var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+      if (typeof iteratorFn === 'function') {
+        return iteratorFn;
+      }
+    }
+
+    /**
+     * Collection of methods that allow declaration and validation of props that are
+     * supplied to React components. Example usage:
+     *
+     *   var Props = require('ReactPropTypes');
+     *   var MyArticle = React.createClass({
+     *     propTypes: {
+     *       // An optional string prop named "description".
+     *       description: Props.string,
+     *
+     *       // A required enum prop named "category".
+     *       category: Props.oneOf(['News','Photos']).isRequired,
+     *
+     *       // A prop named "dialog" that requires an instance of Dialog.
+     *       dialog: Props.instanceOf(Dialog).isRequired
+     *     },
+     *     render: function() { ... }
+     *   });
+     *
+     * A more formal specification of how these methods are used:
+     *
+     *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
+     *   decl := ReactPropTypes.{type}(.isRequired)?
+     *
+     * Each and every declaration produces a function with the same signature. This
+     * allows the creation of custom validation functions. For example:
+     *
+     *  var MyLink = React.createClass({
+     *    propTypes: {
+     *      // An optional string or URI prop named "href".
+     *      href: function(props, propName, componentName) {
+     *        var propValue = props[propName];
+     *        if (propValue != null && typeof propValue !== 'string' &&
+     *            !(propValue instanceof URI)) {
+     *          return new Error(
+     *            'Expected a string or an URI for ' + propName + ' in ' +
+     *            componentName
+     *          );
+     *        }
+     *      }
+     *    },
+     *    render: function() {...}
+     *  });
+     *
+     * @internal
+     */
+
+    var ANONYMOUS = '<<anonymous>>';
+
+    // Important!
+    // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
+    var ReactPropTypes = {
+      array: createPrimitiveTypeChecker('array'),
+      bigint: createPrimitiveTypeChecker('bigint'),
+      bool: createPrimitiveTypeChecker('boolean'),
+      func: createPrimitiveTypeChecker('function'),
+      number: createPrimitiveTypeChecker('number'),
+      object: createPrimitiveTypeChecker('object'),
+      string: createPrimitiveTypeChecker('string'),
+      symbol: createPrimitiveTypeChecker('symbol'),
+      any: createAnyTypeChecker(),
+      arrayOf: createArrayOfTypeChecker,
+      element: createElementTypeChecker(),
+      elementType: createElementTypeTypeChecker(),
+      instanceOf: createInstanceTypeChecker,
+      node: createNodeChecker(),
+      objectOf: createObjectOfTypeChecker,
+      oneOf: createEnumTypeChecker,
+      oneOfType: createUnionTypeChecker,
+      shape: createShapeTypeChecker,
+      exact: createStrictShapeTypeChecker
+    };
+
+    /**
+     * inlined Object.is polyfill to avoid requiring consumers ship their own
+     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+     */
+    /*eslint-disable no-self-compare*/
+    function is(x, y) {
+      // SameValue algorithm
+      if (x === y) {
+        // Steps 1-5, 7-10
+        // Steps 6.b-6.e: +0 != -0
+        return x !== 0 || 1 / x === 1 / y;
+      } else {
+        // Step 6.a: NaN == NaN
+        return x !== x && y !== y;
+      }
+    }
+    /*eslint-enable no-self-compare*/
+
+    /**
+     * We use an Error-like object for backward compatibility as people may call
+     * PropTypes directly and inspect their output. However, we don't use real
+     * Errors anymore. We don't inspect their stack anyway, and creating them
+     * is prohibitively expensive if they are created too often, such as what
+     * happens in oneOfType() for any type before the one that matched.
+     */
+    function PropTypeError(message, data) {
+      this.message = message;
+      this.data = data && _typeof(data) === 'object' ? data : {};
+      this.stack = '';
+    }
+    // Make `instanceof Error` still work for returned errors.
+    PropTypeError.prototype = Error.prototype;
+    function createChainableTypeChecker(validate) {
+      if (process.env.NODE_ENV !== 'production') {
+        var manualPropTypeCallCache = {};
+        var manualPropTypeWarningCount = 0;
+      }
+      function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+        componentName = componentName || ANONYMOUS;
+        propFullName = propFullName || propName;
+        if (secret !== ReactPropTypesSecret) {
+          if (throwOnDirectAccess) {
+            // New behavior only for users of `prop-types` package
+            var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use `PropTypes.checkPropTypes()` to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
+            err.name = 'Invariant Violation';
+            throw err;
+          } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
+            // Old behavior for people using React.PropTypes
+            var cacheKey = componentName + ':' + propName;
+            if (!manualPropTypeCallCache[cacheKey] &&
+            // Avoid spamming the console because they are often not actionable except for lib authors
+            manualPropTypeWarningCount < 3) {
+              printWarning('You are manually calling a React.PropTypes validation ' + 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' + 'and will throw in the standalone `prop-types` package. ' + 'You may be seeing this warning due to a third-party PropTypes ' + 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.');
+              manualPropTypeCallCache[cacheKey] = true;
+              manualPropTypeWarningCount++;
+            }
+          }
+        }
+        if (props[propName] == null) {
+          if (isRequired) {
+            if (props[propName] === null) {
+              return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+            }
+            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+          }
+          return null;
+        } else {
+          return validate(props, propName, componentName, location, propFullName);
+        }
+      }
+      var chainedCheckType = checkType.bind(null, false);
+      chainedCheckType.isRequired = checkType.bind(null, true);
+      return chainedCheckType;
+    }
+    function createPrimitiveTypeChecker(expectedType) {
+      function validate(props, propName, componentName, location, propFullName, secret) {
+        var propValue = props[propName];
+        var propType = getPropType(propValue);
+        if (propType !== expectedType) {
+          // `propValue` being instance of, say, date/regexp, pass the 'object'
+          // check, but we can offer a more precise error message here rather than
+          // 'of type `object`'.
+          var preciseType = getPreciseType(propValue);
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'), {
+            expectedType: expectedType
+          });
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createAnyTypeChecker() {
+      return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+    }
+    function createArrayOfTypeChecker(typeChecker) {
+      function validate(props, propName, componentName, location, propFullName) {
+        if (typeof typeChecker !== 'function') {
+          return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+        }
+        var propValue = props[propName];
+        if (!Array.isArray(propValue)) {
+          var propType = getPropType(propValue);
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+        }
+        for (var i = 0; i < propValue.length; i++) {
+          var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+          if (error instanceof Error) {
+            return error;
+          }
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createElementTypeChecker() {
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName];
+        if (!isValidElement(propValue)) {
+          var propType = getPropType(propValue);
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createElementTypeTypeChecker() {
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName];
+        if (!ReactIs.isValidElementType(propValue)) {
+          var propType = getPropType(propValue);
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createInstanceTypeChecker(expectedClass) {
+      function validate(props, propName, componentName, location, propFullName) {
+        if (!(props[propName] instanceof expectedClass)) {
+          var expectedClassName = expectedClass.name || ANONYMOUS;
+          var actualClassName = getClassName(props[propName]);
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createEnumTypeChecker(expectedValues) {
+      if (!Array.isArray(expectedValues)) {
+        if (process.env.NODE_ENV !== 'production') {
+          if (arguments.length > 1) {
+            printWarning('Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).');
+          } else {
+            printWarning('Invalid argument supplied to oneOf, expected an array.');
+          }
+        }
+        return emptyFunctionThatReturnsNull;
+      }
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName];
+        for (var i = 0; i < expectedValues.length; i++) {
+          if (is(propValue, expectedValues[i])) {
+            return null;
+          }
+        }
+        var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+          var type = getPreciseType(value);
+          if (type === 'symbol') {
+            return String(value);
+          }
+          return value;
+        });
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createObjectOfTypeChecker(typeChecker) {
+      function validate(props, propName, componentName, location, propFullName) {
+        if (typeof typeChecker !== 'function') {
+          return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+        }
+        var propValue = props[propName];
+        var propType = getPropType(propValue);
+        if (propType !== 'object') {
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+        }
+        for (var key in propValue) {
+          if (has(propValue, key)) {
+            var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+            if (error instanceof Error) {
+              return error;
+            }
+          }
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createUnionTypeChecker(arrayOfTypeCheckers) {
+      if (!Array.isArray(arrayOfTypeCheckers)) {
+        process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
+        return emptyFunctionThatReturnsNull;
+      }
+      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+        var checker = arrayOfTypeCheckers[i];
+        if (typeof checker !== 'function') {
+          printWarning('Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.');
+          return emptyFunctionThatReturnsNull;
+        }
+      }
+      function validate(props, propName, componentName, location, propFullName) {
+        var expectedTypes = [];
+        for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+          var checker = arrayOfTypeCheckers[i];
+          var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+          if (checkerResult == null) {
+            return null;
+          }
+          if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
+            expectedTypes.push(checkerResult.data.expectedType);
+          }
+        }
+        var expectedTypesMessage = expectedTypes.length > 0 ? ', expected one of type [' + expectedTypes.join(', ') + ']' : '';
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createNodeChecker() {
+      function validate(props, propName, componentName, location, propFullName) {
+        if (!isNode(props[propName])) {
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function invalidValidatorError(componentName, location, propFullName, key, type) {
+      return new PropTypeError((componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + type + '`.');
+    }
+    function createShapeTypeChecker(shapeTypes) {
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName];
+        var propType = getPropType(propValue);
+        if (propType !== 'object') {
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+        }
+        for (var key in shapeTypes) {
+          var checker = shapeTypes[key];
+          if (typeof checker !== 'function') {
+            return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+          }
+          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+          if (error) {
+            return error;
+          }
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function createStrictShapeTypeChecker(shapeTypes) {
+      function validate(props, propName, componentName, location, propFullName) {
+        var propValue = props[propName];
+        var propType = getPropType(propValue);
+        if (propType !== 'object') {
+          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+        }
+        // We need to check all keys in case some are required but missing from props.
+        var allKeys = assign({}, props[propName], shapeTypes);
+        for (var key in allKeys) {
+          var checker = shapeTypes[key];
+          if (has(shapeTypes, key) && typeof checker !== 'function') {
+            return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+          }
+          if (!checker) {
+            return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + '\nBad object: ' + JSON.stringify(props[propName], null, '  ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  '));
+          }
+          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+          if (error) {
+            return error;
+          }
+        }
+        return null;
+      }
+      return createChainableTypeChecker(validate);
+    }
+    function isNode(propValue) {
+      switch (_typeof(propValue)) {
+        case 'number':
+        case 'string':
+        case 'undefined':
+          return true;
+        case 'boolean':
+          return !propValue;
+        case 'object':
+          if (Array.isArray(propValue)) {
+            return propValue.every(isNode);
+          }
+          if (propValue === null || isValidElement(propValue)) {
+            return true;
+          }
+          var iteratorFn = getIteratorFn(propValue);
+          if (iteratorFn) {
+            var iterator = iteratorFn.call(propValue);
+            var step;
+            if (iteratorFn !== propValue.entries) {
+              while (!(step = iterator.next()).done) {
+                if (!isNode(step.value)) {
+                  return false;
+                }
+              }
+            } else {
+              // Iterator will provide entry [k,v] tuples rather than values.
+              while (!(step = iterator.next()).done) {
+                var entry = step.value;
+                if (entry) {
+                  if (!isNode(entry[1])) {
+                    return false;
+                  }
+                }
+              }
+            }
+          } else {
+            return false;
+          }
+          return true;
+        default:
+          return false;
+      }
+    }
+    function isSymbol(propType, propValue) {
+      // Native Symbol.
+      if (propType === 'symbol') {
+        return true;
+      }
+
+      // falsy value can't be a Symbol
+      if (!propValue) {
+        return false;
+      }
+
+      // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
+      if (propValue['@@toStringTag'] === 'Symbol') {
+        return true;
+      }
+
+      // Fallback for non-spec compliant Symbols which are polyfilled.
+      if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+        return true;
+      }
+      return false;
+    }
+
+    // Equivalent of `typeof` but with special handling for array and regexp.
+    function getPropType(propValue) {
+      var propType = _typeof(propValue);
+      if (Array.isArray(propValue)) {
+        return 'array';
+      }
+      if (propValue instanceof RegExp) {
+        // Old webkits (at least until Android 4.0) return 'function' rather than
+        // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
+        // passes PropTypes.object.
+        return 'object';
+      }
+      if (isSymbol(propType, propValue)) {
+        return 'symbol';
+      }
+      return propType;
+    }
+
+    // This handles more types than `getPropType`. Only used for error messages.
+    // See `createPrimitiveTypeChecker`.
+    function getPreciseType(propValue) {
+      if (typeof propValue === 'undefined' || propValue === null) {
+        return '' + propValue;
+      }
+      var propType = getPropType(propValue);
+      if (propType === 'object') {
+        if (propValue instanceof Date) {
+          return 'date';
+        } else if (propValue instanceof RegExp) {
+          return 'regexp';
+        }
+      }
+      return propType;
+    }
+
+    // Returns a string that is postfixed to a warning about an invalid type.
+    // For example, "undefined" or "of type array"
+    function getPostfixForTypeWarning(value) {
+      var type = getPreciseType(value);
+      switch (type) {
+        case 'array':
+        case 'object':
+          return 'an ' + type;
+        case 'boolean':
+        case 'date':
+        case 'regexp':
+          return 'a ' + type;
+        default:
+          return type;
+      }
+    }
+
+    // Returns class name of the object, if any.
+    function getClassName(propValue) {
+      if (!propValue.constructor || !propValue.constructor.name) {
+        return ANONYMOUS;
+      }
+      return propValue.constructor.name;
+    }
+    ReactPropTypes.checkPropTypes = checkPropTypes;
+    ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+    ReactPropTypes.PropTypes = ReactPropTypes;
+    return ReactPropTypes;
+  };
+  return factoryWithTypeCheckers;
+}
+
+/**
+ * Copyright (c) 2013-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 factoryWithThrowingShims;
+var hasRequiredFactoryWithThrowingShims;
+function requireFactoryWithThrowingShims() {
+  if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
+  hasRequiredFactoryWithThrowingShims = 1;
+  var ReactPropTypesSecret = requireReactPropTypesSecret();
+  function emptyFunction() {}
+  function emptyFunctionWithReset() {}
+  emptyFunctionWithReset.resetWarningCache = emptyFunction;
+  factoryWithThrowingShims = function factoryWithThrowingShims() {
+    function shim(props, propName, componentName, location, propFullName, secret) {
+      if (secret === ReactPropTypesSecret) {
+        // It is still safe when called from React.
+        return;
+      }
+      var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
+      err.name = 'Invariant Violation';
+      throw err;
+    }
+    shim.isRequired = shim;
+    function getShim() {
+      return shim;
+    }
+    // Important!
+    // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
+    var ReactPropTypes = {
+      array: shim,
+      bigint: shim,
+      bool: shim,
+      func: shim,
+      number: shim,
+      object: shim,
+      string: shim,
+      symbol: shim,
+      any: shim,
+      arrayOf: getShim,
+      element: shim,
+      elementType: shim,
+      instanceOf: getShim,
+      node: shim,
+      objectOf: getShim,
+      oneOf: getShim,
+      oneOfType: getShim,
+      shape: getShim,
+      exact: getShim,
+      checkPropTypes: emptyFunctionWithReset,
+      resetWarningCache: emptyFunction
+    };
+    ReactPropTypes.PropTypes = ReactPropTypes;
+    return ReactPropTypes;
+  };
+  return factoryWithThrowingShims;
+}
+
+/**
+ * Copyright (c) 2013-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.
+ */
+if (process.env.NODE_ENV !== 'production') {
+  var ReactIs = requireReactIs();
+
+  // By explicitly using `prop-types` you are opting into new development behavior.
+  // http://fb.me/prop-types-in-prod
+  var throwOnDirectAccess = true;
+  propTypes.exports = requireFactoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
+} else {
+  // By explicitly using `prop-types` you are opting into new production behavior.
+  // http://fb.me/prop-types-in-prod
+  propTypes.exports = requireFactoryWithThrowingShims()();
+}
+var propTypesExports = propTypes.exports;
+var dateFormats = {
+  date: 'YYYY-MM-DD',
+  basic_date: 'YYYYMMDD',
+  basic_date_time: 'YYYYMMDD[T]HHmmss.SSSZ',
+  basic_date_time_no_millis: 'YYYYMMDD[T]HHmmssZ',
+  date_time_no_millis: 'YYYY-MM-DD[T]HH:mm:ssZ',
+  basic_time: 'HHmmss.SSSZ',
+  basic_time_no_millis: 'HHmmssZ',
+  epoch_millis: 'epoch_millis',
+  epoch_second: 'epoch_second'
+};
+var componentTypes = {
+  reactiveList: 'REACTIVELIST',
+  // search components
+  dataSearch: 'DATASEARCH',
+  categorySearch: 'CATEGORYSEARCH',
+  searchBox: 'SEARCHBOX',
+  // list components
+  singleList: 'SINGLELIST',
+  multiList: 'MULTILIST',
+  singleDataList: 'SINGLEDATALIST',
+  tabDataList: 'TABDATALIST',
+  singleDropdownList: 'SINGLEDROPDOWNLIST',
+  multiDataList: 'MULTIDATALIST',
+  multiDropdownList: 'MULTIDROPDOWNLIST',
+  singleDropdownRange: 'SINGLEDROPDOWNRANGE',
+  treeList: 'TREELIST',
+  // basic components
+  numberBox: 'NUMBERBOX',
+  tagCloud: 'TAGCLOUD',
+  toggleButton: 'TOGGLEBUTTON',
+  reactiveComponent: 'REACTIVECOMPONENT',
+  // range components
+  datePicker: 'DATEPICKER',
+  dateRange: 'DATERANGE',
+  dynamicRangeSlider: 'DYNAMICRANGESLIDER',
+  multiDropdownRange: 'MULTIDROPDOWNRANGE',
+  singleRange: 'SINGLERANGE',
+  multiRange: 'MULTIRANGE',
+  rangeSlider: 'RANGESLIDER',
+  ratingsFilter: 'RATINGSFILTER',
+  rangeInput: 'RANGEINPUT',
+  // map components
+  geoDistanceDropdown: 'GEO_DISTANCE_DROPDOWN',
+  geoDistanceSlider: 'GEO_DISTANCE_SLIDER',
+  reactiveMap: 'REACTIVE_MAP',
+  // chart components
+  reactiveChart: 'REACTIVE_CHART'
+};
+var CLEAR_ALL = {
+  NEVER: 'never',
+  ALWAYS: 'always',
+  DEFAULT: 'default'
+};
+var reactKeyType = propTypesExports.oneOfType([propTypesExports.string, propTypesExports.arrayOf(propTypesExports.string), propTypesExports.object, propTypesExports.arrayOf(propTypesExports.object)]);
+function validateLocation(props, propName) {
+  // eslint-disable-next-line
+  if (isNaN(props[propName])) {
+    return new Error("".concat(propName, " value must be a number"));
+  }
+  if (propName === 'lat' && (props[propName] < -90 || props[propName] > 90)) {
+    return new Error("".concat(propName, " value should be between -90 and 90."));
+  } else if (propName === 'lng' && (props[propName] < -180 || props[propName] > 180)) {
+    return new Error("".concat(propName, " value should be between -180 and 180."));
+  }
+  return null;
+}
+
+// eslint-disable-next-line consistent-return
+var dataFieldValidator = function dataFieldValidator(props, propName, componentName) {
+  var requiredError = new Error("".concat(propName, " supplied to ").concat(componentName, " is required. Validation failed."));
+  var propValue = props[propName];
+  if (!propValue) return requiredError;
+  if (typeof propValue !== 'string' && _typeof(propValue) !== 'object' && !Array.isArray(propValue)) {
+    return new Error("Invalid ".concat(propName, " supplied to ").concat(componentName, ". Validation failed."));
+  }
+  if (Array.isArray(propValue) && propValue.length === 0) return requiredError;
+};
+var types = {
+  any: propTypesExports.any,
+  analyticsConfig: propTypesExports.shape({
+    emptyQuery: propTypesExports.bool,
+    suggestionAnalytics: propTypesExports.bool,
+    userId: propTypesExports.string,
+    customEvents: propTypesExports.object // eslint-disable-line
+  }),
+
+  appbaseConfig: propTypesExports.shape({
+    enableQueryRules: propTypesExports.bool,
+    enableSearchRelevancy: propTypesExports.bool,
+    recordAnalytics: propTypesExports.bool,
+    emptyQuery: propTypesExports.bool,
+    suggestionAnalytics: propTypesExports.bool,
+    userId: propTypesExports.string,
+    useCache: propTypesExports.bool,
+    customEvents: propTypesExports.object,
+    // eslint-disable-line
+    enableTelemetry: propTypesExports.bool,
+    queryString: propTypesExports.object // eslint-disable-line
+  }),
+
+  bool: propTypesExports.bool,
+  boolRequired: propTypesExports.bool.isRequired,
+  components: propTypesExports.arrayOf(propTypesExports.string),
+  children: propTypesExports.any,
+  data: propTypesExports.arrayOf(propTypesExports.object),
+  dataFieldArray: propTypesExports.oneOfType([propTypesExports.string, propTypesExports.arrayOf(propTypesExports.string)]).isRequired,
+  dataNumberBox: propTypesExports.shape({
+    label: propTypesExports.string,
+    start: propTypesExports.number.isRequired,
+    end: propTypesExports.number.isRequired
+  }).isRequired,
+  date: propTypesExports.oneOfType([propTypesExports.string, propTypesExports.arrayOf(propTypesExports.string)]),
+  dateObject: propTypesExports.object,
+  excludeFields: propTypesExports.arrayOf(propTypesExports.string),
+  fieldWeights: propTypesExports.arrayOf(propTypesExports.number),
+  filterLabel: propTypesExports.string,
+  func: propTypesExports.func,
+  funcRequired: propTypesExports.func.isRequired,
+  fuzziness: propTypesExports.oneOf([0, 1, 2, 'AUTO']),
+  headers: propTypesExports.object,
+  hits: propTypesExports.arrayOf(propTypesExports.object),
+  rawData: propTypesExports.object,
+  iconPosition: propTypesExports.oneOf(['left', 'right']),
+  includeFields: propTypesExports.arrayOf(propTypesExports.string),
+  labelPosition: propTypesExports.oneOf(['left', 'right', 'top', 'bottom']),
+  number: propTypesExports.number,
+  options: propTypesExports.oneOfType([propTypesExports.arrayOf(propTypesExports.object), propTypesExports.object]),
+  paginationAt: propTypesExports.oneOf(['top', 'bottom', 'both']),
+  range: propTypesExports.shape({
+    start: propTypesExports.oneOfType([propTypesExports.number, propTypesExports.string, propTypesExports.object]).isRequired,
+    end: propTypesExports.oneOfType([propTypesExports.number, propTypesExports.string, propTypesExports.object]).isRequired
+  }),
+  rangeLabels: propTypesExports.shape({
+    start: propTypesExports.string.isRequired,
+    end: propTypesExports.string.isRequired
+  }),
+  react: propTypesExports.shape({
+    and: reactKeyType,
+    or: reactKeyType,
+    not: reactKeyType
+  }),
+  categorySearchValue: propTypesExports.shape({
+    term: propTypesExports.string,
+    category: propTypesExports.string
+  }),
+  selectedValues: propTypesExports.object,
+  selectedValue: propTypesExports.oneOfType([propTypesExports.string, propTypesExports.arrayOf(propTypesExports.string), propTypesExports.arrayOf(propTypesExports.object), propTypesExports.object, propTypesExports.number, propTypesExports.arrayOf(propTypesExports.number)]),
+  suggestions: propTypesExports.arrayOf(propTypesExports.object),
+  supportedOrientations: propTypesExports.oneOf(['portrait', 'portrait-upside-down', 'landscape', 'landscape-left', 'landscape-right']),
+  tooltipTrigger: propTypesExports.oneOf(['hover', 'none', 'focus', 'always']),
+  sortBy: propTypesExports.oneOf(['asc', 'desc']),
+  sortOptions: propTypesExports.arrayOf(propTypesExports.shape({
+    label: propTypesExports.string,
+    dataField: propTypesExports.string,
+    sortBy: propTypesExports.string
+  })),
+  sortByWithCount: propTypesExports.oneOf(['asc', 'desc', 'count']),
+  stats: propTypesExports.arrayOf(propTypesExports.object),
+  string: propTypesExports.string,
+  stringArray: propTypesExports.arrayOf(propTypesExports.string),
+  stringOrArray: propTypesExports.oneOfType([propTypesExports.string, propTypesExports.arrayOf(propTypesExports.string)]),
+  stringRequired: propTypesExports.string.isRequired,
+  style: propTypesExports.object,
+  themePreset: propTypesExports.oneOf(['light', 'dark']),
+  queryFormatDate: propTypesExports.oneOf(Object.keys(dateFormats)),
+  queryFormatSearch: propTypesExports.oneOf(['and', 'or']),
+  queryFormatNumberBox: propTypesExports.oneOf(['exact', 'lte', 'gte']),
+  params: propTypesExports.object.isRequired,
+  props: propTypesExports.object,
+  rangeLabelsAlign: propTypesExports.oneOf(['left', 'right']),
+  title: propTypesExports.oneOfType([propTypesExports.string, propTypesExports.any]),
+  location: propTypesExports.shape({
+    lat: validateLocation,
+    lng: validateLocation
+  }),
+  unit: propTypesExports.oneOf(['mi', 'miles', 'yd', 'yards', 'ft', 'feet', 'in', 'inch', 'km', 'kilometers', 'm', 'meters', 'cm', 'centimeters', 'mm', 'millimeters', 'NM', 'nmi', 'nauticalmiles']),
+  aggregationData: propTypesExports.array,
+  showClearAll: propTypesExports.oneOf([CLEAR_ALL.NEVER, CLEAR_ALL.ALWAYS, CLEAR_ALL.DEFAULT, true, false]),
+  componentType: propTypesExports.oneOf(Object.values(componentTypes)),
+  componentObject: propTypesExports.object,
+  dataFieldValidator: dataFieldValidator,
+  focusShortcuts: propTypesExports.oneOfType([propTypesExports.arrayOf(propTypesExports.string), propTypesExports.arrayOf(propTypesExports.number)]),
+  mongodb: propTypesExports.shape({
+    db: propTypesExports.string,
+    collection: propTypesExports.string
+  }),
+  calendarInterval: propTypesExports.oneOf(['month', 'day', 'year', 'week', 'quarter', 'hour', 'minute']),
+  preferences: propTypesExports.object,
+  endpoint: propTypesExports.shape({
+    url: propTypesExports.string.isRequired,
+    method: propTypesExports.string,
+    /* eslint-disable react/forbid-prop-types */
+    headers: propTypesExports.object,
+    body: propTypesExports.object
+    /* eslint-enable react/forbid-prop-types */
+  })
+};
 
 var _templateObject$8, _templateObject2$1;
 var HierarchicalMenuList = styled('ul')(_templateObject$8 || (_templateObject$8 = _taggedTemplateLiteralLoose(["\n\tlist-style: none;\n\tpadding: 0;\n\tmargin: 0;\n\tmax-height: 0;\n\toverflow: hidden;\n\n\t&.--open {\n\t\tmax-height: 100%;\n\t}\n"])));
@@ -1896,22 +3212,22 @@ var HierarchicalMenuListItemComponent = {
     }
   },
   props: {
-    parentPath: types$1.string,
-    selectedValues: types$1.rawData,
-    mode: types$1.string,
-    searchTerm: types$1.string,
-    listItem: types$1.rawData,
-    showLine: types$1.bool,
-    renderItem: types$1.func,
-    handleListItemClick: types$1.func,
-    renderSwitcherIcon: types$1.func,
+    parentPath: types.string,
+    selectedValues: types.rawData,
+    mode: types.string,
+    searchTerm: types.string,
+    listItem: types.rawData,
+    showLine: types.bool,
+    renderItem: types.func,
+    handleListItemClick: types.func,
+    renderSwitcherIcon: types.func,
     showCheckbox: VueTypes.bool,
-    innerClass: types$1.style,
+    innerClass: types.style,
     showRadio: VueTypes.bool,
-    renderIcon: types$1.func,
+    renderIcon: types.func,
     showCount: VueTypes.bool,
-    showSwitcherIcon: types$1.bool,
-    switcherIcon: types$1.children
+    showSwitcherIcon: types.bool,
+    switcherIcon: types.children
   },
   render: function render() {
     var _this = this;
@@ -2087,7 +3403,7 @@ var HierarchicalMenuComponent = {
     // array of objects
     parentPath: VueTypes.string.def(''),
     isExpanded: VueTypes.bool.def(false),
-    listItemProps: types$1.rawData
+    listItemProps: types.rawData
   },
   render: function render() {
     var _slot;
@@ -2135,62 +3451,62 @@ var transformValueIntoLocalState = function transformValueIntoLocalState(valueAr
 var TreeList = {
   name: 'TreeList',
   props: {
-    selectedValue: types.selectedValue,
-    error: types.title,
-    rawData: types.rawData,
-    aggregationData: types.rawData,
-    themePreset: types.themePreset,
-    updateQueryAction: types.funcRequired,
-    setQueryOptions: types.funcRequired,
+    selectedValue: types$1.selectedValue,
+    error: types$1.title,
+    rawData: types$1.rawData,
+    aggregationData: types$1.rawData,
+    themePreset: types$1.themePreset,
+    updateQueryAction: types$1.funcRequired,
+    setQueryOptions: types$1.funcRequired,
     // component props
-    componentId: types.string.isRequired,
-    className: types.string,
-    style: types.style,
+    componentId: types$1.string.isRequired,
+    className: types$1.string,
+    style: types$1.style,
     showRadio: VueTypes.bool.def(false),
-    showCheckbox: types.bool.def(false),
+    showCheckbox: types$1.bool.def(false),
     mode: VueTypes.oneOf(['single', 'multiple']).def('multiple'),
     showCount: VueTypes.bool.def(false),
     showSearch: VueTypes.bool.def(false),
     showIcon: VueTypes.bool.def(false),
-    icon: types.children,
+    icon: types$1.children,
     showLeafIcon: VueTypes.bool.def(false),
-    leafIcon: types.children,
+    leafIcon: types$1.children,
     showLine: VueTypes.bool.def(false),
-    switcherIcon: types.func,
-    render: types.func,
-    renderItem: types.func,
-    innerClass: types.style,
-    placeholder: types.string,
-    title: types.title,
-    isLoading: types.bool,
-    dataField: types.stringArray.isRequired,
-    onQueryChange: types.func,
-    defaultValue: types.stringArray,
-    value: types.stringArray,
-    customQuery: types.func,
-    defaultQuery: types.func,
-    enableAppbase: types.bool,
-    index: types.string,
-    showFilter: types.bool,
-    URLParams: types.bool,
-    filterLabel: types.string,
-    onChange: types.func,
-    onValueChange: types.func,
-    beforeValueChange: types.func,
-    sortBy: types.sortByWithCount.def('count'),
-    onError: types.func,
-    showSwitcherIcon: types.bool.def(true),
-    renderError: types.title,
-    renderNoResults: types.func,
-    loader: types.title,
-    aggergationSize: types.number,
-    endpoint: types.endpoint,
-    queryFormat: types.queryFormatSearch.def('or'),
-    size: types.number.def(100),
-    nestedField: types.string,
-    react: types.react,
-    transformData: types.func,
-    selectAllLabel: types.string,
+    switcherIcon: types$1.func,
+    render: types$1.func,
+    renderItem: types$1.func,
+    innerClass: types$1.style,
+    placeholder: types$1.string,
+    title: types$1.title,
+    isLoading: types$1.bool,
+    dataField: types$1.stringArray.isRequired,
+    onQueryChange: types$1.func,
+    defaultValue: types$1.stringArray,
+    value: types$1.stringArray,
+    customQuery: types$1.func,
+    defaultQuery: types$1.func,
+    enableAppbase: types$1.bool,
+    index: types$1.string,
+    showFilter: types$1.bool,
+    URLParams: types$1.bool,
+    filterLabel: types$1.string,
+    onChange: types$1.func,
+    onValueChange: types$1.func,
+    beforeValueChange: types$1.func,
+    sortBy: types$1.sortByWithCount.def('count'),
+    onError: types$1.func,
+    showSwitcherIcon: types$1.bool.def(true),
+    renderError: types$1.title,
+    renderNoResults: types$1.func,
+    loader: types$1.title,
+    aggergationSize: types$1.number,
+    endpoint: types$1.endpoint,
+    queryFormat: types$1.queryFormatSearch.def('or'),
+    size: types$1.number.def(100),
+    nestedField: types$1.string,
+    react: types$1.react,
+    transformData: types$1.func,
+    selectAllLabel: types$1.string,
     showMissing: VueTypes.bool.def(false),
     missingLabel: VueTypes.string.def('N/A')
   },
@@ -2484,7 +3800,7 @@ var TreeList = {
         label: this.$props.filterLabel,
         showFilter: this.$props.showFilter,
         URLParams: this.$props.URLParams,
-        componentType: componentTypes.treeList
+        componentType: componentTypes$1.treeList
       });
     },
     setValue: function setValue(value, hasMountedParam) {
@@ -2614,7 +3930,7 @@ TreeList.hasInternalComponent = function () {
   return true;
 };
 var TreeListConnected = PreferencesConsumer(ComponentWrapper(connect(mapStateToProps$1, mapDispatchtoProps)(TreeList), {
-  componentType: componentTypes.treeList,
+  componentType: componentTypes$1.treeList,
   internalComponent: TreeList.hasInternalComponent()
 }));
 TreeListConnected.name = TreeList.name;
@@ -2623,50 +3939,50 @@ TreeListConnected.install = function (Vue) {
 };
 
 // Add componentType for SSR
-TreeListConnected.componentType = componentTypes.treeList;
+TreeListConnected.componentType = componentTypes$1.treeList;
 
 var RcConnected = PreferencesConsumer({
   name: 'RcConnected',
   render: function render() {
     var component = ReactiveComponent;
     switch (this.$attrs.componentType) {
-      case componentTypes.reactiveList:
+      case componentTypes$1.reactiveList:
         component = ReactiveList;
         break;
-      case componentTypes.searchBox:
+      case componentTypes$1.searchBox:
         component = SBConnected;
         break;
       // list components
-      case componentTypes.singleList:
+      case componentTypes$1.singleList:
         component = SingleList;
         break;
-      case componentTypes.multiList:
+      case componentTypes$1.multiList:
         component = MultiList;
         break;
-      case componentTypes.singleDropdownList:
+      case componentTypes$1.singleDropdownList:
         component = SingleDropdownList;
         break;
-      case componentTypes.multiDropdownList:
+      case componentTypes$1.multiDropdownList:
         component = MultiDropdownList;
         break;
       // basic components
-      case componentTypes.toggleButton:
+      case componentTypes$1.toggleButton:
         component = ToggleButton;
         break;
       // range components
-      case componentTypes.dynamicRangeSlider:
+      case componentTypes$1.dynamicRangeSlider:
         component = DynamicRangeSlider;
         break;
-      case componentTypes.singleRange:
+      case componentTypes$1.singleRange:
         component = SingleRange;
         break;
-      case componentTypes.multiRange:
+      case componentTypes$1.multiRange:
         component = MultiRange;
         break;
-      case componentTypes.rangeSlider:
+      case componentTypes$1.rangeSlider:
         component = RangeSlider;
         break;
-      case componentTypes.rangeInput:
+      case componentTypes$1.rangeInput:
         component = RangeInput;
         break;
     }
@@ -2676,7 +3992,7 @@ var RcConnected = PreferencesConsumer({
 RcConnected.name = ReactiveComponent.name;
 RcConnected.hasInternalComponent = ReactiveComponent.hasInternalComponent;
 // Add componentType for SSR
-RcConnected.componentType = componentTypes.reactiveComponent;
+RcConnected.componentType = componentTypes$1.reactiveComponent;
 RcConnected.install = function (Vue) {
   Vue.component(RcConnected.name, RcConnected);
 };