downshift 3.4.7 → 3.4.8

package/dist/downshift.umd.js

@@ -223,212 +223,240 @@
 
   var reactIs_development = createCommonjsModule(function (module, exports) {
 
-    (function () {
-      Object.defineProperty(exports, '__esModule', {
-        value: true
-      }); // 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_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
-      var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+    {
+      (function () {
+
+        Object.defineProperty(exports, '__esModule', {
+          value: true
+        }); // 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_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+        var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+
+        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);
+        }
+        /**
+         * Forked from fbjs/warning:
+         * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
+         *
+         * Only change is we use console.warn instead of console.error,
+         * and do nothing when 'console' is not supported.
+         * This really simplifies the code.
+         * ---
+         * Similar to invariant but only logs a warning if the condition is not met.
+         * This can be used to log issues in development environments in critical
+         * paths. Removing the logging code for production environments will keep the
+         * same logic and follow the same code paths.
+         */
+
+
+        var lowPriorityWarning = function () {};
 
-      /**
-       * Forked from fbjs/warning:
-       * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
-       *
-       * Only change is we use console.warn instead of console.error,
-       * and do nothing when 'console' is not supported.
-       * This really simplifies the code.
-       * ---
-       * Similar to invariant but only logs a warning if the condition is not met.
-       * This can be used to log issues in development environments in critical
-       * paths. Removing the logging code for production environments will keep the
-       * same logic and follow the same code paths.
-       */
-      var lowPriorityWarning = function () {};
+        {
+          var printWarning = function (format) {
+            for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+              args[_key - 1] = arguments[_key];
+            }
 
-      {
-        var printWarning = function (format) {
-          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-            args[_key - 1] = arguments[_key];
-          }
+            var argIndex = 0;
+            var message = 'Warning: ' + format.replace(/%s/g, function () {
+              return args[argIndex++];
+            });
 
-          var argIndex = 0;
-          var message = 'Warning: ' + format.replace(/%s/g, function () {
-            return args[argIndex++];
-          });
+            if (typeof console !== 'undefined') {
+              console.warn(message);
+            }
 
-          if (typeof console !== 'undefined') {
-            console.warn(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) {}
+          };
 
-          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) {}
-        };
+          lowPriorityWarning = function (condition, format) {
+            if (format === undefined) {
+              throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
+            }
 
-        lowPriorityWarning = function (condition, format) {
-          if (format === undefined) {
-            throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
-          }
+            if (!condition) {
+              for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+                args[_key2 - 2] = arguments[_key2];
+              }
 
-          if (!condition) {
-            for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
-              args[_key2 - 2] = arguments[_key2];
+              printWarning.apply(undefined, [format].concat(args));
             }
+          };
+        }
+        var lowPriorityWarning$1 = lowPriorityWarning;
 
-            printWarning.apply(undefined, [format].concat(args));
-          }
-        };
-      }
-      var lowPriorityWarning$1 = lowPriorityWarning;
-
-      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_PROVIDER_TYPE:
-                      return $$typeofType;
-
-                    default:
-                      return $$typeof;
-                  }
+        function typeOf(object) {
+          if (typeof object === 'object' && object !== null) {
+            var $$typeof = object.$$typeof;
 
-              }
+            switch ($$typeof) {
+              case REACT_ELEMENT_TYPE:
+                var type = object.type;
 
-            case REACT_LAZY_TYPE:
-            case REACT_MEMO_TYPE:
-            case REACT_PORTAL_TYPE:
-              return $$typeof;
-          }
-        }
+                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;
 
-        return undefined;
-      } // AsyncMode is deprecated along with isAsyncMode
+                    switch ($$typeofType) {
+                      case REACT_CONTEXT_TYPE:
+                      case REACT_FORWARD_REF_TYPE:
+                      case REACT_PROVIDER_TYPE:
+                        return $$typeofType;
 
+                      default:
+                        return $$typeof;
+                    }
 
-      var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+                }
 
-      function isAsyncMode(object) {
-        {
-          if (!hasWarnedAboutDeprecatedIsAsyncMode) {
-            hasWarnedAboutDeprecatedIsAsyncMode = true;
-            lowPriorityWarning$1(false, '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.');
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+              case REACT_PORTAL_TYPE:
+                return $$typeof;
+            }
           }
-        }
-        return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
-      }
 
-      function isConcurrentMode(object) {
-        return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
-      }
+          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;
+              lowPriorityWarning$1(false, '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;
+        }
 
-      exports.typeOf = typeOf;
-      exports.AsyncMode = REACT_ASYNC_MODE_TYPE;
-      exports.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
-      exports.ContextConsumer = REACT_CONTEXT_TYPE;
-      exports.ContextProvider = REACT_PROVIDER_TYPE;
-      exports.Element = REACT_ELEMENT_TYPE;
-      exports.ForwardRef = REACT_FORWARD_REF_TYPE;
-      exports.Fragment = REACT_FRAGMENT_TYPE;
-      exports.Lazy = REACT_LAZY_TYPE;
-      exports.Memo = REACT_MEMO_TYPE;
-      exports.Portal = REACT_PORTAL_TYPE;
-      exports.Profiler = REACT_PROFILER_TYPE;
-      exports.StrictMode = REACT_STRICT_MODE_TYPE;
-      exports.Suspense = REACT_SUSPENSE_TYPE;
-
-      exports.isValidElementType = function (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);
-      };
+        function isConcurrentMode(object) {
+          return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+        }
 
-      exports.isAsyncMode = isAsyncMode;
-      exports.isConcurrentMode = isConcurrentMode;
+        function isContextConsumer(object) {
+          return typeOf(object) === REACT_CONTEXT_TYPE;
+        }
 
-      exports.isContextConsumer = function (object) {
-        return typeOf(object) === REACT_CONTEXT_TYPE;
-      };
+        function isContextProvider(object) {
+          return typeOf(object) === REACT_PROVIDER_TYPE;
+        }
 
-      exports.isContextProvider = function (object) {
-        return typeOf(object) === REACT_PROVIDER_TYPE;
-      };
+        function isElement(object) {
+          return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
 
-      exports.isElement = function (object) {
-        return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
-      };
+        function isForwardRef(object) {
+          return typeOf(object) === REACT_FORWARD_REF_TYPE;
+        }
 
-      exports.isForwardRef = function (object) {
-        return typeOf(object) === REACT_FORWARD_REF_TYPE;
-      };
+        function isFragment(object) {
+          return typeOf(object) === REACT_FRAGMENT_TYPE;
+        }
 
-      exports.isFragment = function (object) {
-        return typeOf(object) === REACT_FRAGMENT_TYPE;
-      };
+        function isLazy(object) {
+          return typeOf(object) === REACT_LAZY_TYPE;
+        }
 
-      exports.isLazy = function (object) {
-        return typeOf(object) === REACT_LAZY_TYPE;
-      };
+        function isMemo(object) {
+          return typeOf(object) === REACT_MEMO_TYPE;
+        }
 
-      exports.isMemo = function (object) {
-        return typeOf(object) === REACT_MEMO_TYPE;
-      };
+        function isPortal(object) {
+          return typeOf(object) === REACT_PORTAL_TYPE;
+        }
 
-      exports.isPortal = function (object) {
-        return typeOf(object) === REACT_PORTAL_TYPE;
-      };
+        function isProfiler(object) {
+          return typeOf(object) === REACT_PROFILER_TYPE;
+        }
 
-      exports.isProfiler = function (object) {
-        return typeOf(object) === REACT_PROFILER_TYPE;
-      };
+        function isStrictMode(object) {
+          return typeOf(object) === REACT_STRICT_MODE_TYPE;
+        }
 
-      exports.isStrictMode = function (object) {
-        return typeOf(object) === REACT_STRICT_MODE_TYPE;
-      };
+        function isSuspense(object) {
+          return typeOf(object) === REACT_SUSPENSE_TYPE;
+        }
 
-      exports.isSuspense = function (object) {
-        return typeOf(object) === REACT_SUSPENSE_TYPE;
-      };
-    })();
+        exports.typeOf = typeOf;
+        exports.AsyncMode = AsyncMode;
+        exports.ConcurrentMode = ConcurrentMode;
+        exports.ContextConsumer = ContextConsumer;
+        exports.ContextProvider = ContextProvider;
+        exports.Element = Element;
+        exports.ForwardRef = ForwardRef;
+        exports.Fragment = Fragment;
+        exports.Lazy = Lazy;
+        exports.Memo = Memo;
+        exports.Portal = Portal;
+        exports.Profiler = Profiler;
+        exports.StrictMode = StrictMode;
+        exports.Suspense = Suspense;
+        exports.isValidElementType = isValidElementType;
+        exports.isAsyncMode = isAsyncMode;
+        exports.isConcurrentMode = isConcurrentMode;
+        exports.isContextConsumer = isContextConsumer;
+        exports.isContextProvider = isContextProvider;
+        exports.isElement = isElement;
+        exports.isForwardRef = isForwardRef;
+        exports.isFragment = isFragment;
+        exports.isLazy = isLazy;
+        exports.isMemo = isMemo;
+        exports.isPortal = isPortal;
+        exports.isProfiler = isProfiler;
+        exports.isStrictMode = isStrictMode;
+        exports.isSuspense = isSuspense;
+      })();
+    }
   });
   unwrapExports(reactIs_development);
   var reactIs_development_1 = reactIs_development.typeOf;
@@ -462,7 +490,9 @@
 
   var reactIs = createCommonjsModule(function (module) {
 
-    module.exports = reactIs_development;
+    {
+      module.exports = reactIs_development;
+    }
   });
   var reactIs_1 = reactIs.isForwardRef;
 
@@ -533,7 +563,7 @@
     }
   }
 
-  var objectAssign = shouldUseNative() ? Object.assign : function (target) {
+  var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
     var from;
     var to = toObject(target);
     var symbols;
@@ -571,33 +601,28 @@
   var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
   var ReactPropTypesSecret_1 = ReactPropTypesSecret;
 
-  /**
-   * 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 printWarning = function () {};
 
-  var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
-  var loggedTypeFailures = {};
-  var has = Function.call.bind(Object.prototype.hasOwnProperty);
+  {
+    var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
+    var loggedTypeFailures = {};
+    var has = Function.call.bind(Object.prototype.hasOwnProperty);
 
-  printWarning = function (text) {
-    var message = 'Warning: ' + text;
+    printWarning = function (text) {
+      var message = 'Warning: ' + text;
 
-    if (typeof console !== 'undefined') {
-      console.error(message);
-    }
+      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) {}
-  };
+      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.
@@ -612,36 +637,38 @@
 
 
   function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
-    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] + '`.');
-            err.name = 'Invariant Violation';
-            throw err;
-          }
+    {
+      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.
 
-          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);
-        } catch (ex) {
-          error = ex;
-        }
+          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] + '`.');
+              err.name = 'Invariant Violation';
+              throw err;
+            }
 
-        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).');
-        }
+            error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);
+          } 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 : ''));
+          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 : ''));
+          }
         }
       }
     }
@@ -654,36 +681,33 @@
 
 
   checkPropTypes.resetWarningCache = function () {
-    loggedTypeFailures = {};
+    {
+      loggedTypeFailures = {};
+    }
   };
 
   var checkPropTypes_1 = checkPropTypes;
 
-  /**
-   * 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 has$1 = Function.call.bind(Object.prototype.hasOwnProperty);
 
   var printWarning$1 = function () {};
 
-  printWarning$1 = function (text) {
-    var message = 'Warning: ' + text;
+  {
+    printWarning$1 = function (text) {
+      var message = 'Warning: ' + text;
 
-    if (typeof console !== 'undefined') {
-      console.error(message);
-    }
+      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) {}
-  };
+      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;
@@ -692,8 +716,7 @@
   var factoryWithTypeCheckers = function (isValidElement, throwOnDirectAccess) {
     /* global Symbol */
     var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
-
-    // Before Symbol spec.
+    var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
 
     /**
      * Returns the iterator method function contained on the iterable object.
@@ -709,8 +732,9 @@
      * @param {?object} maybeIterable
      * @return {?function}
      */
+
     function getIteratorFn(maybeIterable) {
-      var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable['@@iterator']);
+      var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
 
       if (typeof iteratorFn === 'function') {
         return iteratorFn;
@@ -775,161 +799,17 @@
       object: createPrimitiveTypeChecker('object'),
       string: createPrimitiveTypeChecker('string'),
       symbol: createPrimitiveTypeChecker('symbol'),
-      any: function () {
-        return createChainableTypeChecker(emptyFunctionThatReturnsNull);
-      }(),
-      arrayOf: function (typeChecker) {
-        return createChainableTypeChecker(function (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_1);
-
-            if (error instanceof Error) {
-              return error;
-            }
-          }
-
-          return null;
-        });
-      },
-      element: function () {
-        return createChainableTypeChecker(function (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;
-        });
-      }(),
-      elementType: function () {
-        return createChainableTypeChecker(function (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;
-        });
-      }(),
-      instanceOf: function (expectedClass) {
-        return createChainableTypeChecker(function (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;
-        });
-      },
-      node: function () {
-        return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
-          if (!isNode(props[propName])) {
-            return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
-          }
-
-          return null;
-        });
-      }(),
-      objectOf: function (typeChecker) {
-        return createChainableTypeChecker(function (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$1(propValue, key)) {
-              var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);
-
-              if (error instanceof Error) {
-                return error;
-              }
-            }
-          }
-
-          return null;
-        });
-      },
+      any: createAnyTypeChecker(),
+      arrayOf: createArrayOfTypeChecker,
+      element: createElementTypeChecker(),
+      elementType: createElementTypeTypeChecker(),
+      instanceOf: createInstanceTypeChecker,
+      node: createNodeChecker(),
+      objectOf: createObjectOfTypeChecker,
       oneOf: createEnumTypeChecker,
       oneOfType: createUnionTypeChecker,
