text: (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('popper.js')) :
  	typeof define === 'function' && define.amd ? define(['exports', 'react', 'popper.js'], factory) :
  	(factory((global.ReactPopper = {}),global.React,global.Popper));
  }(this, (function (exports,React,PopperJS) { 'use strict';
  
  	var React__default = 'default' in React ? React['default'] : React;
  	PopperJS = PopperJS && PopperJS.hasOwnProperty('default') ? PopperJS['default'] : PopperJS;
  
  	var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
  	function unwrapExports (x) {
  		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
  	}
  
  	function createCommonjsModule(fn, module) {
  		return module = { exports: {} }, fn(module, module.exports), module.exports;
  	}
  
  	/**
  	 * 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.
  	 *
  	 * 
  	 */
  
  	function makeEmptyFunction(arg) {
  	  return function () {
  	    return arg;
  	  };
  	}
  
  	/**
  	 * This function accepts and discards inputs; it has no side effects. This is
  	 * primarily useful idiomatically for overridable function endpoints which
  	 * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
  	 */
  	var emptyFunction = function emptyFunction() {};
  
  	emptyFunction.thatReturns = makeEmptyFunction;
  	emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
  	emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
  	emptyFunction.thatReturnsNull = makeEmptyFunction(null);
  	emptyFunction.thatReturnsThis = function () {
  	  return this;
  	};
  	emptyFunction.thatReturnsArgument = function (arg) {
  	  return arg;
  	};
  
  	var emptyFunction_1 = emptyFunction;
  
  	/**
  	 * 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.
  	 *
  	 */
  
  	/**
  	 * Use invariant() to assert state which your program assumes to be true.
  	 *
  	 * Provide sprintf-style format (only %s is supported) and arguments
  	 * to provide information about what broke and what you were
  	 * expecting.
  	 *
  	 * The invariant message will be stripped in production, but the invariant
  	 * will remain to ensure logic does not differ in production.
  	 */
  
  	var validateFormat = function validateFormat(format) {};
  
  	{
  	  validateFormat = function validateFormat(format) {
  	    if (format === undefined) {
  	      throw new Error('invariant requires an error message argument');
  	    }
  	  };
  	}
  
  	function invariant(condition, format, a, b, c, d, e, f) {
  	  validateFormat(format);
  
  	  if (!condition) {
  	    var error;
  	    if (format === undefined) {
  	      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
  	    } else {
  	      var args = [a, b, c, d, e, f];
  	      var argIndex = 0;
  	      error = new Error(format.replace(/%s/g, function () {
  	        return args[argIndex++];
  	      }));
  	      error.name = 'Invariant Violation';
  	    }
  
  	    error.framesToPop = 1; // we don't care about invariant's own frame
  	    throw error;
  	  }
  	}
  
  	var invariant_1 = invariant;
  
  	/**
  	 * 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 warning = emptyFunction_1;
  
  	{
  	  var printWarning = function printWarning(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++];
  	    });
  	    if (typeof console !== 'undefined') {
  	      console.error(message);
  	    }
  	    try {
  	      // --- Welcome to debugging React ---
  	      // This error was thrown as a convenience so that you can use this stack
  	      // to find the callsite that caused this warning to fire.
  	      throw new Error(message);
  	    } catch (x) {}
  	  };
  
  	  warning = function warning(condition, format) {
  	    if (format === undefined) {
  	      throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
  	    }
  
  	    if (format.indexOf('Failed Composite propType: ') === 0) {
  	      return; // Ignore CompositeComponent proptype check.
  	    }
  
  	    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 warning_1 = warning;
  
  	/*
  	object-assign
  	(c) Sindre Sorhus
  	@license MIT
  	*/
  	/* eslint-disable no-unused-vars */
  	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  	var hasOwnProperty = Object.prototype.hasOwnProperty;
  	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
  
  	function toObject(val) {
  		if (val === null || val === undefined) {
  			throw new TypeError('Object.assign cannot be called with null or undefined');
  		}
  
  		return Object(val);
  	}
  
  	function shouldUseNative() {
  		try {
  			if (!Object.assign) {
  				return false;
  			}
  
  			// Detect buggy property enumeration order in older V8 versions.
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
  			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
  			test1[5] = 'de';
  			if (Object.getOwnPropertyNames(test1)[0] === '5') {
  				return false;
  			}
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  			var test2 = {};
  			for (var i = 0; i < 10; i++) {
  				test2['_' + String.fromCharCode(i)] = i;
  			}
  			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
  				return test2[n];
  			});
  			if (order2.join('') !== '0123456789') {
  				return false;
  			}
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  			var test3 = {};
  			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
  				test3[letter] = letter;
  			});
  			if (Object.keys(Object.assign({}, test3)).join('') !==
  					'abcdefghijklmnopqrst') {
  				return false;
  			}
  
  			return true;
  		} catch (err) {
  			// We don't expect any of the above to throw, but better to be safe.
  			return false;
  		}
  	}
  
  	var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
  		var from;
  		var to = toObject(target);
  		var symbols;
  
  		for (var s = 1; s < arguments.length; s++) {
  			from = Object(arguments[s]);
  
  			for (var key in from) {
  				if (hasOwnProperty.call(from, key)) {
  					to[key] = from[key];
  				}
  			}
  
  			if (getOwnPropertySymbols) {
  				symbols = getOwnPropertySymbols(from);
  				for (var i = 0; i < symbols.length; i++) {
  					if (propIsEnumerable.call(from, symbols[i])) {
  						to[symbols[i]] = from[symbols[i]];
  					}
  				}
  			}
  		}
  
  		return to;
  	};
  
  	/**
  	 * Copyright (c) 2013-present, Facebook, Inc.
  	 *
  	 * This source code is licensed under the MIT license found in the
  	 * LICENSE file in the root directory of this source tree.
  	 */
  
  	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
  
  	var ReactPropTypesSecret_1 = ReactPropTypesSecret;
  
  	{
  	  var invariant$1 = invariant_1;
  	  var warning$1 = warning_1;
  	  var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
  	  var loggedTypeFailures = {};
  	}
  
  	/**
  	 * Assert that the values match with the type specs.
  	 * Error messages are memorized and will only be shown once.
  	 *
  	 * @param {object} typeSpecs Map of name to a ReactPropType
  	 * @param {object} values Runtime values that need to be type-checked
  	 * @param {string} location e.g. "prop", "context", "child context"
  	 * @param {string} componentName Name of the component for error messages.
  	 * @param {?Function} getStack Returns the component stack.
  	 * @private
  	 */
  	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
  	  {
  	    for (var typeSpecName in typeSpecs) {
  	      if (typeSpecs.hasOwnProperty(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.
  	          invariant$1(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);
  	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);
  	        } catch (ex) {
  	          error = ex;
  	        }
  	        warning$1(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);
  	        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() : '';
  
  	          warning$1(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');
  	        }
  	      }
  	    }
  	  }
  	}
  
  	var checkPropTypes_1 = checkPropTypes;
  
  	var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
  	  /* global Symbol */
  	  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
  	  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
  
  	  /**
  	   * Returns the iterator method function contained on the iterable object.
  	   *
  	   * Be sure to invoke the function with the iterable as context:
  	   *
  	   *     var iteratorFn = getIteratorFn(myIterable);
  	   *     if (iteratorFn) {
  	   *       var iterator = iteratorFn.call(myIterable);
  	   *       ...
  	   *     }
  	   *
  	   * @param {?object} maybeIterable
  	   * @return {?function}
  	   */
  	  function getIteratorFn(maybeIterable) {
  	    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
  	    if (typeof iteratorFn === 'function') {
  	      return iteratorFn;
  	    }
  	  }
  
  	  /**
  	   * Collection of methods that allow declaration and validation of props that are
  	   * supplied to React components. Example usage:
  	   *
  	   *   var Props = require('ReactPropTypes');
  	   *   var MyArticle = React.createClass({
  	   *     propTypes: {
  	   *       // An optional string prop named "description".
  	   *       description: Props.string,
  	   *
  	   *       // A required enum prop named "category".
  	   *       category: Props.oneOf(['News','Photos']).isRequired,
  	   *
  	   *       // A prop named "dialog" that requires an instance of Dialog.
  	   *       dialog: Props.instanceOf(Dialog).isRequired
  	   *     },
  	   *     render: function() { ... }
  	   *   });
  	   *
  	   * A more formal specification of how these methods are used:
  	   *
  	   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
  	   *   decl := ReactPropTypes.{type}(.isRequired)?
  	   *
  	   * Each and every declaration produces a function with the same signature. This
  	   * allows the creation of custom validation functions. For example:
  	   *
  	   *  var MyLink = React.createClass({
  	   *    propTypes: {
  	   *      // An optional string or URI prop named "href".
  	   *      href: function(props, propName, componentName) {
  	   *        var propValue = props[propName];
  	   *        if (propValue != null && typeof propValue !== 'string' &&
  	   *            !(propValue instanceof URI)) {
  	   *          return new Error(
  	   *            'Expected a string or an URI for ' + propName + ' in ' +
  	   *            componentName
  	   *          );
  	   *        }
  	   *      }
  	   *    },
  	   *    render: function() {...}
  	   *  });
  	   *
  	   * @internal
  	   */
  
  	  var ANONYMOUS = '<<anonymous>>';
  
  	  // Important!
  	  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
  	  var ReactPropTypes = {
  	    array: createPrimitiveTypeChecker('array'),
  	    bool: createPrimitiveTypeChecker('boolean'),
  	    func: createPrimitiveTypeChecker('function'),
  	    number: createPrimitiveTypeChecker('number'),
  	    object: createPrimitiveTypeChecker('object'),
  	    string: createPrimitiveTypeChecker('string'),
  	    symbol: createPrimitiveTypeChecker('symbol'),
  
  	    any: createAnyTypeChecker(),
  	    arrayOf: createArrayOfTypeChecker,
  	    element: createElementTypeChecker(),
  	    instanceOf: createInstanceTypeChecker,
  	    node: createNodeChecker(),
  	    objectOf: createObjectOfTypeChecker,
  	    oneOf: createEnumTypeChecker,
  	    oneOfType: createUnionTypeChecker,
  	    shape: createShapeTypeChecker,
  	    exact: createStrictShapeTypeChecker,
  	  };
  
  	  /**
  	   * inlined Object.is polyfill to avoid requiring consumers ship their own
  	   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  	   */
  	  /*eslint-disable no-self-compare*/
  	  function is(x, y) {
  	    // SameValue algorithm
  	    if (x === y) {
  	      // Steps 1-5, 7-10
  	      // Steps 6.b-6.e: +0 != -0
  	      return x !== 0 || 1 / x === 1 / y;
  	    } else {
  	      // Step 6.a: NaN == NaN
  	      return x !== x && y !== y;
  	    }
  	  }
  	  /*eslint-enable no-self-compare*/
  
  	  /**
  	   * We use an Error-like object for backward compatibility as people may call
  	   * PropTypes directly and inspect their output. However, we don't use real
  	   * Errors anymore. We don't inspect their stack anyway, and creating them
  	   * is prohibitively expensive if they are created too often, such as what
  	   * happens in oneOfType() for any type before the one that matched.
  	   */
  	  function PropTypeError(message) {
  	    this.message = message;
  	    this.stack = '';
  	  }
  	  // Make `instanceof Error` still work for returned errors.
  	  PropTypeError.prototype = Error.prototype;
  
  	  function createChainableTypeChecker(validate) {
  	    {
  	      var manualPropTypeCallCache = {};
  	      var manualPropTypeWarningCount = 0;
  	    }
  	    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
  	      componentName = componentName || ANONYMOUS;
  	      propFullName = propFullName || propName;
  
  	      if (secret !== ReactPropTypesSecret_1) {
  	        if (throwOnDirectAccess) {
  	          // New behavior only for users of `prop-types` package
  	          invariant_1(
  	            false,
  	            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
  	            'Use `PropTypes.checkPropTypes()` to call them. ' +
  	            'Read more at http://fb.me/use-check-prop-types'
  	          );
  	        } else if (typeof console !== 'undefined') {
  	          // Old behavior for people using React.PropTypes
  	          var cacheKey = componentName + ':' + propName;
  	          if (
  	            !manualPropTypeCallCache[cacheKey] &&
  	            // Avoid spamming the console because they are often not actionable except for lib authors
  	            manualPropTypeWarningCount < 3
  	          ) {
  	            warning_1(
  	              false,
  	              'You are manually calling a React.PropTypes validation ' +
  	              'function for the `%s` prop on `%s`. This is deprecated ' +
  	              'and will throw in the standalone `prop-types` package. ' +
  	              'You may be seeing this warning due to a third-party PropTypes ' +
  	              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',
  	              propFullName,
  	              componentName
  	            );
  	            manualPropTypeCallCache[cacheKey] = true;
  	            manualPropTypeWarningCount++;
  	          }
  	        }
  	      }
  	      if (props[propName] == null) {
  	        if (isRequired) {
  	          if (props[propName] === null) {
  	            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
  	          }
  	          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
  	        }
  	        return null;
  	      } else {
  	        return validate(props, propName, componentName, location, propFullName);
  	      }
  	    }
  
  	    var chainedCheckType = checkType.bind(null, false);
  	    chainedCheckType.isRequired = checkType.bind(null, true);
  
  	    return chainedCheckType;
  	  }
  
  	  function createPrimitiveTypeChecker(expectedType) {
  	    function validate(props, propName, componentName, location, propFullName, secret) {
  	      var propValue = props[propName];
  	      var propType = getPropType(propValue);
  	      if (propType !== expectedType) {
  	        // `propValue` being instance of, say, date/regexp, pass the 'object'
  	        // check, but we can offer a more precise error message here rather than
  	        // 'of type `object`'.
  	        var preciseType = getPreciseType(propValue);
  
  	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
  	      }
  	      return null;
  	    }
  	    return createChainableTypeChecker(validate);
  	  }
  
  	  function createAnyTypeChecker() {
  	    return createChainableTypeChecker(emptyFunction_1.thatReturnsNull);
  	  }
  
  	  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 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)) {
  	      warning_1(false, 'Invalid argument supplied to oneOf, expected an instance of array.');
  	      return emptyFunction_1.thatReturnsNull;
  	    }
  
  	    function validate(props, propName, componentName, location, propFullName) {
  	      var propValue = props[propName];
  	      for (var i = 0; i < expectedValues.length; i++) {
  	        if (is(propValue, expectedValues[i])) {
  	          return null;
  	        }
  	      }
  
  	      var valuesString = JSON.stringify(expectedValues);
  	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
  	    }
  	    return createChainableTypeChecker(validate);
  	  }
  
  	  function createObjectOfTypeChecker(typeChecker) {
  	    function validate(props, propName, componentName, location, propFullName) {
  	      if (typeof typeChecker !== 'function') {
  	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
  	      }
  	      var propValue = props[propName];
  	      var propType = getPropType(propValue);
  	      if (propType !== 'object') {
  	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
  	      }
  	      for (var key in propValue) {
  	        if (propValue.hasOwnProperty(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)) {
  	      warning_1(false, 'Invalid argument supplied to oneOfType, expected an instance of array.');
  	      return emptyFunction_1.thatReturnsNull;
  	    }
  
  	    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
  	      var checker = arrayOfTypeCheckers[i];
  	      if (typeof checker !== 'function') {
  	        warning_1(
  	          false,
  	          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
  	          'received %s at index %s.',
  	          getPostfixForTypeWarning(checker),
  	          i
  	        );
  	        return emptyFunction_1.thatReturnsNull;
  	      }
  	    }
  
  	    function validate(props, propName, componentName, location, propFullName) {
  	      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
  	        var checker = arrayOfTypeCheckers[i];
  	        if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret_1) == null) {
  	          return null;
  	        }
  	      }
  
  	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
  	    }
  	    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':
  	      case 'string':
  	      case 'undefined':
  	        return true;
  	      case 'boolean':
  	        return !propValue;
  	      case 'object':
  	        if (Array.isArray(propValue)) {
  	          return propValue.every(isNode);
  	        }
  	        if (propValue === null || isValidElement(propValue)) {
  	          return true;
  	        }
  
  	        var iteratorFn = getIteratorFn(propValue);
  	        if (iteratorFn) {
  	          var iterator = iteratorFn.call(propValue);
  	          var step;
  	          if (iteratorFn !== propValue.entries) {
  	            while (!(step = iterator.next()).done) {
  	              if (!isNode(step.value)) {
  	                return false;
  	              }
  	            }
  	          } else {
  	            // Iterator will provide entry [k,v] tuples rather than values.
  	            while (!(step = iterator.next()).done) {
  	              var entry = step.value;
  	              if (entry) {
  	                if (!isNode(entry[1])) {
  	                  return false;
  	                }
  	              }
  	            }
  	          }
  	        } else {
  	          return false;
  	        }
  
  	        return true;
  	      default:
  	        return false;
  	    }
  	  }
  
  	  function isSymbol(propType, propValue) {
  	    // Native Symbol.
  	    if (propType === 'symbol') {
  	      return true;
  	    }
  
  	    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
  	    if (propValue['@@toStringTag'] === 'Symbol') {
  	      return true;
  	    }
  
  	    // Fallback for non-spec compliant Symbols which are polyfilled.
  	    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
  	      return true;
  	    }
  
  	    return false;
  	  }
  
  	  // Equivalent of `typeof` but with special handling for array and regexp.
  	  function getPropType(propValue) {
  	    var propType = typeof propValue;
  	    if (Array.isArray(propValue)) {
  	      return 'array';
  	    }
  	    if (propValue instanceof RegExp) {
  	      // Old webkits (at least until Android 4.0) return 'function' rather than
  	      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
  	      // passes PropTypes.object.
  	      return 'object';
  	    }
  	    if (isSymbol(propType, propValue)) {
  	      return 'symbol';
  	    }
  	    return propType;
  	  }
  
  	  // This handles more types than `getPropType`. Only used for error messages.
  	  // See `createPrimitiveTypeChecker`.
  	  function getPreciseType(propValue) {
  	    if (typeof propValue === 'undefined' || propValue === null) {
  	      return '' + propValue;
  	    }
  	    var propType = getPropType(propValue);
  	    if (propType === 'object') {
  	      if (propValue instanceof Date) {
  	        return 'date';
  	      } else if (propValue instanceof RegExp) {
  	        return 'regexp';
  	      }
  	    }
  	    return propType;
  	  }
  
  	  // Returns a string that is postfixed to a warning about an invalid type.
  	  // For example, "undefined" or "of type array"
  	  function getPostfixForTypeWarning(value) {
  	    var type = getPreciseType(value);
  	    switch (type) {
  	      case 'array':
  	      case 'object':
  	        return 'an ' + type;
  	      case 'boolean':
  	      case 'date':
  	      case 'regexp':
  	        return 'a ' + type;
  	      default:
  	        return type;
  	    }
  	  }
  
  	  // Returns class name of the object, if any.
  	  function getClassName(propValue) {
  	    if (!propValue.constructor || !propValue.constructor.name) {
  	      return ANONYMOUS;
  	    }
  	    return propValue.constructor.name;
  	  }
  
  	  ReactPropTypes.checkPropTypes = checkPropTypes_1;
  	  ReactPropTypes.PropTypes = ReactPropTypes;
  
  	  return ReactPropTypes;
  	};
  
  	var propTypes = createCommonjsModule(function (module) {
  	/**
  	 * 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 REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&
  	    Symbol.for &&
  	    Symbol.for('react.element')) ||
  	    0xeac7;
  
  	  var isValidElement = function(object) {
  	    return typeof object === 'object' &&
  	      object !== null &&
  	      object.$$typeof === REACT_ELEMENT_TYPE;
  	  };
  
  	  // 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(isValidElement, throwOnDirectAccess);
  	}
  	});
  
  	var key = '__global_unique_id__';
  
  	var gud = function() {
  	  return commonjsGlobal[key] = (commonjsGlobal[key] || 0) + 1;
  	};
  
  	var implementation = createCommonjsModule(function (module, exports) {
  
  	exports.__esModule = true;
  
  
  
  	var _react2 = _interopRequireDefault(React__default);
  
  
  
  	var _propTypes2 = _interopRequireDefault(propTypes);
  
  
  
  	var _gud2 = _interopRequireDefault(gud);
  
  
  
  	var _warning2 = _interopRequireDefault(warning_1);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  	var MAX_SIGNED_31_BIT_INT = 1073741823;
  
  	// Inlined Object.is polyfill.
  	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  	function objectIs(x, y) {
  	  if (x === y) {
  	    return x !== 0 || 1 / x === 1 / y;
  	  } else {
  	    return x !== x && y !== y;
  	  }
  	}
  
  	function createEventEmitter(value) {
  	  var handlers = [];
  	  return {
  	    on: function on(handler) {
  	      handlers.push(handler);
  	    },
  	    off: function off(handler) {
  	      handlers = handlers.filter(function (h) {
  	        return h !== handler;
  	      });
  	    },
  	    get: function get() {
  	      return value;
  	    },
  	    set: function set(newValue, changedBits) {
  	      value = newValue;
  	      handlers.forEach(function (handler) {
  	        return handler(value, changedBits);
  	      });
  	    }
  	  };
  	}
  
  	function onlyChild(children) {
  	  return Array.isArray(children) ? children[0] : children;
  	}
  
  	function createReactContext(defaultValue, calculateChangedBits) {
  	  var _Provider$childContex, _Consumer$contextType;
  
  	  var contextProp = '__create-react-context-' + (0, _gud2.default)() + '__';
  
  	  var Provider = function (_Component) {
  	    _inherits(Provider, _Component);
  
  	    function Provider() {
  	      var _temp, _this, _ret;
  
  	      _classCallCheck(this, Provider);
  
  	      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
  	        args[_key] = arguments[_key];
  	      }
  
  	      return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.emitter = createEventEmitter(_this.props.value), _temp), _possibleConstructorReturn(_this, _ret);
  	    }
  
  	    Provider.prototype.getChildContext = function getChildContext() {
  	      var _ref;
  
  	      return _ref = {}, _ref[contextProp] = this.emitter, _ref;
  	    };
  
  	    Provider.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
  	      if (this.props.value !== nextProps.value) {
  	        var oldValue = this.props.value;
  	        var newValue = nextProps.value;
  	        var changedBits = void 0;
  
  	        if (objectIs(oldValue, newValue)) {
  	          changedBits = 0; // No change
  	        } else {
  	          changedBits = typeof calculateChangedBits === 'function' ? calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;
  	          {
  	            (0, _warning2.default)((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits, 'calculateChangedBits: Expected the return value to be a ' + '31-bit integer. Instead received: %s', changedBits);
  	          }
  
  	          changedBits |= 0;
  
  	          if (changedBits !== 0) {
  	            this.emitter.set(nextProps.value, changedBits);
  	          }
  	        }
  	      }
  	    };
  
  	    Provider.prototype.render = function render() {
  	      return this.props.children;
  	    };
  
  	    return Provider;
  	  }(React__default.Component);
  
  	  Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = _propTypes2.default.object.isRequired, _Provider$childContex);
  
  	  var Consumer = function (_Component2) {
  	    _inherits(Consumer, _Component2);
  
  	    function Consumer() {
  	      var _temp2, _this2, _ret2;
  
  	      _classCallCheck(this, Consumer);
  
  	      for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
  	        args[_key2] = arguments[_key2];
  	      }
  
  	      return _ret2 = (_temp2 = (_this2 = _possibleConstructorReturn(this, _Component2.call.apply(_Component2, [this].concat(args))), _this2), _this2.state = {
  	        value: _this2.getValue()
  	      }, _this2.onUpdate = function (newValue, changedBits) {
  	        var observedBits = _this2.observedBits | 0;
  	        if ((observedBits & changedBits) !== 0) {
  	          _this2.setState({ value: _this2.getValue() });
  	        }
  	      }, _temp2), _possibleConstructorReturn(_this2, _ret2);
  	    }
  
  	    Consumer.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
  	      var observedBits = nextProps.observedBits;
  
  	      this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT // Subscribe to all changes by default
  	      : observedBits;
  	    };
  
  	    Consumer.prototype.componentDidMount = function componentDidMount() {
  	      if (this.context[contextProp]) {
  	        this.context[contextProp].on(this.onUpdate);
  	      }
  	      var observedBits = this.props.observedBits;
  
  	      this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT // Subscribe to all changes by default
  	      : observedBits;
  	    };
  
  	    Consumer.prototype.componentWillUnmount = function componentWillUnmount() {
  	      if (this.context[contextProp]) {
  	        this.context[contextProp].off(this.onUpdate);
  	      }
  	    };
  
  	    Consumer.prototype.getValue = function getValue() {
  	      if (this.context[contextProp]) {
  	        return this.context[contextProp].get();
  	      } else {
  	        return defaultValue;
  	      }
  	    };
  
  	    Consumer.prototype.render = function render() {
  	      return onlyChild(this.props.children)(this.state.value);
  	    };
  
  	    return Consumer;
  	  }(React__default.Component);
  
  	  Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = _propTypes2.default.object, _Consumer$contextType);
  
  
  	  return {
  	    Provider: Provider,
  	    Consumer: Consumer
  	  };
  	}
  
  	exports.default = _react2.default.createContext || createReactContext;
  	module.exports = exports['default'];
  	});
  
  	unwrapExports(implementation);
  
  	var lib = createCommonjsModule(function (module, exports) {
  
  	exports.__esModule = true;
  
  
  
  	var _react2 = _interopRequireDefault(React__default);
  
  
  
  	var _implementation2 = _interopRequireDefault(implementation);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = _react2.default.createContext || _implementation2.default;
  	module.exports = exports['default'];
  	});
  
  	var createContext = unwrapExports(lib);
  
  	var classCallCheck = function (instance, Constructor) {
  	  if (!(instance instanceof Constructor)) {
  	    throw new TypeError("Cannot call a class as a function");
  	  }
  	};
  
  	var _extends = Object.assign || function (target) {
  	  for (var i = 1; i < arguments.length; i++) {
  	    var source = arguments[i];
  
  	    for (var key in source) {
  	      if (Object.prototype.hasOwnProperty.call(source, key)) {
  	        target[key] = source[key];
  	      }
  	    }
  	  }
  
  	  return target;
  	};
  
  	var inherits = function (subClass, superClass) {
  	  if (typeof superClass !== "function" && superClass !== null) {
  	    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  	  }
  
  	  subClass.prototype = Object.create(superClass && superClass.prototype, {
  	    constructor: {
  	      value: subClass,
  	      enumerable: false,
  	      writable: true,
  	      configurable: true
  	    }
  	  });
  	  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  	};
  
  	var possibleConstructorReturn = function (self, call) {
  	  if (!self) {
  	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  	  }
  
  	  return call && (typeof call === "object" || typeof call === "function") ? call : self;
  	};
  
  	var ManagerContext = createContext({ getReferenceRef: undefined, referenceNode: undefined });
  
  	var Manager = function (_React$Component) {
  	  inherits(Manager, _React$Component);
  
  	  function Manager() {
  	    classCallCheck(this, Manager);
  
  	    var _this = possibleConstructorReturn(this, _React$Component.call(this));
  
  	    _this.getReferenceRef = function (referenceNode) {
  	      return _this.setState(function (_ref) {
  	        var context = _ref.context;
  	        return {
  	          context: _extends({}, context, { referenceNode: referenceNode })
  	        };
  	      });
  	    };
  
  	    _this.state = {
  	      context: {
  	        getReferenceRef: _this.getReferenceRef,
  	        referenceNode: undefined
  	      }
  	    };
  	    return _this;
  	  }
  
  	  Manager.prototype.render = function render() {
  	    return React.createElement(
  	      ManagerContext.Provider,
  	      { value: this.state.context },
  	      this.props.children
  	    );
  	  };
  
  	  return Manager;
  	}(React.Component);
  
  	/**
  	 * Takes an argument and if it's an array, returns the first item in the array,
  	 * otherwise returns the argument. Used for Preact compatibility.
  	 */
  	var unwrapArray = function unwrapArray(arg) {
  	  return Array.isArray(arg) ? arg[0] : arg;
  	};
  
  	/**
  	 * Takes a maybe-undefined function and arbitrary args and invokes the function
  	 * only if it is defined.
  	 */
  	var safeInvoke = function safeInvoke(fn) {
  	  for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
  	    args[_key - 1] = arguments[_key];
  	  }
  
  	  if (typeof fn === "function") {
  	    return fn.apply(undefined, args);
  	  }
  	};
  
  	var initialStyle = {
  	  position: 'absolute',
  	  top: 0,
  	  left: 0,
  	  opacity: 0,
  	  pointerEvents: 'none'
  	};
  
  	var initialArrowStyle = {};
  
  	var InnerPopper = function (_React$Component) {
  	  inherits(InnerPopper, _React$Component);
  
  	  function InnerPopper() {
  	    var _temp, _this, _ret;
  
  	    classCallCheck(this, InnerPopper);
  
  	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
  	      args[_key] = arguments[_key];
  	    }
  
  	    return _ret = (_temp = (_this = possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
  	      data: undefined,
  	      placement: undefined
  	    }, _this.popperNode = null, _this.arrowNode = null, _this.setPopperNode = function (popperNode) {
  	      if (_this.popperNode === popperNode) return;
  
  	      safeInvoke(_this.props.innerRef, popperNode);
  	      _this.popperNode = popperNode;
  
  	      _this.updatePopperInstance();
  	    }, _this.setArrowNode = function (arrowNode) {
  	      if (_this.arrowNode === arrowNode) return;
  	      _this.arrowNode = arrowNode;
  
  	      if (!_this.popperInstance) _this.updatePopperInstance();
  	    }, _this.updateStateModifier = {
  	      enabled: true,
  	      order: 900,
  	      fn: function fn(data) {
  	        var placement = data.placement;
  
  	        _this.setState({ data: data, placement: placement }, placement !== _this.state.placement ? _this.scheduleUpdate : undefined);
  	        return data;
  	      }
  	    }, _this.getOptions = function () {
  	      return {
  	        placement: _this.props.placement,
  	        eventsEnabled: _this.props.eventsEnabled,
  	        positionFixed: _this.props.positionFixed,
  	        modifiers: _extends({}, _this.props.modifiers, {
  	          arrow: _extends({}, _this.props.modifiers && _this.props.modifiers.arrow, {
  	            enabled: !!_this.arrowNode,
  	            element: _this.arrowNode
  	          }),
  	          applyStyle: { enabled: false },
  	          updateStateModifier: _this.updateStateModifier
  	        })
  	      };
  	    }, _this.getPopperStyle = function () {
  	      return !_this.popperNode || !_this.state.data ? initialStyle : _extends({
  	        position: _this.state.data.offsets.popper.position
  	      }, _this.state.data.styles);
  	    }, _this.getPopperPlacement = function () {
  	      return !_this.state.data ? undefined : _this.state.placement;
  	    }, _this.getArrowStyle = function () {
  	      return !_this.arrowNode || !_this.state.data ? initialArrowStyle : _this.state.data.arrowStyles;
  	    }, _this.getOutOfBoundariesState = function () {
  	      return _this.state.data ? _this.state.data.hide : undefined;
  	    }, _this.destroyPopperInstance = function () {
  	      if (!_this.popperInstance) return;
  
  	      _this.popperInstance.destroy();
  	      _this.popperInstance = null;
  	    }, _this.updatePopperInstance = function () {
  	      _this.destroyPopperInstance();
  
  	      var _this2 = _this,
  	          popperNode = _this2.popperNode;
  	      var referenceElement = _this.props.referenceElement;
  
  
  	      if (!referenceElement || !popperNode) return;
  
  	      _this.popperInstance = new PopperJS(referenceElement, popperNode, _this.getOptions());
  	    }, _this.scheduleUpdate = function () {
  	      if (_this.popperInstance) {
  	        _this.popperInstance.scheduleUpdate();
  	      }
  	    }, _temp), possibleConstructorReturn(_this, _ret);
  	  }
  
  	  InnerPopper.prototype.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
  	    // If the Popper.js options have changed, update the instance (destroy + create)
  	    if (this.props.placement !== prevProps.placement || this.props.referenceElement !== prevProps.referenceElement || this.props.positionFixed !== prevProps.positionFixed) {
  	      this.updatePopperInstance();
  	    } else if (this.props.eventsEnabled !== prevProps.eventsEnabled && this.popperInstance) {
  	      this.props.eventsEnabled ? this.popperInstance.enableEventListeners() : this.popperInstance.disableEventListeners();
  	    }
  
  	    // A placement difference in state means popper determined a new placement
  	    // apart from the props value. By the time the popper element is rendered with
  	    // the new position Popper has already measured it, if the place change triggers
  	    // a size change it will result in a misaligned popper. So we schedule an update to be sure.
  	    if (prevState.placement !== this.state.placement) {
  	      this.scheduleUpdate();
  	    }
  	  };
  
  	  InnerPopper.prototype.componentWillUnmount = function componentWillUnmount() {
  	    this.destroyPopperInstance();
  	  };
  
  	  InnerPopper.prototype.render = function render() {
  	    return unwrapArray(this.props.children)({
  	      ref: this.setPopperNode,
  	      style: this.getPopperStyle(),
  	      placement: this.getPopperPlacement(),
  	      outOfBoundaries: this.getOutOfBoundariesState(),
  	      scheduleUpdate: this.scheduleUpdate,
  	      arrowProps: {
  	        ref: this.setArrowNode,
  	        style: this.getArrowStyle()
  	      }
  	    });
  	  };
  
  	  return InnerPopper;
  	}(React.Component);
  
  	InnerPopper.defaultProps = {
  	  placement: 'bottom',
  	  eventsEnabled: true,
  	  referenceElement: undefined,
  	  positionFixed: false
  	};
  	var placements = PopperJS.placements;
  
  	function Popper(props) {
  	  return React.createElement(
  	    ManagerContext.Consumer,
  	    null,
  	    function (_ref) {
  	      var referenceNode = _ref.referenceNode;
  	      return React.createElement(InnerPopper, _extends({ referenceElement: referenceNode }, props));
  	    }
  	  );
  	}
  
  	/**
  	 * Copyright 2014-2015, Facebook, Inc.
  	 * All rights reserved.
  	 *
  	 * This source code is licensed under the BSD-style license found in the
  	 * LICENSE file in the root directory of this source tree. An additional grant
  	 * of patent rights can be found in the PATENTS file in the same directory.
  	 */
  
  	var warning$2 = function() {};
  
  	{
  	  warning$2 = function(condition, format, args) {
  	    var len = arguments.length;
  	    args = new Array(len > 2 ? len - 2 : 0);
  	    for (var key = 2; key < len; key++) {
  	      args[key - 2] = arguments[key];
  	    }
  	    if (format === undefined) {
  	      throw new Error(
  	        '`warning(condition, format, ...args)` requires a warning ' +
  	        'message argument'
  	      );
  	    }
  
  	    if (format.length < 10 || (/^[s\W]*$/).test(format)) {
  	      throw new Error(
  	        'The warning format should be able to uniquely identify this ' +
  	        'warning. Please, use a more descriptive format than: ' + format
  	      );
  	    }
  
  	    if (!condition) {
  	      var argIndex = 0;
  	      var message = 'Warning: ' +
  	        format.replace(/%s/g, function() {
  	          return args[argIndex++];
  	        });
  	      if (typeof console !== 'undefined') {
  	        console.error(message);
  	      }
  	      try {
  	        // 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) {}
  	    }
  	  };
  	}
  
  	var warning_1$1 = warning$2;
  
  	var InnerReference = function (_React$Component) {
  	  inherits(InnerReference, _React$Component);
  
  	  function InnerReference() {
  	    var _temp, _this, _ret;
  
  	    classCallCheck(this, InnerReference);
  
  	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
  	      args[_key] = arguments[_key];
  	    }
  
  	    return _ret = (_temp = (_this = possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.refHandler = function (node) {
  	      safeInvoke(_this.props.innerRef, node);
  	      safeInvoke(_this.props.getReferenceRef, node);
  	    }, _temp), possibleConstructorReturn(_this, _ret);
  	  }
  
  	  InnerReference.prototype.render = function render() {
  	    warning_1$1(this.props.getReferenceRef, '`Reference` should not be used outside of a `Manager` component.');
  	    return unwrapArray(this.props.children)({ ref: this.refHandler });
  	  };
  
  	  return InnerReference;
  	}(React.Component);
  
  	function Reference(props) {
  	  return React.createElement(
  	    ManagerContext.Consumer,
  	    null,
  	    function (_ref) {
  	      var getReferenceRef = _ref.getReferenceRef;
  	      return React.createElement(InnerReference, _extends({ getReferenceRef: getReferenceRef }, props));
  	    }
  	  );
  	}
  
  	// Public types
  
  	exports.Popper = Popper;
  	exports.placements = placements;
  	exports.Manager = Manager;
  	exports.Reference = Reference;
  
  	Object.defineProperty(exports, '__esModule', { value: true });
  
  })));
  