-      shape: function (shapeTypes) {
-        return createChainableTypeChecker(function (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 (!checker) {
-              continue;
-            }
-
-            var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);
-
-            if (error) {
-              return error;
-            }
-          }
-
-          return null;
-        });
-      },
-      exact: function (shapeTypes) {
-        return createChainableTypeChecker(function (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 = objectAssign({}, props[propName], shapeTypes);
-
-          for (var key in allKeys) {
-            var checker = shapeTypes[key];
-
-            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_1);
-
-            if (error) {
-              return error;
-            }
-          }
-
-          return null;
-        });
-      }
+      shape: createShapeTypeChecker,
+      exact: createStrictShapeTypeChecker
     };
     /**
      * inlined Object.is polyfill to avoid requiring consumers ship their own
@@ -969,8 +849,10 @@
     PropTypeError.prototype = Error.prototype;
 
     function createChainableTypeChecker(validate) {
-      var manualPropTypeCallCache = {};
-      var manualPropTypeWarningCount = 0;
+      {
+        var manualPropTypeCallCache = {};
+        var manualPropTypeWarningCount = 0;
+      }
 
       function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
         componentName = componentName || ANONYMOUS;
@@ -1016,7 +898,7 @@
     }
 
     function createPrimitiveTypeChecker(expectedType) {
-      return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
+      function validate(props, propName, componentName, location, propFullName, secret) {
         var propValue = props[propName];
         var propType = getPropType(propValue);
 
@@ -1029,21 +911,100 @@
         }
 
         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_1);
+
+          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 (arguments.length > 1) {
-          printWarning$1('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$1('Invalid argument supplied to oneOf, expected an array.');
+        {
+          if (arguments.length > 1) {
+            printWarning$1('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$1('Invalid argument supplied to oneOf, expected an array.');
+          }
         }
 
         return emptyFunctionThatReturnsNull;
       }
 
-      return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
+      function validate(props, propName, componentName, location, propFullName) {
         var propValue = props[propName];
 
         for (var i = 0; i < expectedValues.length; i++) {
@@ -1052,7 +1013,7 @@
           }
         }
 
-        var valuesString = JSON.stringify(expectedValues, function (key, value) {
+        var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
           var type = getPreciseType(value);
 
           if (type === 'symbol') {
@@ -1062,19 +1023,50 @@
           return value;
         });
         return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
-      });
-    }
-
-    function createUnionTypeChecker(arrayOfTypeCheckers) {
-      if (!Array.isArray(arrayOfTypeCheckers)) {
-        printWarning$1('Invalid argument supplied to oneOfType, expected an instance of array.');
-        return emptyFunctionThatReturnsNull;
       }
 
-      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
-        var checker = arrayOfTypeCheckers[i];
+      return createChainableTypeChecker(validate);
+    }
 
-        if (typeof checker !== 'function') {
+    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$1(propValue, key)) {
+            var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);
+
+            if (error instanceof Error) {
+              return error;
+            }
+          }
+        }
+
+        return null;
+      }
+
+      return createChainableTypeChecker(validate);
+    }
+
+    function createUnionTypeChecker(arrayOfTypeCheckers) {
+      if (!Array.isArray(arrayOfTypeCheckers)) {
+         printWarning$1('Invalid argument supplied to oneOfType, expected an instance of array.') ;
+        return emptyFunctionThatReturnsNull;
+      }
+
+      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+        var checker = arrayOfTypeCheckers[i];
+
+        if (typeof checker !== 'function') {
           printWarning$1('Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.');
           return emptyFunctionThatReturnsNull;
         }
@@ -1095,6 +1087,80 @@
       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 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 (!checker) {
+            continue;
+          }
+
+          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);
+
+          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 = objectAssign({}, props[propName], shapeTypes);
+
+        for (var key in allKeys) {
+          var checker = shapeTypes[key];
+
+          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_1);
+
+          if (error) {
+            return error;
+          }
+        }
+
+        return null;
+      }
+
+      return createChainableTypeChecker(validate);
+    }
+
     function isNode(propValue) {
       switch (typeof propValue) {
         case 'number':
@@ -1257,9 +1323,13 @@
      * This source code is licensed under the MIT license found in the
      * LICENSE file in the root directory of this source tree.
      */
-    // By explicitly using `prop-types` you are opting into new development behavior.
-    // http://fb.me/prop-types-in-prod
-    module.exports = factoryWithTypeCheckers(reactIs.isElement, true);
+    {
+      var ReactIs = reactIs; // By explicitly using `prop-types` you are opting into new development behavior.
+      // http://fb.me/prop-types-in-prod
+
+      var throwOnDirectAccess = true;
+      module.exports = factoryWithTypeCheckers(ReactIs.isElement, throwOnDirectAccess);
+    }
   });
 
   function isElement(el) {
@@ -1834,1051 +1904,1057 @@
 
   var Downshift =
   /*#__PURE__*/
-  function (_Component) {
-    _inheritsLoose(Downshift, _Component);
-
-    function Downshift(_props) {
-      var _this = _Component.call(this, _props) || this;
+  function () {
+    var Downshift =
+    /*#__PURE__*/
+    function (_Component) {
+      _inheritsLoose(Downshift, _Component);
+
+      function Downshift(_props) {
+        var _this = _Component.call(this, _props) || this;
+
+        _this.id = _this.props.id || "downshift-" + generateId();
+        _this.menuId = _this.props.menuId || _this.id + "-menu";
+        _this.labelId = _this.props.labelId || _this.id + "-label";
+        _this.inputId = _this.props.inputId || _this.id + "-input";
+
+        _this.getItemId = _this.props.getItemId || function (index) {
+          return _this.id + "-item-" + index;
+        };
 
-      _this.id = _this.props.id || "downshift-" + generateId();
-      _this.menuId = _this.props.menuId || _this.id + "-menu";
-      _this.labelId = _this.props.labelId || _this.id + "-label";
-      _this.inputId = _this.props.inputId || _this.id + "-input";
+        _this.input = null;
+        _this.items = [];
+        _this.itemCount = null;
+        _this.previousResultCount = 0;
+        _this.timeoutIds = [];
 
-      _this.getItemId = _this.props.getItemId || function (index) {
-        return _this.id + "-item-" + index;
-      };
+        _this.internalSetTimeout = function (fn, time) {
+          var id = setTimeout(function () {
+            _this.timeoutIds = _this.timeoutIds.filter(function (i) {
+              return i !== id;
+            });
+            fn();
+          }, time);
 
-      _this.input = null;
-      _this.items = [];
-      _this.itemCount = null;
-      _this.previousResultCount = 0;
-      _this.timeoutIds = [];
+          _this.timeoutIds.push(id);
+        };
 
-      _this.internalSetTimeout = function (fn, time) {
-        var id = setTimeout(function () {
-          _this.timeoutIds = _this.timeoutIds.filter(function (i) {
-            return i !== id;
-          });
-          fn();
-        }, time);
+        _this.setItemCount = function (count) {
+          _this.itemCount = count;
+        };
 
-        _this.timeoutIds.push(id);
-      };
+        _this.unsetItemCount = function () {
+          _this.itemCount = null;
+        };
 
-      _this.setItemCount = function (count) {
-        _this.itemCount = count;
-      };
+        _this.setHighlightedIndex = function (highlightedIndex, otherStateToSet) {
+          if (highlightedIndex === void 0) {
+            highlightedIndex = _this.props.defaultHighlightedIndex;
+          }
 
-      _this.unsetItemCount = function () {
-        _this.itemCount = null;
-      };
+          if (otherStateToSet === void 0) {
+            otherStateToSet = {};
+          }
 
-      _this.setHighlightedIndex = function (highlightedIndex, otherStateToSet) {
-        if (highlightedIndex === void 0) {
-          highlightedIndex = _this.props.defaultHighlightedIndex;
-        }
+          otherStateToSet = pickState(otherStateToSet);
 
-        if (otherStateToSet === void 0) {
-          otherStateToSet = {};
-        }
+          _this.internalSetState(_extends({
+            highlightedIndex: highlightedIndex
+          }, otherStateToSet));
+        };
 
-        otherStateToSet = pickState(otherStateToSet);
+        _this.clearSelection = function (cb) {
+          _this.internalSetState({
+            selectedItem: null,
+            inputValue: '',
+            highlightedIndex: _this.props.defaultHighlightedIndex,
+            isOpen: _this.props.defaultIsOpen
+          }, cb);
+        };
 
-        _this.internalSetState(_extends({
-          highlightedIndex: highlightedIndex
-        }, otherStateToSet));
-      };
+        _this.selectItem = function (item, otherStateToSet, cb) {
+          otherStateToSet = pickState(otherStateToSet);
 
-      _this.clearSelection = function (cb) {
-        _this.internalSetState({
-          selectedItem: null,
-          inputValue: '',
-          highlightedIndex: _this.props.defaultHighlightedIndex,
-          isOpen: _this.props.defaultIsOpen
-        }, cb);
-      };
+          _this.internalSetState(_extends({
+            isOpen: _this.props.defaultIsOpen,
+            highlightedIndex: _this.props.defaultHighlightedIndex,
+            selectedItem: item,
+            inputValue: _this.props.itemToString(item)
+          }, otherStateToSet), cb);
+        };
 
-      _this.selectItem = function (item, otherStateToSet, cb) {
-        otherStateToSet = pickState(otherStateToSet);
+        _this.selectItemAtIndex = function (itemIndex, otherStateToSet, cb) {
+          var item = _this.items[itemIndex];
 
-        _this.internalSetState(_extends({
-          isOpen: _this.props.defaultIsOpen,
-          highlightedIndex: _this.props.defaultHighlightedIndex,
-          selectedItem: item,
-          inputValue: _this.props.itemToString(item)
-        }, otherStateToSet), cb);
-      };
+          if (item == null) {
+            return;
+          }
 
-      _this.selectItemAtIndex = function (itemIndex, otherStateToSet, cb) {
-        var item = _this.items[itemIndex];
+          _this.selectItem(item, otherStateToSet, cb);
+        };
 
-        if (item == null) {
-          return;
-        }
+        _this.selectHighlightedItem = function (otherStateToSet, cb) {
+          return _this.selectItemAtIndex(_this.getState().highlightedIndex, otherStateToSet, cb);
+        };
 
-        _this.selectItem(item, otherStateToSet, cb);
-      };
+        _this.internalSetState = function (stateToSet, cb) {
+          var isItemSelected, onChangeArg;
+          var onStateChangeArg = {};
+          var isStateToSetFunction = typeof stateToSet === 'function'; // we want to call `onInputValueChange` before the `setState` call
+          // so someone controlling the `inputValue` state gets notified of
+          // the input change as soon as possible. This avoids issues with
+          // preserving the cursor position.
+          // See https://github.com/downshift-js/downshift/issues/217 for more info.
+
+          if (!isStateToSetFunction && stateToSet.hasOwnProperty('inputValue')) {
+            _this.props.onInputValueChange(stateToSet.inputValue, _extends({}, _this.getStateAndHelpers(), {}, stateToSet));
+          }
 
-      _this.selectHighlightedItem = function (otherStateToSet, cb) {
-        return _this.selectItemAtIndex(_this.getState().highlightedIndex, otherStateToSet, cb);
-      };
+          return _this.setState(function (state) {
+            state = _this.getState(state);
+            var newStateToSet = isStateToSetFunction ? stateToSet(state) : stateToSet; // Your own function that could modify the state that will be set.
 
-      _this.internalSetState = function (stateToSet, cb) {
-        var isItemSelected, onChangeArg;
-        var onStateChangeArg = {};
-        var isStateToSetFunction = typeof stateToSet === 'function'; // we want to call `onInputValueChange` before the `setState` call
-        // so someone controlling the `inputValue` state gets notified of
-        // the input change as soon as possible. This avoids issues with
-        // preserving the cursor position.
-        // See https://github.com/downshift-js/downshift/issues/217 for more info.
+            newStateToSet = _this.props.stateReducer(state, newStateToSet); // checks if an item is selected, regardless of if it's different from
+            // what was selected before
+            // used to determine if onSelect and onChange callbacks should be called
 
-        if (!isStateToSetFunction && stateToSet.hasOwnProperty('inputValue')) {
-          _this.props.onInputValueChange(stateToSet.inputValue, _extends({}, _this.getStateAndHelpers(), {}, stateToSet));
-        }
+            isItemSelected = newStateToSet.hasOwnProperty('selectedItem'); // this keeps track of the object we want to call with setState
 
-        return _this.setState(function (state) {
-          state = _this.getState(state);
-          var newStateToSet = isStateToSetFunction ? stateToSet(state) : stateToSet; // Your own function that could modify the state that will be set.
+            var nextState = {}; // this is just used to tell whether the state changed
 
-          newStateToSet = _this.props.stateReducer(state, newStateToSet); // checks if an item is selected, regardless of if it's different from
-          // what was selected before
-          // used to determine if onSelect and onChange callbacks should be called
+            var nextFullState = {}; // we need to call on change if the outside world is controlling any of our state
+            // and we're trying to update that state. OR if the selection has changed and we're
+            // trying to update the selection
 
-          isItemSelected = newStateToSet.hasOwnProperty('selectedItem'); // this keeps track of the object we want to call with setState
+            if (isItemSelected && newStateToSet.selectedItem !== state.selectedItem) {
+              onChangeArg = newStateToSet.selectedItem;
+            }
 
-          var nextState = {}; // this is just used to tell whether the state changed
+            newStateToSet.type = newStateToSet.type || unknown;
+            Object.keys(newStateToSet).forEach(function (key) {
+              // onStateChangeArg should only have the state that is
+              // actually changing
+              if (state[key] !== newStateToSet[key]) {
+                onStateChangeArg[key] = newStateToSet[key];
+              } // the type is useful for the onStateChangeArg
+              // but we don't actually want to set it in internal state.
+              // this is an undocumented feature for now... Not all internalSetState
+              // calls support it and I'm not certain we want them to yet.
+              // But it enables users controlling the isOpen state to know when
+              // the isOpen state changes due to mouseup events which is quite handy.
+
+
+              if (key === 'type') {
+                return;
+              }
 
-          var nextFullState = {}; // we need to call on change if the outside world is controlling any of our state
-          // and we're trying to update that state. OR if the selection has changed and we're
-          // trying to update the selection
+              nextFullState[key] = newStateToSet[key]; // if it's coming from props, then we don't care to set it internally
 
-          if (isItemSelected && newStateToSet.selectedItem !== state.selectedItem) {
-            onChangeArg = newStateToSet.selectedItem;
-          }
+              if (!_this.isControlledProp(key)) {
+                nextState[key] = newStateToSet[key];
+              }
+            }); // if stateToSet is a function, then we weren't able to call onInputValueChange
+            // earlier, so we'll call it now that we know what the inputValue state will be.
 
-          newStateToSet.type = newStateToSet.type || unknown;
-          Object.keys(newStateToSet).forEach(function (key) {
-            // onStateChangeArg should only have the state that is
-            // actually changing
-            if (state[key] !== newStateToSet[key]) {
-              onStateChangeArg[key] = newStateToSet[key];
-            } // the type is useful for the onStateChangeArg
-            // but we don't actually want to set it in internal state.
-            // this is an undocumented feature for now... Not all internalSetState
-            // calls support it and I'm not certain we want them to yet.
-            // But it enables users controlling the isOpen state to know when
-            // the isOpen state changes due to mouseup events which is quite handy.
-
-
-            if (key === 'type') {
-              return;
+            if (isStateToSetFunction && newStateToSet.hasOwnProperty('inputValue')) {
+              _this.props.onInputValueChange(newStateToSet.inputValue, _extends({}, _this.getStateAndHelpers(), {}, newStateToSet));
             }
 
-            nextFullState[key] = newStateToSet[key]; // if it's coming from props, then we don't care to set it internally
+            return nextState;
+          }, function () {
+            // call the provided callback if it's a function
+            cbToCb(cb)(); // only call the onStateChange and onChange callbacks if
+            // we have relevant information to pass them.
 
-            if (!_this.isControlledProp(key)) {
-              nextState[key] = newStateToSet[key];
-            }
-          }); // if stateToSet is a function, then we weren't able to call onInputValueChange
-          // earlier, so we'll call it now that we know what the inputValue state will be.
+            var hasMoreStateThanType = Object.keys(onStateChangeArg).length > 1;
 
-          if (isStateToSetFunction && newStateToSet.hasOwnProperty('inputValue')) {
-            _this.props.onInputValueChange(newStateToSet.inputValue, _extends({}, _this.getStateAndHelpers(), {}, newStateToSet));
-          }
+            if (hasMoreStateThanType) {
+              _this.props.onStateChange(onStateChangeArg, _this.getStateAndHelpers());
+            }
 
-          return nextState;
-        }, function () {
-          // call the provided callback if it's a function
-          cbToCb(cb)(); // only call the onStateChange and onChange callbacks if
-          // we have relevant information to pass them.
+            if (isItemSelected) {
+              _this.props.onSelect(stateToSet.selectedItem, _this.getStateAndHelpers());
+            }
 
-          var hasMoreStateThanType = Object.keys(onStateChangeArg).length > 1;
+            if (onChangeArg !== undefined) {
+              _this.props.onChange(onChangeArg, _this.getStateAndHelpers());
+            } // this is currently undocumented and therefore subject to change
+            // We'll try to not break it, but just be warned.
 
-          if (hasMoreStateThanType) {
-            _this.props.onStateChange(onStateChangeArg, _this.getStateAndHelpers());
-          }
 
-          if (isItemSelected) {
-            _this.props.onSelect(stateToSet.selectedItem, _this.getStateAndHelpers());
-          }
+            _this.props.onUserAction(onStateChangeArg, _this.getStateAndHelpers());
+          });
+        };
 
-          if (onChangeArg !== undefined) {
-            _this.props.onChange(onChangeArg, _this.getStateAndHelpers());
-          } // this is currently undocumented and therefore subject to change
-          // We'll try to not break it, but just be warned.
+        _this.rootRef = function (node) {
+          return _this._rootNode = node;
+        };
 
+        _this.getRootProps = function (_temp, _temp2) {
+          var _extends2;
 
-          _this.props.onUserAction(onStateChangeArg, _this.getStateAndHelpers());
-        });
-      };
+          var _ref = _temp === void 0 ? {} : _temp,
+              _ref$refKey = _ref.refKey,
+              refKey = _ref$refKey === void 0 ? 'ref' : _ref$refKey,
+              ref = _ref.ref,
+              rest = _objectWithoutPropertiesLoose(_ref, ["refKey", "ref"]);
 
-      _this.rootRef = function (node) {
-        return _this._rootNode = node;
-      };
+          var _ref2 = _temp2 === void 0 ? {} : _temp2,
+              _ref2$suppressRefErro = _ref2.suppressRefError,
+              suppressRefError = _ref2$suppressRefErro === void 0 ? false : _ref2$suppressRefErro;
 
-      _this.getRootProps = function (_temp, _temp2) {
-        var _extends2;
+          // this is used in the render to know whether the user has called getRootProps.
+          // It uses that to know whether to apply the props automatically
+          _this.getRootProps.called = true;
+          _this.getRootProps.refKey = refKey;
+          _this.getRootProps.suppressRefError = suppressRefError;
 
-        var _ref = _temp === void 0 ? {} : _temp,
-            _ref$refKey = _ref.refKey,
-            refKey = _ref$refKey === void 0 ? 'ref' : _ref$refKey,
-            ref = _ref.ref,
-            rest = _objectWithoutPropertiesLoose(_ref, ["refKey", "ref"]);
+          var _this$getState = _this.getState(),
+              isOpen = _this$getState.isOpen;
 
-        var _ref2 = _temp2 === void 0 ? {} : _temp2,
-            _ref2$suppressRefErro = _ref2.suppressRefError,
-            suppressRefError = _ref2$suppressRefErro === void 0 ? false : _ref2$suppressRefErro;
+          return _extends((_extends2 = {}, _extends2[refKey] = handleRefs(ref, _this.rootRef), _extends2.role = 'combobox', _extends2['aria-expanded'] = isOpen, _extends2['aria-haspopup'] = 'listbox', _extends2['aria-owns'] = isOpen ? _this.menuId : null, _extends2['aria-labelledby'] = _this.labelId, _extends2), rest);
+        };
 
-        // this is used in the render to know whether the user has called getRootProps.
-        // It uses that to know whether to apply the props automatically
-        _this.getRootProps.called = true;
-        _this.getRootProps.refKey = refKey;
-        _this.getRootProps.suppressRefError = suppressRefError;
+        _this.keyDownHandlers = {
+          ArrowDown: function ArrowDown(event) {
+            var _this2 = this;
 
-        var _this$getState = _this.getState(),
-            isOpen = _this$getState.isOpen;
+            event.preventDefault();
 
-        return _extends((_extends2 = {}, _extends2[refKey] = handleRefs(ref, _this.rootRef), _extends2.role = 'combobox', _extends2['aria-expanded'] = isOpen, _extends2['aria-haspopup'] = 'listbox', _extends2['aria-owns'] = isOpen ? _this.menuId : null, _extends2['aria-labelledby'] = _this.labelId, _extends2), rest);
-      };
+            if (this.getState().isOpen) {
+              var amount = event.shiftKey ? 5 : 1;
+              this.moveHighlightedIndex(amount, {
+                type: keyDownArrowDown
+              });
+            } else {
+              this.internalSetState({
+                isOpen: true,
+                type: keyDownArrowDown
+              }, function () {
+                var itemCount = _this2.getItemCount();
+
+                if (itemCount > 0) {
+                  _this2.setHighlightedIndex(getNextWrappingIndex(1, _this2.getState().highlightedIndex, itemCount), {
+                    type: keyDownArrowDown
+                  });
+                }
+              });
+            }
+          },
+          ArrowUp: function ArrowUp(event) {
+            var _this3 = this;
 
-      _this.keyDownHandlers = {
-        ArrowDown: function ArrowDown(event) {
-          var _this2 = this;
+            event.preventDefault();
 
-          event.preventDefault();
+            if (this.getState().isOpen) {
+              var amount = event.shiftKey ? -5 : -1;
+              this.moveHighlightedIndex(amount, {
+                type: keyDownArrowUp
+              });
+            } else {
+              this.internalSetState({
+                isOpen: true,
+                type: keyDownArrowUp
+              }, function () {
+                var itemCount = _this3.getItemCount();
+
+                if (itemCount > 0) {
+                  _this3.setHighlightedIndex(getNextWrappingIndex(-1, _this3.getState().highlightedIndex, itemCount), {
+                    type: keyDownArrowDown
+                  });
+                }
+              });
+            }
+          },
+          Enter: function Enter(event) {
+            var _this$getState2 = this.getState(),
+                isOpen = _this$getState2.isOpen,
+                highlightedIndex = _this$getState2.highlightedIndex;
+
+            if (isOpen && highlightedIndex != null) {
+              event.preventDefault();
+              var item = this.items[highlightedIndex];
+              var itemNode = this.getItemNodeFromIndex(highlightedIndex);
+
+              if (item == null || itemNode && itemNode.hasAttribute('disabled')) {
+                return;
+              }
 
-          if (this.getState().isOpen) {
-            var amount = event.shiftKey ? 5 : 1;
-            this.moveHighlightedIndex(amount, {
-              type: keyDownArrowDown
+              this.selectHighlightedItem({
+                type: keyDownEnter
+              });
+            }
+          },
+          Escape: function Escape(event) {
+            event.preventDefault();
+            this.reset({
+              type: keyDownEscape,
+              selectedItem: null,
+              inputValue: ''
             });
-          } else {
-            this.internalSetState({
-              isOpen: true,
-              type: keyDownArrowDown
-            }, function () {
-              var itemCount = _this2.getItemCount();
-
-              if (itemCount > 0) {
-                _this2.setHighlightedIndex(getNextWrappingIndex(1, _this2.getState().highlightedIndex, itemCount), {
-                  type: keyDownArrowDown
-                });
-              }
+          }
+        };
+        _this.buttonKeyDownHandlers = _extends({}, _this.keyDownHandlers, {
+          ' ': function _(event) {
+            event.preventDefault();
+            this.toggleMenu({
+              type: keyDownSpaceButton
+            });
+          }
+        });
+        _this.inputKeyDownHandlers = _extends({}, _this.keyDownHandlers, {
+          Home: function Home(event) {
+            this.highlightFirstOrLastIndex(event, true, {
+              type: keyDownHome
+            });
+          },
+          End: function End(event) {
+            this.highlightFirstOrLastIndex(event, false, {
+              type: keyDownEnd
             });
           }
-        },
-        ArrowUp: function ArrowUp(event) {
-          var _this3 = this;
+        });
 
+        _this.getToggleButtonProps = function (_temp3) {
+          var _ref3 = _temp3 === void 0 ? {} : _temp3,
+              onClick = _ref3.onClick,
+              onPress = _ref3.onPress,
+              onKeyDown = _ref3.onKeyDown,
+              onKeyUp = _ref3.onKeyUp,
+              onBlur = _ref3.onBlur,
+              rest = _objectWithoutPropertiesLoose(_ref3, ["onClick", "onPress", "onKeyDown", "onKeyUp", "onBlur"]);
+
+          var _this$getState3 = _this.getState(),
+              isOpen = _this$getState3.isOpen;
+
+          var enabledEventHandlers = {
+            onClick: callAllEventHandlers(onClick, _this.buttonHandleClick),
+            onKeyDown: callAllEventHandlers(onKeyDown, _this.buttonHandleKeyDown),
+            onKeyUp: callAllEventHandlers(onKeyUp, _this.buttonHandleKeyUp),
+            onBlur: callAllEventHandlers(onBlur, _this.buttonHandleBlur)
+          };
+          var eventHandlers = rest.disabled ? {} : enabledEventHandlers;
+          return _extends({
+            type: 'button',
+            role: 'button',
+            'aria-label': isOpen ? 'close menu' : 'open menu',
+            'aria-haspopup': true,
+            'data-toggle': true
+          }, eventHandlers, {}, rest);
+        };
+
+        _this.buttonHandleKeyUp = function (event) {
+          // Prevent click event from emitting in Firefox
           event.preventDefault();
+        };
 
-          if (this.getState().isOpen) {
-            var amount = event.shiftKey ? -5 : -1;
-            this.moveHighlightedIndex(amount, {
-              type: keyDownArrowUp
-            });
-          } else {
-            this.internalSetState({
-              isOpen: true,
-              type: keyDownArrowUp
-            }, function () {
-              var itemCount = _this3.getItemCount();
-
-              if (itemCount > 0) {
-                _this3.setHighlightedIndex(getNextWrappingIndex(-1, _this3.getState().highlightedIndex, itemCount), {
-                  type: keyDownArrowDown
-                });
-              }
-            });
+        _this.buttonHandleKeyDown = function (event) {
+          var key = normalizeArrowKey(event);
+
+          if (_this.buttonKeyDownHandlers[key]) {
+            _this.buttonKeyDownHandlers[key].call(_assertThisInitialized(_this), event);
           }
-        },
-        Enter: function Enter(event) {
-          var _this$getState2 = this.getState(),
-              isOpen = _this$getState2.isOpen,
-              highlightedIndex = _this$getState2.highlightedIndex;
+        };
 
-          if (isOpen && highlightedIndex != null) {
-            event.preventDefault();
-            var item = this.items[highlightedIndex];
-            var itemNode = this.getItemNodeFromIndex(highlightedIndex);
+        _this.buttonHandleClick = function (event) {
+          event.preventDefault(); // handle odd case for Safari and Firefox which
+          // don't give the button the focus properly.
 
-            if (item == null || itemNode && itemNode.hasAttribute('disabled')) {
-              return;
-            }
+          /* istanbul ignore if (can't reasonably test this) */
+
+          if ( _this.props.environment.document.activeElement === _this.props.environment.document.body) {
+            event.target.focus();
+          } // to simplify testing components that use downshift, we'll not wrap this in a setTimeout
+          // if the NODE_ENV is test. With the proper build system, this should be dead code eliminated
+          // when building for production and should therefore have no impact on production code.
 
-            this.selectHighlightedItem({
-              type: keyDownEnter
+
+          // Ensure that toggle of menu occurs after the potential blur event in iOS
+          _this.internalSetTimeout(function () {
+            return _this.toggleMenu({
+              type: clickButton
             });
-          }
-        },
-        Escape: function Escape(event) {
-          event.preventDefault();
-          this.reset({
-            type: keyDownEscape,
-            selectedItem: null,
-            inputValue: ''
-          });
-        }
-      };
-      _this.buttonKeyDownHandlers = _extends({}, _this.keyDownHandlers, {
-        ' ': function _(event) {
-          event.preventDefault();
-          this.toggleMenu({
-            type: keyDownSpaceButton
-          });
-        }
-      });
-      _this.inputKeyDownHandlers = _extends({}, _this.keyDownHandlers, {
-        Home: function Home(event) {
-          this.highlightFirstOrLastIndex(event, true, {
-            type: keyDownHome
           });
-        },
-        End: function End(event) {
-          this.highlightFirstOrLastIndex(event, false, {
-            type: keyDownEnd
+        };
+
+        _this.buttonHandleBlur = function (event) {
+          var blurTarget = event.target; // Save blur target for comparison with activeElement later
+          // Need setTimeout, so that when the user presses Tab, the activeElement is the next focused element, not body element
+
+          _this.internalSetTimeout(function () {
+            if (!_this.isMouseDown && (_this.props.environment.document.activeElement == null || _this.props.environment.document.activeElement.id !== _this.inputId) && _this.props.environment.document.activeElement !== blurTarget // Do nothing if we refocus the same element again (to solve issue in Safari on iOS)
+            ) {
+                _this.reset({
+                  type: blurButton
+                });
+              }
           });
-        }
-      });
+        };
 
-      _this.getToggleButtonProps = function (_temp3) {
-        var _ref3 = _temp3 === void 0 ? {} : _temp3,
-            onClick = _ref3.onClick,
-            onPress = _ref3.onPress,
-            onKeyDown = _ref3.onKeyDown,
-            onKeyUp = _ref3.onKeyUp,
-            onBlur = _ref3.onBlur,
-            rest = _objectWithoutPropertiesLoose(_ref3, ["onClick", "onPress", "onKeyDown", "onKeyUp", "onBlur"]);
-
-        var _this$getState3 = _this.getState(),
-            isOpen = _this$getState3.isOpen;
-
-        var enabledEventHandlers = {
-          onClick: callAllEventHandlers(onClick, _this.buttonHandleClick),
-          onKeyDown: callAllEventHandlers(onKeyDown, _this.buttonHandleKeyDown),
-          onKeyUp: callAllEventHandlers(onKeyUp, _this.buttonHandleKeyUp),
-          onBlur: callAllEventHandlers(onBlur, _this.buttonHandleBlur)
+        _this.getLabelProps = function (props) {
+          return _extends({
+            htmlFor: _this.inputId,
+            id: _this.labelId
+          }, props);
         };
-        var eventHandlers = rest.disabled ? {} : enabledEventHandlers;
-        return _extends({
-          type: 'button',
-          role: 'button',
-          'aria-label': isOpen ? 'close menu' : 'open menu',
-          'aria-haspopup': true,
-          'data-toggle': true
-        }, eventHandlers, {}, rest);
-      };
 
-      _this.buttonHandleKeyUp = function (event) {
-        // Prevent click event from emitting in Firefox
-        event.preventDefault();
-      };
+        _this.getInputProps = function (_temp4) {
+          var _ref4 = _temp4 === void 0 ? {} : _temp4,
+              onKeyDown = _ref4.onKeyDown,
+              onBlur = _ref4.onBlur,
+              onChange = _ref4.onChange,
+              onInput = _ref4.onInput,
+              onChangeText = _ref4.onChangeText,
+              rest = _objectWithoutPropertiesLoose(_ref4, ["onKeyDown", "onBlur", "onChange", "onInput", "onChangeText"]);
 
-      _this.buttonHandleKeyDown = function (event) {
-        var key = normalizeArrowKey(event);
+          var onChangeKey;
+          var eventHandlers = {};
+          /* istanbul ignore next (preact) */
 
-        if (_this.buttonKeyDownHandlers[key]) {
-          _this.buttonKeyDownHandlers[key].call(_assertThisInitialized(_this), event);
-        }
-      };
+          onChangeKey = 'onChange';
 
-      _this.buttonHandleClick = function (event) {
-        event.preventDefault(); // handle odd case for Safari and Firefox which
-        // don't give the button the focus properly.
+          var _this$getState4 = _this.getState(),
+              inputValue = _this$getState4.inputValue,
+              isOpen = _this$getState4.isOpen,
+              highlightedIndex = _this$getState4.highlightedIndex;
 
-        /* istanbul ignore if (can't reasonably test this) */
+          if (!rest.disabled) {
+            var _eventHandlers;
 
-        if ( _this.props.environment.document.activeElement === _this.props.environment.document.body) {
-          event.target.focus();
-        } // to simplify testing components that use downshift, we'll not wrap this in a setTimeout
-        // if the NODE_ENV is test. With the proper build system, this should be dead code eliminated
-        // when building for production and should therefore have no impact on production code.
+            eventHandlers = (_eventHandlers = {}, _eventHandlers[onChangeKey] = callAllEventHandlers(onChange, onInput, _this.inputHandleChange), _eventHandlers.onKeyDown = callAllEventHandlers(onKeyDown, _this.inputHandleKeyDown), _eventHandlers.onBlur = callAllEventHandlers(onBlur, _this.inputHandleBlur), _eventHandlers);
+          }
+          /* istanbul ignore if (react-native) */
 
 
-        // Ensure that toggle of menu occurs after the potential blur event in iOS
-        _this.internalSetTimeout(function () {
-          return _this.toggleMenu({
-            type: clickButton
+          return _extends({
+            'aria-autocomplete': 'list',
+            'aria-activedescendant': isOpen && typeof highlightedIndex === 'number' && highlightedIndex >= 0 ? _this.getItemId(highlightedIndex) : null,
+            'aria-controls': isOpen ? _this.menuId : null,
+            'aria-labelledby': _this.labelId,
+            // https://developer.mozilla.org/en-US/docs/Web/Security/Securing_your_site/Turning_off_form_autocompletion
+            // revert back since autocomplete="nope" is ignored on latest Chrome and Opera
+            autoComplete: 'off',
+            value: inputValue,
+            id: _this.inputId
+          }, eventHandlers, {}, rest);
+        };
+
+        _this.inputHandleKeyDown = function (event) {
+          var key = normalizeArrowKey(event);
+
+          if (key && _this.inputKeyDownHandlers[key]) {
+            _this.inputKeyDownHandlers[key].call(_assertThisInitialized(_this), event);
+          }
+        };
+
+        _this.inputHandleChange = function (event) {
+          _this.internalSetState({
+            type: changeInput,
+            isOpen: true,
+            inputValue: event.target.value,
+            highlightedIndex: _this.props.defaultHighlightedIndex
           });
-        });
-      };
+        };
 
-      _this.buttonHandleBlur = function (event) {
-        var blurTarget = event.target; // Save blur target for comparison with activeElement later
-        // Need setTimeout, so that when the user presses Tab, the activeElement is the next focused element, not body element
+        _this.inputHandleBlur = function () {
+          // Need setTimeout, so that when the user presses Tab, the activeElement is the next focused element, not the body element
+          _this.internalSetTimeout(function () {
+            var downshiftButtonIsActive = _this.props.environment.document && !!_this.props.environment.document.activeElement && !!_this.props.environment.document.activeElement.dataset && _this.props.environment.document.activeElement.dataset.toggle && _this._rootNode && _this._rootNode.contains(_this.props.environment.document.activeElement);
 
-        _this.internalSetTimeout(function () {
-          if (!_this.isMouseDown && (_this.props.environment.document.activeElement == null || _this.props.environment.document.activeElement.id !== _this.inputId) && _this.props.environment.document.activeElement !== blurTarget // Do nothing if we refocus the same element again (to solve issue in Safari on iOS)
-          ) {
+            if (!_this.isMouseDown && !downshiftButtonIsActive) {
               _this.reset({
-                type: blurButton
+                type: blurInput
               });
             }
-        });
-      };
+          });
+        };
 
-      _this.getLabelProps = function (props) {
-        return _extends({
-          htmlFor: _this.inputId,
-          id: _this.labelId
-        }, props);
-      };
+        _this.menuRef = function (node) {
+          _this._menuNode = node;
+        };
 
-      _this.getInputProps = function (_temp4) {
-        var _ref4 = _temp4 === void 0 ? {} : _temp4,
-            onKeyDown = _ref4.onKeyDown,
-            onBlur = _ref4.onBlur,
-            onChange = _ref4.onChange,
-            onInput = _ref4.onInput,
-            onChangeText = _ref4.onChangeText,
-            rest = _objectWithoutPropertiesLoose(_ref4, ["onKeyDown", "onBlur", "onChange", "onInput", "onChangeText"]);
+        _this.getMenuProps = function (_temp5, _temp6) {
+          var _extends3;
 
-        var onChangeKey;
-        var eventHandlers = {};
-        /* istanbul ignore next (preact) */
+          var _ref5 = _temp5 === void 0 ? {} : _temp5,
+              _ref5$refKey = _ref5.refKey,
+              refKey = _ref5$refKey === void 0 ? 'ref' : _ref5$refKey,
+              ref = _ref5.ref,
+              props = _objectWithoutPropertiesLoose(_ref5, ["refKey", "ref"]);
 
-        onChangeKey = 'onChange';
+          var _ref6 = _temp6 === void 0 ? {} : _temp6,
+              _ref6$suppressRefErro = _ref6.suppressRefError,
+              suppressRefError = _ref6$suppressRefErro === void 0 ? false : _ref6$suppressRefErro;
 
-        var _this$getState4 = _this.getState(),
-            inputValue = _this$getState4.inputValue,
-            isOpen = _this$getState4.isOpen,
-            highlightedIndex = _this$getState4.highlightedIndex;
+          _this.getMenuProps.called = true;
+          _this.getMenuProps.refKey = refKey;
+          _this.getMenuProps.suppressRefError = suppressRefError;
+          return _extends((_extends3 = {}, _extends3[refKey] = handleRefs(ref, _this.menuRef), _extends3.role = 'listbox', _extends3['aria-labelledby'] = props && props['aria-label'] ? null : _this.labelId, _extends3.id = _this.menuId, _extends3), props);
+        };
 
-        if (!rest.disabled) {
-          var _eventHandlers;
+        _this.getItemProps = function (_temp7) {
+          var _enabledEventHandlers;
 
-          eventHandlers = (_eventHandlers = {}, _eventHandlers[onChangeKey] = callAllEventHandlers(onChange, onInput, _this.inputHandleChange), _eventHandlers.onKeyDown = callAllEventHandlers(onKeyDown, _this.inputHandleKeyDown), _eventHandlers.onBlur = callAllEventHandlers(onBlur, _this.inputHandleBlur), _eventHandlers);
-        }
-        /* istanbul ignore if (react-native) */
+          var _ref7 = _temp7 === void 0 ? {} : _temp7,
+              onMouseMove = _ref7.onMouseMove,
+              onMouseDown = _ref7.onMouseDown,
+              onClick = _ref7.onClick,
+              onPress = _ref7.onPress,
+              index = _ref7.index,
+              _ref7$item = _ref7.item,
+              item = _ref7$item === void 0 ? requiredProp('getItemProps', 'item') : _ref7$item,
+              rest = _objectWithoutPropertiesLoose(_ref7, ["onMouseMove", "onMouseDown", "onClick", "onPress", "index", "item"]);
 
+          if (index === undefined) {
+            _this.items.push(item);
 
-        return _extends({
-          'aria-autocomplete': 'list',
-          'aria-activedescendant': isOpen && typeof highlightedIndex === 'number' && highlightedIndex >= 0 ? _this.getItemId(highlightedIndex) : null,
-          'aria-controls': isOpen ? _this.menuId : null,
-          'aria-labelledby': _this.labelId,
-          // https://developer.mozilla.org/en-US/docs/Web/Security/Securing_your_site/Turning_off_form_autocompletion
-          // revert back since autocomplete="nope" is ignored on latest Chrome and Opera
-          autoComplete: 'off',
-          value: inputValue,
-          id: _this.inputId
-        }, eventHandlers, {}, rest);
-      };
+            index = _this.items.indexOf(item);
+          } else {
+            _this.items[index] = item;
+          }
 
-      _this.inputHandleKeyDown = function (event) {
-        var key = normalizeArrowKey(event);
+          var onSelectKey = 'onClick';
+          var customClickHandler = onClick;
+          var enabledEventHandlers = (_enabledEventHandlers = {
+            // onMouseMove is used over onMouseEnter here. onMouseMove
+            // is only triggered on actual mouse movement while onMouseEnter
+            // can fire on DOM changes, interrupting keyboard navigation
+            onMouseMove: callAllEventHandlers(onMouseMove, function () {
+              if (index === _this.getState().highlightedIndex) {
+                return;
+              }
 
-        if (key && _this.inputKeyDownHandlers[key]) {
-          _this.inputKeyDownHandlers[key].call(_assertThisInitialized(_this), event);
-        }
-      };
+              _this.setHighlightedIndex(index, {
+                type: itemMouseEnter
+              }); // We never want to manually scroll when changing state based
+              // on `onMouseMove` because we will be moving the element out
+              // from under the user which is currently scrolling/moving the
+              // cursor
+
+
+              _this.avoidScrolling = true;
+
+              _this.internalSetTimeout(function () {
+                return _this.avoidScrolling = false;
+              }, 250);
+            }),
+            onMouseDown: callAllEventHandlers(onMouseDown, function (event) {
+              // This prevents the activeElement from being changed
+              // to the item so it can remain with the current activeElement
+              // which is a more common use case.
+              event.preventDefault();
+            })
+          }, _enabledEventHandlers[onSelectKey] = callAllEventHandlers(customClickHandler, function () {
+            _this.selectItemAtIndex(index, {
+              type: clickItem
+            });
+          }), _enabledEventHandlers); // Passing down the onMouseDown handler to prevent redirect
+          // of the activeElement if clicking on disabled items
 
-      _this.inputHandleChange = function (event) {
-        _this.internalSetState({
-          type: changeInput,
-          isOpen: true,
-          inputValue: event.target.value,
-          highlightedIndex: _this.props.defaultHighlightedIndex
-        });
-      };
+          var eventHandlers = rest.disabled ? {
+            onMouseDown: enabledEventHandlers.onMouseDown
+          } : enabledEventHandlers;
+          return _extends({
+            id: _this.getItemId(index),
+            role: 'option',
+            'aria-selected': _this.getState().highlightedIndex === index
+          }, eventHandlers, {}, rest);
+        };
 
-      _this.inputHandleBlur = function () {
-        // Need setTimeout, so that when the user presses Tab, the activeElement is the next focused element, not the body element
-        _this.internalSetTimeout(function () {
-          var downshiftButtonIsActive = _this.props.environment.document && !!_this.props.environment.document.activeElement && !!_this.props.environment.document.activeElement.dataset && _this.props.environment.document.activeElement.dataset.toggle && _this._rootNode && _this._rootNode.contains(_this.props.environment.document.activeElement);
+        _this.clearItems = function () {
+          _this.items = [];
+        };
 
-          if (!_this.isMouseDown && !downshiftButtonIsActive) {
-            _this.reset({
-              type: blurInput
-            });
+        _this.reset = function (otherStateToSet, cb) {
+          if (otherStateToSet === void 0) {
+            otherStateToSet = {};
           }
-        });
-      };
 
-      _this.menuRef = function (node) {
-        _this._menuNode = node;
-      };
+          otherStateToSet = pickState(otherStateToSet);
 
-      _this.getMenuProps = function (_temp5, _temp6) {
-        var _extends3;
-
-        var _ref5 = _temp5 === void 0 ? {} : _temp5,
-            _ref5$refKey = _ref5.refKey,
-            refKey = _ref5$refKey === void 0 ? 'ref' : _ref5$refKey,
-            ref = _ref5.ref,
-            props = _objectWithoutPropertiesLoose(_ref5, ["refKey", "ref"]);
-
-        var _ref6 = _temp6 === void 0 ? {} : _temp6,
-            _ref6$suppressRefErro = _ref6.suppressRefError,
-            suppressRefError = _ref6$suppressRefErro === void 0 ? false : _ref6$suppressRefErro;
+          _this.internalSetState(function (_ref8) {
+            var selectedItem = _ref8.selectedItem;
+            return _extends({
+              isOpen: _this.props.defaultIsOpen,
+              highlightedIndex: _this.props.defaultHighlightedIndex,
+              inputValue: _this.props.itemToString(selectedItem)
+            }, otherStateToSet);
+          }, cb);
+        };
 
-        _this.getMenuProps.called = true;
-        _this.getMenuProps.refKey = refKey;
-        _this.getMenuProps.suppressRefError = suppressRefError;
-        return _extends((_extends3 = {}, _extends3[refKey] = handleRefs(ref, _this.menuRef), _extends3.role = 'listbox', _extends3['aria-labelledby'] = props && props['aria-label'] ? null : _this.labelId, _extends3.id = _this.menuId, _extends3), props);
-      };
+        _this.toggleMenu = function (otherStateToSet, cb) {
+          if (otherStateToSet === void 0) {
+            otherStateToSet = {};
+          }
 
-      _this.getItemProps = function (_temp7) {
-        var _enabledEventHandlers;
+          otherStateToSet = pickState(otherStateToSet);
+
+          _this.internalSetState(function (_ref9) {
+            var isOpen = _ref9.isOpen;
+            return _extends({
+              isOpen: !isOpen
+            }, isOpen && {
+              highlightedIndex: _this.props.defaultHighlightedIndex
+            }, {}, otherStateToSet);
+          }, function () {
+            var _this$getState5 = _this.getState(),
+                isOpen = _this$getState5.isOpen,
+                highlightedIndex = _this$getState5.highlightedIndex;
+
+            if (isOpen) {
+              if (_this.getItemCount() > 0 && typeof highlightedIndex === 'number') {
+                _this.setHighlightedIndex(highlightedIndex, otherStateToSet);
+              }
+            }
 
-        var _ref7 = _temp7 === void 0 ? {} : _temp7,
-            onMouseMove = _ref7.onMouseMove,
-            onMouseDown = _ref7.onMouseDown,
-            onClick = _ref7.onClick,
-            onPress = _ref7.onPress,
-            index = _ref7.index,
-            _ref7$item = _ref7.item,
-            item = _ref7$item === void 0 ? requiredProp('getItemProps', 'item') : _ref7$item,
-            rest = _objectWithoutPropertiesLoose(_ref7, ["onMouseMove", "onMouseDown", "onClick", "onPress", "index", "item"]);
+            cbToCb(cb)();
+          });
+        };
 
-        if (index === undefined) {
-          _this.items.push(item);
+        _this.openMenu = function (cb) {
+          _this.internalSetState({
+            isOpen: true
+          }, cb);
+        };
 
-          index = _this.items.indexOf(item);
-        } else {
-          _this.items[index] = item;
-        }
-
-        var onSelectKey = 'onClick';
-        var customClickHandler = onClick;
-        var enabledEventHandlers = (_enabledEventHandlers = {
-          // onMouseMove is used over onMouseEnter here. onMouseMove
-          // is only triggered on actual mouse movement while onMouseEnter
-          // can fire on DOM changes, interrupting keyboard navigation
-          onMouseMove: callAllEventHandlers(onMouseMove, function () {
-            if (index === _this.getState().highlightedIndex) {
-              return;
-            }
+        _this.closeMenu = function (cb) {
+          _this.internalSetState({
+            isOpen: false
+          }, cb);
+        };
 
-            _this.setHighlightedIndex(index, {
-              type: itemMouseEnter
-            }); // We never want to manually scroll when changing state based
-            // on `onMouseMove` because we will be moving the element out
-            // from under the user which is currently scrolling/moving the
-            // cursor
+        _this.updateStatus = debounce(function () {
+          var state = _this.getState();
+
+          var item = _this.items[state.highlightedIndex];
+
+          var resultCount = _this.getItemCount();
+
+          var status = _this.props.getA11yStatusMessage(_extends({
+            itemToString: _this.props.itemToString,
+            previousResultCount: _this.previousResultCount,
+            resultCount: resultCount,
+            highlightedItem: item
+          }, state));
+
+          _this.previousResultCount = resultCount;
+          setStatus(status, _this.props.environment.document);
+        }, 200);
+
+        // fancy destructuring + defaults + aliases
+        // this basically says each value of state should either be set to
+        // the initial value or the default value if the initial value is not provided
+        var _this$props = _this.props,
+            defaultHighlightedIndex = _this$props.defaultHighlightedIndex,
+            _this$props$initialHi = _this$props.initialHighlightedIndex,
+            _highlightedIndex = _this$props$initialHi === void 0 ? defaultHighlightedIndex : _this$props$initialHi,
+            defaultIsOpen = _this$props.defaultIsOpen,
+            _this$props$initialIs = _this$props.initialIsOpen,
+            _isOpen = _this$props$initialIs === void 0 ? defaultIsOpen : _this$props$initialIs,
+            _this$props$initialIn = _this$props.initialInputValue,
+            _inputValue = _this$props$initialIn === void 0 ? '' : _this$props$initialIn,
+            _this$props$initialSe = _this$props.initialSelectedItem,
+            _selectedItem = _this$props$initialSe === void 0 ? null : _this$props$initialSe;
+
+        var _state = _this.getState({
+          highlightedIndex: _highlightedIndex,
+          isOpen: _isOpen,
+          inputValue: _inputValue,
+          selectedItem: _selectedItem
+        });
 
+        if (_state.selectedItem != null && _this.props.initialInputValue === undefined) {
+          _state.inputValue = _this.props.itemToString(_state.selectedItem);
+        }
 
-            _this.avoidScrolling = true;
+        _this.state = _state;
+        return _this;
+      }
 
-            _this.internalSetTimeout(function () {
-              return _this.avoidScrolling = false;
-            }, 250);
-          }),
-          onMouseDown: callAllEventHandlers(onMouseDown, function (event) {
-            // This prevents the activeElement from being changed
-            // to the item so it can remain with the current activeElement
-            // which is a more common use case.
-            event.preventDefault();
-          })
-        }, _enabledEventHandlers[onSelectKey] = callAllEventHandlers(customClickHandler, function () {
-          _this.selectItemAtIndex(index, {
-            type: clickItem
-          });
-        }), _enabledEventHandlers); // Passing down the onMouseDown handler to prevent redirect
-        // of the activeElement if clicking on disabled items
+      var _proto = Downshift.prototype;
 
-        var eventHandlers = rest.disabled ? {
-          onMouseDown: enabledEventHandlers.onMouseDown
-        } : enabledEventHandlers;
-        return _extends({
-          id: _this.getItemId(index),
-          role: 'option',
-          'aria-selected': _this.getState().highlightedIndex === index
-        }, eventHandlers, {}, rest);
-      };
+      /**
+       * Clear all running timeouts
+       */
+      _proto.internalClearTimeouts = function internalClearTimeouts() {
+        this.timeoutIds.forEach(function (id) {
+          clearTimeout(id);
+        });
+        this.timeoutIds = [];
+      }
+      /**
+       * Gets the state based on internal state or props
+       * If a state value is passed via props, then that
+       * is the value given, otherwise it's retrieved from
+       * stateToMerge
+       *
+       * This will perform a shallow merge of the given state object
+       * with the state coming from props
+       * (for the controlled component scenario)
+       * This is used in state updater functions so they're referencing
+       * the right state regardless of where it comes from.
+       *
+       * @param {Object} stateToMerge defaults to this.state
+       * @return {Object} the state
+       */
+      ;
 
-      _this.clearItems = function () {
-        _this.items = [];
-      };
+      _proto.getState = function getState(stateToMerge) {
+        var _this4 = this;
 
-      _this.reset = function (otherStateToSet, cb) {
-        if (otherStateToSet === void 0) {
-          otherStateToSet = {};
+        if (stateToMerge === void 0) {
+          stateToMerge = this.state;
         }
 
-        otherStateToSet = pickState(otherStateToSet);
+        return Object.keys(stateToMerge).reduce(function (state, key) {
+          state[key] = _this4.isControlledProp(key) ? _this4.props[key] : stateToMerge[key];
+          return state;
+        }, {});
+      }
+      /**
+       * This determines whether a prop is a "controlled prop" meaning it is
+       * state which is controlled by the outside of this component rather
+       * than within this component.
+       * @param {String} key the key to check
+       * @return {Boolean} whether it is a controlled controlled prop
+       */
+      ;
 
-        _this.internalSetState(function (_ref8) {
-          var selectedItem = _ref8.selectedItem;
-          return _extends({
-            isOpen: _this.props.defaultIsOpen,
-            highlightedIndex: _this.props.defaultHighlightedIndex,
-            inputValue: _this.props.itemToString(selectedItem)
-          }, otherStateToSet);
-        }, cb);
+      _proto.isControlledProp = function isControlledProp(key) {
+        return this.props[key] !== undefined;
       };
 
-      _this.toggleMenu = function (otherStateToSet, cb) {
-        if (otherStateToSet === void 0) {
-          otherStateToSet = {};
+      _proto.getItemCount = function getItemCount() {
+        // things read better this way. They're in priority order:
+        // 1. `this.itemCount`
+        // 2. `this.props.itemCount`
+        // 3. `this.items.length`
+        var itemCount = this.items.length;
+
+        if (this.itemCount != null) {
+          itemCount = this.itemCount;
+        } else if (this.props.itemCount !== undefined) {
+          itemCount = this.props.itemCount;
         }
 
-        otherStateToSet = pickState(otherStateToSet);
-
-        _this.internalSetState(function (_ref9) {
-          var isOpen = _ref9.isOpen;
-          return _extends({
-            isOpen: !isOpen
-          }, isOpen && {
-            highlightedIndex: _this.props.defaultHighlightedIndex
-          }, {}, otherStateToSet);
-        }, function () {
-          var _this$getState5 = _this.getState(),
-              isOpen = _this$getState5.isOpen,
-              highlightedIndex = _this$getState5.highlightedIndex;
-
-          if (isOpen) {
-            if (_this.getItemCount() > 0 && typeof highlightedIndex === 'number') {
-              _this.setHighlightedIndex(highlightedIndex, otherStateToSet);
-            }
-          }
-
-          cbToCb(cb)();
-        });
+        return itemCount;
       };
 
-      _this.openMenu = function (cb) {
-        _this.internalSetState({
-          isOpen: true
-        }, cb);
+      _proto.getItemNodeFromIndex = function getItemNodeFromIndex(index) {
+        return this.props.environment.document.getElementById(this.getItemId(index));
       };
 
-      _this.closeMenu = function (cb) {
-        _this.internalSetState({
-          isOpen: false
-        }, cb);
+      _proto.scrollHighlightedItemIntoView = function scrollHighlightedItemIntoView() {
+        /* istanbul ignore else (react-native) */
+        {
+          var node = this.getItemNodeFromIndex(this.getState().highlightedIndex);
+          this.props.scrollIntoView(node, this._menuNode);
+        }
       };
 
-      _this.updateStatus = debounce(function () {
-        var state = _this.getState();
-
-        var item = _this.items[state.highlightedIndex];
-
-        var resultCount = _this.getItemCount();
-
-        var status = _this.props.getA11yStatusMessage(_extends({
-          itemToString: _this.props.itemToString,
-          previousResultCount: _this.previousResultCount,
-          resultCount: resultCount,
-          highlightedItem: item
-        }, state));
-
-        _this.previousResultCount = resultCount;
-        setStatus(status, _this.props.environment.document);
-      }, 200);
-
-      // fancy destructuring + defaults + aliases
-      // this basically says each value of state should either be set to
-      // the initial value or the default value if the initial value is not provided
-      var _this$props = _this.props,
-          defaultHighlightedIndex = _this$props.defaultHighlightedIndex,
-          _this$props$initialHi = _this$props.initialHighlightedIndex,
-          _highlightedIndex = _this$props$initialHi === void 0 ? defaultHighlightedIndex : _this$props$initialHi,
-          defaultIsOpen = _this$props.defaultIsOpen,
-          _this$props$initialIs = _this$props.initialIsOpen,
-          _isOpen = _this$props$initialIs === void 0 ? defaultIsOpen : _this$props$initialIs,
-          _this$props$initialIn = _this$props.initialInputValue,
-          _inputValue = _this$props$initialIn === void 0 ? '' : _this$props$initialIn,
-          _this$props$initialSe = _this$props.initialSelectedItem,
-          _selectedItem = _this$props$initialSe === void 0 ? null : _this$props$initialSe;
-
-      var _state = _this.getState({
-        highlightedIndex: _highlightedIndex,
-        isOpen: _isOpen,
-        inputValue: _inputValue,
-        selectedItem: _selectedItem
-      });
-
-      if (_state.selectedItem != null && _this.props.initialInputValue === undefined) {
-        _state.inputValue = _this.props.itemToString(_state.selectedItem);
-      }
-
-      _this.state = _state;
-      return _this;
-    }
-
-    var _proto = Downshift.prototype;
-
-    /**
-     * Clear all running timeouts
-     */
-    _proto.internalClearTimeouts = function internalClearTimeouts() {
-      this.timeoutIds.forEach(function (id) {
-        clearTimeout(id);
-      });
-      this.timeoutIds = [];
-    }
-    /**
-     * Gets the state based on internal state or props
-     * If a state value is passed via props, then that
-     * is the value given, otherwise it's retrieved from
-     * stateToMerge
-     *
-     * This will perform a shallow merge of the given state object
-     * with the state coming from props
-     * (for the controlled component scenario)
-     * This is used in state updater functions so they're referencing
-     * the right state regardless of where it comes from.
-     *
-     * @param {Object} stateToMerge defaults to this.state
-     * @return {Object} the state
-     */
-    ;
-
-    _proto.getState = function getState(stateToMerge) {
-      var _this4 = this;
-
-      if (stateToMerge === void 0) {
-        stateToMerge = this.state;
-      }
-
-      return Object.keys(stateToMerge).reduce(function (state, key) {
-        state[key] = _this4.isControlledProp(key) ? _this4.props[key] : stateToMerge[key];
-        return state;
-      }, {});
-    }
-    /**
-     * This determines whether a prop is a "controlled prop" meaning it is
-     * state which is controlled by the outside of this component rather
-     * than within this component.
-     * @param {String} key the key to check
-     * @return {Boolean} whether it is a controlled controlled prop
-     */
-    ;
-
-    _proto.isControlledProp = function isControlledProp(key) {
-      return this.props[key] !== undefined;
-    };
+      _proto.moveHighlightedIndex = function moveHighlightedIndex(amount, otherStateToSet) {
+        var itemCount = this.getItemCount();
 
-    _proto.getItemCount = function getItemCount() {
-      // things read better this way. They're in priority order:
-      // 1. `this.itemCount`
-      // 2. `this.props.itemCount`
-      // 3. `this.items.length`
-      var itemCount = this.items.length;
-
-      if (this.itemCount != null) {
-        itemCount = this.itemCount;
-      } else if (this.props.itemCount !== undefined) {
-        itemCount = this.props.itemCount;
-      }
+        if (itemCount > 0) {
+          var nextHighlightedIndex = getNextWrappingIndex(amount, this.getState().highlightedIndex, itemCount);
+          this.setHighlightedIndex(nextHighlightedIndex, otherStateToSet);
+        }
+      };
 
-      return itemCount;
-    };
+      _proto.highlightFirstOrLastIndex = function highlightFirstOrLastIndex(event, first, otherStateToSet) {
+        var itemsLastIndex = this.getItemCount() - 1;
 
-    _proto.getItemNodeFromIndex = function getItemNodeFromIndex(index) {
-      return this.props.environment.document.getElementById(this.getItemId(index));
-    };
+        if (itemsLastIndex < 0 || !this.getState().isOpen) {
+          return;
+        }
 
-    _proto.scrollHighlightedItemIntoView = function scrollHighlightedItemIntoView() {
-      /* istanbul ignore else (react-native) */
-      {
-        var node = this.getItemNodeFromIndex(this.getState().highlightedIndex);
-        this.props.scrollIntoView(node, this._menuNode);
-      }
-    };
+        event.preventDefault();
+        this.setHighlightedIndex(first ? 0 : itemsLastIndex, otherStateToSet);
+      };
 
-    _proto.moveHighlightedIndex = function moveHighlightedIndex(amount, otherStateToSet) {
-      var itemCount = this.getItemCount();
+      _proto.getStateAndHelpers = function getStateAndHelpers() {
+        var _this$getState6 = this.getState(),
+            highlightedIndex = _this$getState6.highlightedIndex,
+            inputValue = _this$getState6.inputValue,
+            selectedItem = _this$getState6.selectedItem,
+            isOpen = _this$getState6.isOpen;
+
+        var itemToString = this.props.itemToString;
+        var id = this.id;
+        var getRootProps = this.getRootProps,
+            getToggleButtonProps = this.getToggleButtonProps,
+            getLabelProps = this.getLabelProps,
+            getMenuProps = this.getMenuProps,
+            getInputProps = this.getInputProps,
+            getItemProps = this.getItemProps,
+            openMenu = this.openMenu,
+            closeMenu = this.closeMenu,
+            toggleMenu = this.toggleMenu,
+            selectItem = this.selectItem,
+            selectItemAtIndex = this.selectItemAtIndex,
+            selectHighlightedItem = this.selectHighlightedItem,
+            setHighlightedIndex = this.setHighlightedIndex,
+            clearSelection = this.clearSelection,
+            clearItems = this.clearItems,
+            reset = this.reset,
+            setItemCount = this.setItemCount,
+            unsetItemCount = this.unsetItemCount,
+            setState = this.internalSetState;
+        return {
+          // prop getters
+          getRootProps: getRootProps,
+          getToggleButtonProps: getToggleButtonProps,
+          getLabelProps: getLabelProps,
+          getMenuProps: getMenuProps,
+          getInputProps: getInputProps,
+          getItemProps: getItemProps,
+          // actions
+          reset: reset,
+          openMenu: openMenu,
+          closeMenu: closeMenu,
+          toggleMenu: toggleMenu,
+          selectItem: selectItem,
+          selectItemAtIndex: selectItemAtIndex,
+          selectHighlightedItem: selectHighlightedItem,
+          setHighlightedIndex: setHighlightedIndex,
+          clearSelection: clearSelection,
+          clearItems: clearItems,
+          setItemCount: setItemCount,
+          unsetItemCount: unsetItemCount,
+          setState: setState,
+          // props
+          itemToString: itemToString,
+          // derived
+          id: id,
+          // state
+          highlightedIndex: highlightedIndex,
+          inputValue: inputValue,
+          isOpen: isOpen,
+          selectedItem: selectedItem
+        };
+      } //////////////////////////// ROOT
+      ;
 
-      if (itemCount > 0) {
-        var nextHighlightedIndex = getNextWrappingIndex(amount, this.getState().highlightedIndex, itemCount);
-        this.setHighlightedIndex(nextHighlightedIndex, otherStateToSet);
-      }
-    };
+      _proto.componentDidMount = function componentDidMount() {
+        var _this5 = this;
 
-    _proto.highlightFirstOrLastIndex = function highlightFirstOrLastIndex(event, first, otherStateToSet) {
-      var itemsLastIndex = this.getItemCount() - 1;
+        /* istanbul ignore if (react-native) */
+        if ( this.getMenuProps.called && !this.getMenuProps.suppressRefError) {
+          validateGetMenuPropsCalledCorrectly(this._menuNode, this.getMenuProps);
+        }
+        /* istanbul ignore if (react-native) */
 
-      if (itemsLastIndex < 0 || !this.getState().isOpen) {
-        return;
-      }
 
-      event.preventDefault();
-      this.setHighlightedIndex(first ? 0 : itemsLastIndex, otherStateToSet);
-    };
+        {
+          var targetWithinDownshift = function (target, checkActiveElement) {
+            if (checkActiveElement === void 0) {
+              checkActiveElement = true;
+            }
 
-    _proto.getStateAndHelpers = function getStateAndHelpers() {
-      var _this$getState6 = this.getState(),
-          highlightedIndex = _this$getState6.highlightedIndex,
-          inputValue = _this$getState6.inputValue,
-          selectedItem = _this$getState6.selectedItem,
-          isOpen = _this$getState6.isOpen;
-
-      var itemToString = this.props.itemToString;
-      var id = this.id;
-      var getRootProps = this.getRootProps,
-          getToggleButtonProps = this.getToggleButtonProps,
-          getLabelProps = this.getLabelProps,
-          getMenuProps = this.getMenuProps,
-          getInputProps = this.getInputProps,
-          getItemProps = this.getItemProps,
-          openMenu = this.openMenu,
-          closeMenu = this.closeMenu,
-          toggleMenu = this.toggleMenu,
-          selectItem = this.selectItem,
-          selectItemAtIndex = this.selectItemAtIndex,
-          selectHighlightedItem = this.selectHighlightedItem,
-          setHighlightedIndex = this.setHighlightedIndex,
-          clearSelection = this.clearSelection,
-          clearItems = this.clearItems,
-          reset = this.reset,
-          setItemCount = this.setItemCount,
-          unsetItemCount = this.unsetItemCount,
-          setState = this.internalSetState;
-      return {
-        // prop getters
-        getRootProps: getRootProps,
-        getToggleButtonProps: getToggleButtonProps,
-        getLabelProps: getLabelProps,
-        getMenuProps: getMenuProps,
-        getInputProps: getInputProps,
-        getItemProps: getItemProps,
-        // actions
-        reset: reset,
-        openMenu: openMenu,
-        closeMenu: closeMenu,
-        toggleMenu: toggleMenu,
-        selectItem: selectItem,
-        selectItemAtIndex: selectItemAtIndex,
-        selectHighlightedItem: selectHighlightedItem,
-        setHighlightedIndex: setHighlightedIndex,
-        clearSelection: clearSelection,
-        clearItems: clearItems,
-        setItemCount: setItemCount,
-        unsetItemCount: unsetItemCount,
-        setState: setState,
-        // props
-        itemToString: itemToString,
-        // derived
-        id: id,
-        // state
-        highlightedIndex: highlightedIndex,
-        inputValue: inputValue,
-        isOpen: isOpen,
-        selectedItem: selectedItem
-      };
-    } //////////////////////////// ROOT
-    ;
+            var document = _this5.props.environment.document;
+            return [_this5._rootNode, _this5._menuNode].some(function (contextNode) {
+              return contextNode && (isOrContainsNode(contextNode, target) || checkActiveElement && isOrContainsNode(contextNode, document.activeElement));
+            });
+          }; // this.isMouseDown helps us track whether the mouse is currently held down.
+          // This is useful when the user clicks on an item in the list, but holds the mouse
+          // down long enough for the list to disappear (because the blur event fires on the input)
+          // this.isMouseDown is used in the blur handler on the input to determine whether the blur event should
+          // trigger hiding the menu.
 
-    _proto.componentDidMount = function componentDidMount() {
-      var _this5 = this;
 
-      /* istanbul ignore if (react-native) */
-      if ( this.getMenuProps.called && !this.getMenuProps.suppressRefError) {
-        validateGetMenuPropsCalledCorrectly(this._menuNode, this.getMenuProps);
-      }
-      /* istanbul ignore if (react-native) */
+          var onMouseDown = function () {
+            _this5.isMouseDown = true;
+          };
 
+          var onMouseUp = function (event) {
+            _this5.isMouseDown = false; // if the target element or the activeElement is within a downshift node
+            // then we don't want to reset downshift
 
-      {
-        var targetWithinDownshift = function (target, checkActiveElement) {
-          if (checkActiveElement === void 0) {
-            checkActiveElement = true;
-          }
+            var contextWithinDownshift = targetWithinDownshift(event.target);
 
-          var document = _this5.props.environment.document;
-          return [_this5._rootNode, _this5._menuNode].some(function (contextNode) {
-            return contextNode && (isOrContainsNode(contextNode, target) || checkActiveElement && isOrContainsNode(contextNode, document.activeElement));
-          });
-        }; // this.isMouseDown helps us track whether the mouse is currently held down.
-        // This is useful when the user clicks on an item in the list, but holds the mouse
-        // down long enough for the list to disappear (because the blur event fires on the input)
-        // this.isMouseDown is used in the blur handler on the input to determine whether the blur event should
-        // trigger hiding the menu.
+            if (!contextWithinDownshift && _this5.getState().isOpen) {
+              _this5.reset({
+                type: mouseUp
+              }, function () {
+                return _this5.props.onOuterClick(_this5.getStateAndHelpers());
+              });
+            }
+          }; // Touching an element in iOS gives focus and hover states, but touching out of
+          // the element will remove hover, and persist the focus state, resulting in the
+          // blur event not being triggered.
+          // this.isTouchMove helps us track whether the user is tapping or swiping on a touch screen.
+          // If the user taps outside of Downshift, the component should be reset,
+          // but not if the user is swiping
 
 
-        var onMouseDown = function () {
-          _this5.isMouseDown = true;
-        };
+          var onTouchStart = function () {
+            _this5.isTouchMove = false;
+          };
 
-        var onMouseUp = function (event) {
-          _this5.isMouseDown = false; // if the target element or the activeElement is within a downshift node
-          // then we don't want to reset downshift
+          var onTouchMove = function () {
+            _this5.isTouchMove = true;
+          };
 
-          var contextWithinDownshift = targetWithinDownshift(event.target);
+          var onTouchEnd = function (event) {
+            var contextWithinDownshift = targetWithinDownshift(event.target, false);
 
-          if (!contextWithinDownshift && _this5.getState().isOpen) {
-            _this5.reset({
-              type: mouseUp
-            }, function () {
-              return _this5.props.onOuterClick(_this5.getStateAndHelpers());
-            });
-          }
-        }; // Touching an element in iOS gives focus and hover states, but touching out of
-        // the element will remove hover, and persist the focus state, resulting in the
-        // blur event not being triggered.
-        // this.isTouchMove helps us track whether the user is tapping or swiping on a touch screen.
-        // If the user taps outside of Downshift, the component should be reset,
-        // but not if the user is swiping
+            if (!_this5.isTouchMove && !contextWithinDownshift && _this5.getState().isOpen) {
+              _this5.reset({
+                type: touchEnd
+              }, function () {
+                return _this5.props.onOuterClick(_this5.getStateAndHelpers());
+              });
+            }
+          };
 
+          var environment = this.props.environment;
+          environment.addEventListener('mousedown', onMouseDown);
+          environment.addEventListener('mouseup', onMouseUp);
+          environment.addEventListener('touchstart', onTouchStart);
+          environment.addEventListener('touchmove', onTouchMove);
+          environment.addEventListener('touchend', onTouchEnd);
 
-        var onTouchStart = function () {
-          _this5.isTouchMove = false;
-        };
+          this.cleanup = function () {
+            _this5.internalClearTimeouts();
 
-        var onTouchMove = function () {
-          _this5.isTouchMove = true;
-        };
+            _this5.updateStatus.cancel();
 
-        var onTouchEnd = function (event) {
-          var contextWithinDownshift = targetWithinDownshift(event.target, false);
+            environment.removeEventListener('mousedown', onMouseDown);
+            environment.removeEventListener('mouseup', onMouseUp);
+            environment.removeEventListener('touchstart', onTouchStart);
+            environment.removeEventListener('touchmove', onTouchMove);
+            environment.removeEventListener('touchend', onTouchEnd);
+          };
+        }
+      };
 
-          if (!_this5.isTouchMove && !contextWithinDownshift && _this5.getState().isOpen) {
-            _this5.reset({
-              type: touchEnd
-            }, function () {
-              return _this5.props.onOuterClick(_this5.getStateAndHelpers());
-            });
-          }
-        };
+      _proto.shouldScroll = function shouldScroll(prevState, prevProps) {
+        var _ref10 = this.props.highlightedIndex === undefined ? this.getState() : this.props,
+            currentHighlightedIndex = _ref10.highlightedIndex;
 
-        var environment = this.props.environment;
-        environment.addEventListener('mousedown', onMouseDown);
-        environment.addEventListener('mouseup', onMouseUp);
-        environment.addEventListener('touchstart', onTouchStart);
-        environment.addEventListener('touchmove', onTouchMove);
-        environment.addEventListener('touchend', onTouchEnd);
+        var _ref11 = prevProps.highlightedIndex === undefined ? prevState : prevProps,
+            prevHighlightedIndex = _ref11.highlightedIndex;
 
-        this.cleanup = function () {
-          _this5.internalClearTimeouts();
+        var scrollWhenOpen = currentHighlightedIndex && this.getState().isOpen && !prevState.isOpen;
+        return scrollWhenOpen || currentHighlightedIndex !== prevHighlightedIndex;
+      };
 
-          _this5.updateStatus.cancel();
+      _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
+        validateControlledUnchanged(prevProps, this.props);
+        /* istanbul ignore if (react-native) */
 
-          environment.removeEventListener('mousedown', onMouseDown);
-          environment.removeEventListener('mouseup', onMouseUp);
-          environment.removeEventListener('touchstart', onTouchStart);
-          environment.removeEventListener('touchmove', onTouchMove);
-          environment.removeEventListener('touchend', onTouchEnd);
-        };
-      }
-    };
+        if ( this.getMenuProps.called && !this.getMenuProps.suppressRefError) {
+          validateGetMenuPropsCalledCorrectly(this._menuNode, this.getMenuProps);
+        }
 
-    _proto.shouldScroll = function shouldScroll(prevState, prevProps) {
-      var _ref10 = this.props.highlightedIndex === undefined ? this.getState() : this.props,
-          currentHighlightedIndex = _ref10.highlightedIndex;
+        if (this.isControlledProp('selectedItem') && this.props.selectedItemChanged(prevProps.selectedItem, this.props.selectedItem)) {
+          this.internalSetState({
+            type: controlledPropUpdatedSelectedItem,
+            inputValue: this.props.itemToString(this.props.selectedItem)
+          });
+        }
 
-      var _ref11 = prevProps.highlightedIndex === undefined ? prevState : prevProps,
-          prevHighlightedIndex = _ref11.highlightedIndex;
+        if (!this.avoidScrolling && this.shouldScroll(prevState, prevProps)) {
+          this.scrollHighlightedItemIntoView();
+        }
+        /* istanbul ignore else (react-native) */
 
-      var scrollWhenOpen = currentHighlightedIndex && this.getState().isOpen && !prevState.isOpen;
-      return scrollWhenOpen || currentHighlightedIndex !== prevHighlightedIndex;
-    };
 
-    _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
-      validateControlledUnchanged(prevProps, this.props);
-      /* istanbul ignore if (react-native) */
+        this.updateStatus();
+      };
 
-      if ( this.getMenuProps.called && !this.getMenuProps.suppressRefError) {
-        validateGetMenuPropsCalledCorrectly(this._menuNode, this.getMenuProps);
-      }
+      _proto.componentWillUnmount = function componentWillUnmount() {
+        this.cleanup(); // avoids memory leak
+      };
 
-      if (this.isControlledProp('selectedItem') && this.props.selectedItemChanged(prevProps.selectedItem, this.props.selectedItem)) {
-        this.internalSetState({
-          type: controlledPropUpdatedSelectedItem,
-          inputValue: this.props.itemToString(this.props.selectedItem)
-        });
-      }
+      _proto.render = function render() {
+        var children = unwrapArray(this.props.children, noop); // because the items are rerendered every time we call the children
+        // we clear this out each render and it will be populated again as
+        // getItemProps is called.
 
-      if (!this.avoidScrolling && this.shouldScroll(prevState, prevProps)) {
-        this.scrollHighlightedItemIntoView();
-      }
-      /* istanbul ignore else (react-native) */
+        this.clearItems(); // we reset this so we know whether the user calls getRootProps during
+        // this render. If they do then we don't need to do anything,
+        // if they don't then we need to clone the element they return and
+        // apply the props for them.
 
+        this.getRootProps.called = false;
+        this.getRootProps.refKey = undefined;
+        this.getRootProps.suppressRefError = undefined; // we do something similar for getMenuProps
 
-      this.updateStatus();
-    };
+        this.getMenuProps.called = false;
+        this.getMenuProps.refKey = undefined;
+        this.getMenuProps.suppressRefError = undefined; // we do something similar for getLabelProps
 
-    _proto.componentWillUnmount = function componentWillUnmount() {
-      this.cleanup(); // avoids memory leak
-    };
+        this.getLabelProps.called = false; // and something similar for getInputProps
 
-    _proto.render = function render() {
-      var children = unwrapArray(this.props.children, noop); // because the items are rerendered every time we call the children
-      // we clear this out each render and it will be populated again as
-      // getItemProps is called.
+        this.getInputProps.called = false;
+        var element = unwrapArray(children(this.getStateAndHelpers()));
 
-      this.clearItems(); // we reset this so we know whether the user calls getRootProps during
-      // this render. If they do then we don't need to do anything,
-      // if they don't then we need to clone the element they return and
-      // apply the props for them.
+        if (!element) {
+          return null;
+        }
 
-      this.getRootProps.called = false;
-      this.getRootProps.refKey = undefined;
-      this.getRootProps.suppressRefError = undefined; // we do something similar for getMenuProps
+        if (this.getRootProps.called || this.props.suppressRefError) {
+          if ( !this.getRootProps.suppressRefError && !this.props.suppressRefError) {
+            validateGetRootPropsCalledCorrectly(element, this.getRootProps);
+          }
 
-      this.getMenuProps.called = false;
-      this.getMenuProps.refKey = undefined;
-      this.getMenuProps.suppressRefError = undefined; // we do something similar for getLabelProps
+          return element;
+        } else if (isDOMElement(element)) {
+          // they didn't apply the root props, but we can clone
+          // this and apply the props ourselves
+          return react.cloneElement(element, this.getRootProps(getElementProps(element)));
+        }
+        /* istanbul ignore else */
 
-      this.getLabelProps.called = false; // and something similar for getInputProps
 
-      this.getInputProps.called = false;
-      var element = unwrapArray(children(this.getStateAndHelpers()));
+        // they didn't apply the root props, but they need to
+        // otherwise we can't query around the autocomplete
+        throw new Error('downshift: If you return a non-DOM element, you must apply the getRootProps function');
+        /* istanbul ignore next */
+      };
 
-      if (!element) {
-        return null;
-      }
+      return Downshift;
+    }(react.Component);
 
-      if (this.getRootProps.called || this.props.suppressRefError) {
-        if ( !this.getRootProps.suppressRefError && !this.props.suppressRefError) {
-          validateGetRootPropsCalledCorrectly(element, this.getRootProps);
+    Downshift.defaultProps = {
+      defaultHighlightedIndex: null,
+      defaultIsOpen: false,
+      getA11yStatusMessage: getA11yStatusMessage,
+      itemToString: function itemToString(i) {
+        if (i == null) {
+          return '';
         }
 
-        return element;
-      } else if (isDOMElement(element)) {
-        // they didn't apply the root props, but we can clone
-        // this and apply the props ourselves
-        return react.cloneElement(element, this.getRootProps(getElementProps(element)));
-      }
-      /* istanbul ignore else */
-
+        if ( isPlainObject(i) && !i.hasOwnProperty('toString')) {
+          // eslint-disable-next-line no-console
+          console.warn('downshift: An object was passed to the default implementation of `itemToString`. You should probably provide your own `itemToString` implementation. Please refer to the `itemToString` API documentation.', 'The object that was passed:', i);
+        }
 
-      // they didn't apply the root props, but they need to
-      // otherwise we can't query around the autocomplete
-      throw new Error('downshift: If you return a non-DOM element, you must apply the getRootProps function');
-      /* istanbul ignore next */
+        return String(i);
+      },
+      onStateChange: noop,
+      onInputValueChange: noop,
+      onUserAction: noop,
+      onChange: noop,
+      onSelect: noop,
+      onOuterClick: noop,
+      selectedItemChanged: function selectedItemChanged(prevItem, item) {
+        return prevItem !== item;
+      },
+      environment: typeof window === 'undefined'
+      /* istanbul ignore next (ssr) */
+      ? {} : window,
+      stateReducer: function stateReducer(state, stateToSet) {
+        return stateToSet;
+      },
+      suppressRefError: false,
+      scrollIntoView: scrollIntoView
     };
-
+    Downshift.stateChangeTypes = stateChangeTypes;
     return Downshift;
-  }(react.Component);
-
-  Downshift.defaultProps = {
-    defaultHighlightedIndex: null,
-    defaultIsOpen: false,
-    getA11yStatusMessage: getA11yStatusMessage,
-    itemToString: function itemToString(i) {
-      if (i == null) {
-        return '';
-      }
-
-      if ( isPlainObject(i) && !i.hasOwnProperty('toString')) {
-        // eslint-disable-next-line no-console
-        console.warn('downshift: An object was passed to the default implementation of `itemToString`. You should probably provide your own `itemToString` implementation. Please refer to the `itemToString` API documentation.', 'The object that was passed:', i);
-      }
+  }();
 
-      return String(i);
-    },
-    onStateChange: noop,
-    onInputValueChange: noop,
-    onUserAction: noop,
-    onChange: noop,
-    onSelect: noop,
-    onOuterClick: noop,
-    selectedItemChanged: function selectedItemChanged(prevItem, item) {
-      return prevItem !== item;
-    },
-    environment: typeof window === 'undefined'
-    /* istanbul ignore next (ssr) */
-    ? {} : window,
-    stateReducer: function stateReducer(state, stateToSet) {
-      return stateToSet;
-    },
-    suppressRefError: false,
-    scrollIntoView: scrollIntoView
-  };
-  Downshift.stateChangeTypes = stateChangeTypes;
   Downshift.propTypes = {
     children: propTypes.func,
     defaultHighlightedIndex: propTypes.number,
@@ -3522,6 +3598,7 @@
       userProps = {};
     }
 
+    /* istanbul ignore else */
     validatePropTypes(userProps); // Props defaults and destructuring.
 
     var props = _extends({}, defaultProps, {}, userProps);