text:
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('redux')) :
	typeof define === 'function' && define.amd ? define(['exports', 'react', 'redux'], factory) :
	(factory((global.ReactRedux = {}),global.React,global.Redux));
}(this, (function (exports,React,redux) { 'use strict';

	var React__default = 'default' in React ? React['default'] : React;

	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;
	}

	/*
	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 printWarning = function() {};

	{
	  var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
	  var loggedTypeFailures = {};

	  printWarning = function(text) {
	    var message = 'Warning: ' + text;
	    if (typeof console !== 'undefined') {
	      console.error(message);
	    }
	    try {
	      // --- Welcome to debugging React ---
	      // This error was thrown as a convenience so that you can use this stack
	      // to find the callsite that caused this warning to fire.
	      throw new Error(message);
	    } catch (x) {}
	  };
	}

	/**
	 * Assert that the values match with the type specs.
	 * Error messages are memorized and will only be shown once.
	 *
	 * @param {object} typeSpecs Map of name to a ReactPropType
	 * @param {object} values Runtime values that need to be type-checked
	 * @param {string} location e.g. "prop", "context", "child context"
	 * @param {string} componentName Name of the component for error messages.
	 * @param {?Function} getStack Returns the component stack.
	 * @private
	 */
	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
	  {
	    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.
	          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;
	          }
	          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 : '')
	          );
	        }
	      }
	    }
	  }
	}

	var checkPropTypes_1 = checkPropTypes;

	var printWarning$1 = function() {};

	{
	  printWarning$1 = function(text) {
	    var message = 'Warning: ' + text;
	    if (typeof console !== 'undefined') {
	      console.error(message);
	    }
	    try {
	      // --- Welcome to debugging React ---
	      // This error was thrown as a convenience so that you can use this stack
	      // to find the callsite that caused this warning to fire.
	      throw new Error(message);
	    } catch (x) {}
	  };
	}

	function emptyFunctionThatReturnsNull() {
	  return null;
	}

	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
	          var err = new Error(
	            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
	            'Use `PropTypes.checkPropTypes()` to call them. ' +
	            'Read more at http://fb.me/use-check-prop-types'
	          );
	          err.name = 'Invariant Violation';
	          throw err;
	        } else if (typeof console !== 'undefined') {
	          // Old behavior for people using React.PropTypes
	          var cacheKey = componentName + ':' + propName;
	          if (
	            !manualPropTypeCallCache[cacheKey] &&
	            // Avoid spamming the console because they are often not actionable except for lib authors
	            manualPropTypeWarningCount < 3
	          ) {
	            printWarning$1(
	              'You are manually calling a React.PropTypes validation ' +
	              'function for the `' + propFullName + '` prop on `' + componentName  + '`. This is deprecated ' +
	              'and will throw in the standalone `prop-types` package. ' +
	              'You may be seeing this warning due to a third-party PropTypes ' +
	              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
	            );
	            manualPropTypeCallCache[cacheKey] = true;
	            manualPropTypeWarningCount++;
	          }
	        }
	      }
	      if (props[propName] == null) {
	        if (isRequired) {
	          if (props[propName] === null) {
	            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
	          }
	          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
	        }
	        return null;
	      } else {
	        return validate(props, propName, componentName, location, propFullName);
	      }
	    }

	    var chainedCheckType = checkType.bind(null, false);
	    chainedCheckType.isRequired = checkType.bind(null, true);

	    return chainedCheckType;
	  }

	  function createPrimitiveTypeChecker(expectedType) {
	    function validate(props, propName, componentName, location, propFullName, secret) {
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== expectedType) {
	        // `propValue` being instance of, say, date/regexp, pass the 'object'
	        // check, but we can offer a more precise error message here rather than
	        // 'of type `object`'.
	        var preciseType = getPreciseType(propValue);

	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
	      }
	      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 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)) {
	      printWarning$1('Invalid argument supplied to oneOf, expected an instance of array.');
	      return emptyFunctionThatReturnsNull;
	    }

	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      for (var i = 0; i < expectedValues.length; i++) {
	        if (is(propValue, expectedValues[i])) {
	          return null;
	        }
	      }

	      var valuesString = JSON.stringify(expectedValues);
	      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)) {
	      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;
	      }
	    }

	    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 Context = React__default.createContext(null);

	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 objectWithoutProperties = function (obj, keys) {
	  var target = {};

	  for (var i in obj) {
	    if (keys.indexOf(i) >= 0) continue;
	    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
	    target[i] = obj[i];
	  }

	  return target;
	};

	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 ContextProvider = Context.Provider;

	var Provider = function (_Component) {
	  inherits(Provider, _Component);

	  function Provider(props) {
	    classCallCheck(this, Provider);

	    var _this = possibleConstructorReturn(this, _Component.call(this, props));

	    _this.state = {
	      state: props.store.getState(),
	      store: props.store
	    };
	    _this.unsubscribe = null;
	    return _this;
	  }

	  Provider.prototype.componentDidMount = function componentDidMount() {
	    this.isUnmounted = false;
	    var state = this.state.store.getState();
	    this.unsubscribe = this.state.store.subscribe(this.triggerUpdateOnStoreStateChange.bind(this));

	    if (state !== this.state.state) {
	      this.setState({ state: state });
	    }
	  };

	  Provider.prototype.componentWillUnmount = function componentWillUnmount() {
	    this.isUnmounted = true;
	    if (this.unsubscribe) this.unsubscribe();
	  };

	  Provider.prototype.componentDidUpdate = function componentDidUpdate(lastProps) {
	    if (lastProps.store !== this.props.store) {
	      if (this.unsubscribe) this.unsubscribe();
	      this.unsubscribe = this.props.store.subscribe(this.triggerUpdateOnStoreStateChange.bind(this));
	      this.setState({
	        state: this.props.store.getState(),
	        store: this.props.store
	      });
	    }
	  };

	  Provider.prototype.triggerUpdateOnStoreStateChange = function triggerUpdateOnStoreStateChange() {
	    if (this.isUnmounted) {
	      return;
	    }

	    this.setState(function (prevState) {
	      var newState = prevState.store.getState();
	      if (prevState.state === newState) {
	        return null;
	      }
	      return {
	        state: newState
	      };
	    });
	  };

	  Provider.prototype.render = function render() {
	    var Context$$1 = this.props.context || ContextProvider;
	    return React__default.createElement(
	      Context$$1,
	      { value: this.state },
	      this.props.children
	    );
	  };

	  return Provider;
	}(React.Component);

	Provider.propTypes = {
	  store: propTypes.shape({
	    subscribe: propTypes.func.isRequired,
	    dispatch: propTypes.func.isRequired,
	    getState: propTypes.func.isRequired
	  }),
	  context: propTypes.object,
	  children: propTypes.any
	};

	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;
	var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
	var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
	var REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for('react.timeout') : 0xead1;

	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_ASYNC_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_TIMEOUT_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
	}

	function typeOf(object) {
	  if (typeof object === 'object' && object !== null) {
	    var $$typeof = object.$$typeof;

	    switch ($$typeof) {
	      case REACT_ELEMENT_TYPE:
	        var type = object.type;

	        switch (type) {
	          case REACT_ASYNC_MODE_TYPE:
	          case REACT_FRAGMENT_TYPE:
	          case REACT_PROFILER_TYPE:
	          case REACT_STRICT_MODE_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;
	            }
	        }
	      case REACT_PORTAL_TYPE:
	        return $$typeof;
	    }
	  }

	  return undefined;
	}

	var AsyncMode = REACT_ASYNC_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 Profiler = REACT_PROFILER_TYPE;
	var Portal = REACT_PORTAL_TYPE;
	var StrictMode = REACT_STRICT_MODE_TYPE;

	function isAsyncMode(object) {
	  return typeOf(object) === REACT_ASYNC_MODE_TYPE;
	}
	function isContextConsumer(object) {
	  return typeOf(object) === REACT_CONTEXT_TYPE;
	}
	function isContextProvider(object) {
	  return typeOf(object) === REACT_PROVIDER_TYPE;
	}
	function isElement(object) {
	  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
	}
	function isForwardRef(object) {
	  return typeOf(object) === REACT_FORWARD_REF_TYPE;
	}
	function isFragment(object) {
	  return typeOf(object) === REACT_FRAGMENT_TYPE;
	}
	function isProfiler(object) {
	  return typeOf(object) === REACT_PROFILER_TYPE;
	}
	function isPortal(object) {
	  return typeOf(object) === REACT_PORTAL_TYPE;
	}
	function isStrictMode(object) {
	  return typeOf(object) === REACT_STRICT_MODE_TYPE;
	}

	exports.typeOf = typeOf;
	exports.AsyncMode = AsyncMode;
	exports.ContextConsumer = ContextConsumer;
	exports.ContextProvider = ContextProvider;
	exports.Element = Element;
	exports.ForwardRef = ForwardRef;
	exports.Fragment = Fragment;
	exports.Profiler = Profiler;
	exports.Portal = Portal;
	exports.StrictMode = StrictMode;
	exports.isValidElementType = isValidElementType;
	exports.isAsyncMode = isAsyncMode;
	exports.isContextConsumer = isContextConsumer;
	exports.isContextProvider = isContextProvider;
	exports.isElement = isElement;
	exports.isForwardRef = isForwardRef;
	exports.isFragment = isFragment;
	exports.isProfiler = isProfiler;
	exports.isPortal = isPortal;
	exports.isStrictMode = isStrictMode;
	  })();
	}
	});

	unwrapExports(reactIs_development);
	var reactIs_development_1 = reactIs_development.typeOf;
	var reactIs_development_2 = reactIs_development.AsyncMode;
	var reactIs_development_3 = reactIs_development.ContextConsumer;
	var reactIs_development_4 = reactIs_development.ContextProvider;
	var reactIs_development_5 = reactIs_development.Element;
	var reactIs_development_6 = reactIs_development.ForwardRef;
	var reactIs_development_7 = reactIs_development.Fragment;
	var reactIs_development_8 = reactIs_development.Profiler;
	var reactIs_development_9 = reactIs_development.Portal;
	var reactIs_development_10 = reactIs_development.StrictMode;
	var reactIs_development_11 = reactIs_development.isValidElementType;
	var reactIs_development_12 = reactIs_development.isAsyncMode;
	var reactIs_development_13 = reactIs_development.isContextConsumer;
	var reactIs_development_14 = reactIs_development.isContextProvider;
	var reactIs_development_15 = reactIs_development.isElement;
	var reactIs_development_16 = reactIs_development.isForwardRef;
	var reactIs_development_17 = reactIs_development.isFragment;
	var reactIs_development_18 = reactIs_development.isProfiler;
	var reactIs_development_19 = reactIs_development.isPortal;
	var reactIs_development_20 = reactIs_development.isStrictMode;

	var reactIs = createCommonjsModule(function (module) {

	{
	  module.exports = reactIs_development;
	}
	});
	var reactIs_1 = reactIs.isValidElementType;

	var _ReactIs$ForwardRef;

	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

	/**
	 * Copyright 2015, Yahoo! Inc.
	 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
	 */

	var REACT_STATICS = {
	    childContextTypes: true,
	    contextTypes: true,
	    defaultProps: true,
	    displayName: true,
	    getDefaultProps: true,
	    getDerivedStateFromProps: true,
	    mixins: true,
	    propTypes: true,
	    type: true
	};

	var KNOWN_STATICS = {
	    name: true,
	    length: true,
	    prototype: true,
	    caller: true,
	    callee: true,
	    arguments: true,
	    arity: true
	};

	var TYPE_STATICS = _defineProperty({}, reactIs.ForwardRef, (_ReactIs$ForwardRef = {}, _defineProperty(_ReactIs$ForwardRef, '$$typeof', true), _defineProperty(_ReactIs$ForwardRef, 'render', true), _ReactIs$ForwardRef));

	var defineProperty$1 = Object.defineProperty;
	var getOwnPropertyNames = Object.getOwnPropertyNames;
	var getOwnPropertySymbols$1 = Object.getOwnPropertySymbols;
	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
	var getPrototypeOf = Object.getPrototypeOf;
	var objectPrototype = Object.prototype;

	function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
	    if (typeof sourceComponent !== 'string') {
	        // don't hoist over string (html) components

	        if (objectPrototype) {
	            var inheritedComponent = getPrototypeOf(sourceComponent);
	            if (inheritedComponent && inheritedComponent !== objectPrototype) {
	                hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
	            }
	        }

	        var keys = getOwnPropertyNames(sourceComponent);

	        if (getOwnPropertySymbols$1) {
	            keys = keys.concat(getOwnPropertySymbols$1(sourceComponent));
	        }

	        var targetStatics = TYPE_STATICS[targetComponent['$$typeof']] || REACT_STATICS;
	        var sourceStatics = TYPE_STATICS[sourceComponent['$$typeof']] || REACT_STATICS;

	        for (var i = 0; i < keys.length; ++i) {
	            var key = keys[i];
	            if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
	                var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
	                try {
	                    // Avoid failures from read-only properties
	                    defineProperty$1(targetComponent, key, descriptor);
	                } catch (e) {}
	            }
	        }

	        return targetComponent;
	    }

	    return targetComponent;
	}

	var hoistNonReactStatics_cjs = hoistNonReactStatics;

	/**
	 * 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 invariant = function(condition, format, a, b, c, d, e, f) {
	  {
	    if (format === undefined) {
	      throw new Error('invariant requires an error message argument');
	    }
	  }

	  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;

	var ReduxConsumer = Context.Consumer;

	function connectAdvanced(
	/*
	  selectorFactory is a func that is responsible for returning the selector function used to
	  compute new props from state, props, and dispatch. For example:
	     export default connectAdvanced((dispatch, options) => (state, props) => ({
	      thing: state.things[props.thingId],
	      saveThing: fields => dispatch(actionCreators.saveThing(props.thingId, fields)),
	    }))(YourComponent)
	   Access to dispatch is provided to the factory so selectorFactories can bind actionCreators
	  outside of their selector as an optimization. Options passed to connectAdvanced are passed to
	  the selectorFactory, along with displayName and WrappedComponent, as the second argument.
	   Note that selectorFactory is responsible for all caching/memoization of inbound and outbound
	  props. Do not use connectAdvanced directly without memoizing results between calls to your
	  selector, otherwise the Connect component will re-render on every state or props change.
	*/
	selectorFactory) {
	  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
	      _ref$getDisplayName = _ref.getDisplayName,
	      getDisplayName = _ref$getDisplayName === undefined ? function (name) {
	    return 'ConnectAdvanced(' + name + ')';
	  } : _ref$getDisplayName,
	      _ref$methodName = _ref.methodName,
	      methodName = _ref$methodName === undefined ? 'connectAdvanced' : _ref$methodName,
	      _ref$renderCountProp = _ref.renderCountProp,
	      renderCountProp = _ref$renderCountProp === undefined ? undefined : _ref$renderCountProp,
	      _ref$shouldHandleStat = _ref.shouldHandleStateChanges,
	      shouldHandleStateChanges = _ref$shouldHandleStat === undefined ? true : _ref$shouldHandleStat,
	      _ref$storeKey = _ref.storeKey,
	      storeKey = _ref$storeKey === undefined ? 'store' : _ref$storeKey,
	      _ref$withRef = _ref.withRef,
	      withRef = _ref$withRef === undefined ? false : _ref$withRef,
	      _ref$forwardRef = _ref.forwardRef,
	      _ref$consumer = _ref.consumer,
	      consumer = _ref$consumer === undefined ? ReduxConsumer : _ref$consumer,
	      connectOptions = objectWithoutProperties(_ref, ['getDisplayName', 'methodName', 'renderCountProp', 'shouldHandleStateChanges', 'storeKey', 'withRef', 'forwardRef', 'consumer']);

	  invariant_1(renderCountProp === undefined, 'renderCountProp is removed. render counting is built into the latest React dev tools profiling extension');

	  invariant_1(!withRef, "withRef is removed. To access the wrapped instance, use a ref on the connected component");

	  invariant_1(storeKey === 'store', 'storeKey has been removed and does not do anything. To use a custom redux store for a single component, ' + 'create a custom React context with React.createContext() and pass the Provider to react-redux\'s provider ' + 'and the Consumer to this component as in <Provider context={context.Provider}><' + 'ConnectedComponent consumer={context.Consumer} /></Provider>');

	  var Consumer = consumer;

	  return function wrapWithConnect(WrappedComponent) {
	    invariant_1(reactIs_1(WrappedComponent), 'You must pass a component to the function returned by ' + (methodName + '. Instead received ' + JSON.stringify(WrappedComponent)));

	    var wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component';

	    var displayName = getDisplayName(wrappedComponentName);

	    var PureWrapper = void 0;

	    if (forwardRef) {
	      var PureWrapperRef = function (_Component) {
	        inherits(PureWrapperRef, _Component);

	        function PureWrapperRef() {
	          classCallCheck(this, PureWrapperRef);
	          return possibleConstructorReturn(this, _Component.apply(this, arguments));
	        }

	        PureWrapperRef.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
	          return nextProps.derivedProps !== this.props.derivedProps;
	        };

	        PureWrapperRef.prototype.render = function render() {
	          var _props = this.props,
	              forwardRef = _props.forwardRef,
	              derivedProps = _props.derivedProps;

	          return React__default.createElement(WrappedComponent, _extends({}, derivedProps, { ref: forwardRef }));
	        };

	        return PureWrapperRef;
	      }(React.Component);

	      PureWrapperRef.propTypes = {
	        derivedProps: propTypes.object,
	        forwardRef: propTypes.oneOfType([propTypes.func, propTypes.object])
	      };
	      PureWrapper = PureWrapperRef;
	    } else {
	      var PureWrapperNoRef = function (_Component2) {
	        inherits(PureWrapperNoRef, _Component2);

	        function PureWrapperNoRef() {
	          classCallCheck(this, PureWrapperNoRef);
	          return possibleConstructorReturn(this, _Component2.apply(this, arguments));
	        }

	        PureWrapperNoRef.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
	          return nextProps.derivedProps !== this.props.derivedProps;
	        };

	        PureWrapperNoRef.prototype.render = function render() {
	          return React__default.createElement(WrappedComponent, this.props.derivedProps);
	        };

	        return PureWrapperNoRef;
	      }(React.Component);

	      PureWrapperNoRef.propTypes = {
	        derivedProps: propTypes.object
	      };
	      PureWrapper = PureWrapperNoRef;
	    }

	    var selectorFactoryOptions = _extends({}, connectOptions, {
	      getDisplayName: getDisplayName,
	      methodName: methodName,
	      renderCountProp: renderCountProp,
	      shouldHandleStateChanges: shouldHandleStateChanges,
	      storeKey: storeKey,
	      displayName: displayName,
	      wrappedComponentName: wrappedComponentName,
	      WrappedComponent: WrappedComponent
	    });

	    var OuterBase = connectOptions.pure ? React.PureComponent : React.Component;

	    var Connect = function (_OuterBase) {
	      inherits(Connect, _OuterBase);

	      function Connect(props) {
	        classCallCheck(this, Connect);

	        var _this3 = possibleConstructorReturn(this, _OuterBase.call(this, props));

	        invariant_1(forwardRef ? !props.props[storeKey] : !props[storeKey], 'Passing redux store in props has been removed and does not do anything. ' + 'To use a custom redux store for a single component, ' + 'create a custom React context with React.createContext() and pass the Provider to react-redux\'s provider ' + 'and the Consumer to this component\'s connect as in <Provider context={context.Provider}></Provider>' + (' and connect(mapState, mapDispatch, undefined, { consumer=context.consumer })(' + wrappedComponentName + ')'));
	        _this3.generatedDerivedProps = _this3.makeDerivedPropsGenerator();
	        _this3.renderWrappedComponent = _this3.renderWrappedComponent.bind(_this3);
	        return _this3;
	      }

	      Connect.prototype.makeDerivedPropsGenerator = function makeDerivedPropsGenerator() {
	        var lastProps = void 0;
	        var lastState = void 0;
	        var lastDerivedProps = void 0;
	        var lastStore = void 0;
	        var sourceSelector = void 0;
	        return function (state, props, store) {
	          if (connectOptions.pure && lastProps === props && lastState === state) {
	            return lastDerivedProps;
	          }
	          if (store !== lastStore) {
	            lastStore = store;
	            sourceSelector = selectorFactory(store.dispatch, selectorFactoryOptions);
	          }
	          lastProps = props;
	          lastState = state;
	          var nextProps = sourceSelector(state, props);
	          if (lastDerivedProps === nextProps) {
	            return lastDerivedProps;
	          }
	          lastDerivedProps = nextProps;
	          return lastDerivedProps;
	        };
	      };

	      Connect.prototype.renderWrappedComponentWithRef = function renderWrappedComponentWithRef(value) {
	        invariant_1(value, 'Could not find "store" in the context of ' + ('"' + displayName + '". Either wrap the root component in a <Provider>, ') + 'or pass a custom React context provider to <Provider> and the corresponding ' + ('React context consumer to ' + displayName + ' in connect options.'));
	        var state = value.state,
	            store = value.store;
	        var _props2 = this.props,
	            forwardRef = _props2.forwardRef,
	            props = _props2.props;

	        var derivedProps = this.generatedDerivedProps(state, props, store);
	        if (connectOptions.pure) {
	          return React__default.createElement(PureWrapper, { derivedProps: derivedProps, forwardRef: forwardRef });
	        }

	        return React__default.createElement(WrappedComponent, _extends({}, derivedProps, { ref: forwardRef }));
	      };

	      Connect.prototype.renderWrappedComponent = function renderWrappedComponent(value) {
	        invariant_1(value, 'Could not find "store" in the context of ' + ('"' + displayName + '". Either wrap the root component in a <Provider>, ') + 'or pass a custom React context provider to <Provider> and the corresponding ' + ('React context consumer to ' + displayName + ' in connect options.'));
	        var state = value.state,
	            store = value.store;

	        var derivedProps = this.generatedDerivedProps(state, this.props, store);
	        if (connectOptions.pure) {
	          return React__default.createElement(PureWrapper, { derivedProps: derivedProps });
	        }

	        return React__default.createElement(WrappedComponent, derivedProps);
	      };

	      Connect.prototype.render = function render() {
	        if (this.props.unstable_observedBits) {
	          return React__default.createElement(
	            Consumer,
	            { unstable_observedBits: this.props.unstable_observedBits },
	            this.renderWrappedComponent
	          );
	        }
	        return React__default.createElement(
	          Consumer,
	          null,
	          this.renderWrappedComponent
	        );
	      };

	      return Connect;
	    }(OuterBase);

	    Connect.WrappedComponent = WrappedComponent;
	    Connect.displayName = displayName;
	    if (forwardRef) {
	      Connect.prototype.renderWrappedComponent = Connect.prototype.renderWrappedComponentWithRef;
	      Connect.propTypes = {
	        props: propTypes.object,
	        forwardRef: propTypes.oneOfType([propTypes.func, propTypes.object])
	      };
	    }

	    if (!forwardRef) {
	      return hoistNonReactStatics_cjs(Connect, WrappedComponent);
	    }

	    function forwardRef(props, ref) {
	      return React__default.createElement(Connect, { props: props, forwardRef: ref });
	    }

	    var forwarded = React__default.forwardRef(forwardRef);
	    forwarded.displayName = displayName;
	    forwarded.WrappedComponent = WrappedComponent;
	    return hoistNonReactStatics_cjs(forwarded, WrappedComponent);
	  };
	}

	var hasOwn = Object.prototype.hasOwnProperty;

	function is(x, y) {
	  if (x === y) {
	    return x !== 0 || y !== 0 || 1 / x === 1 / y;
	  } else {
	    return x !== x && y !== y;
	  }
	}

	function shallowEqual(objA, objB) {
	  if (is(objA, objB)) return true;

	  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
	    return false;
	  }

	  var keysA = Object.keys(objA);
	  var keysB = Object.keys(objB);

	  if (keysA.length !== keysB.length) return false;

	  for (var i = 0; i < keysA.length; i++) {
	    if (!hasOwn.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
	      return false;
	    }
	  }

	  return true;
	}

	/**
	 * @param {any} obj The object to inspect.
	 * @returns {boolean} True if the argument appears to be a plain object.
	 */
	function isPlainObject(obj) {
	  if (typeof obj !== 'object' || obj === null) return false;

	  var proto = obj;
	  while (Object.getPrototypeOf(proto) !== null) {
	    proto = Object.getPrototypeOf(proto);
	  }

	  return Object.getPrototypeOf(obj) === proto;
	}

	/**
	 * Prints a warning in the console if it exists.
	 *
	 * @param {String} message The warning message.
	 * @returns {void}
	 */
	function warning(message) {
	  /* eslint-disable no-console */
	  if (typeof console !== 'undefined' && typeof console.error === 'function') {
	    console.error(message);
	  }
	  /* eslint-enable no-console */
	  try {
	    // This error was thrown as a convenience so that if you enable
	    // "break on all exceptions" in your console,
	    // it would pause the execution at this line.
	    throw new Error(message);
	    /* eslint-disable no-empty */
	  } catch (e) {}
	  /* eslint-enable no-empty */
	}

	function verifyPlainObject(value, displayName, methodName) {
	  if (!isPlainObject(value)) {
	    warning(methodName + '() in ' + displayName + ' must return a plain object. Instead received ' + value + '.');
	  }
	}

	function wrapMapToPropsConstant(getConstant) {
	  return function initConstantSelector(dispatch, options) {
	    var constant = getConstant(dispatch, options);

	    function constantSelector() {
	      return constant;
	    }
	    constantSelector.dependsOnOwnProps = false;
	    return constantSelector;
	  };
	}

	// dependsOnOwnProps is used by createMapToPropsProxy to determine whether to pass props as args
	// to the mapToProps function being wrapped. It is also used by makePurePropsSelector to determine
	// whether mapToProps needs to be invoked when props have changed.
	//
	// A length of one signals that mapToProps does not depend on props from the parent component.
	// A length of zero is assumed to mean mapToProps is getting args via arguments or ...args and
	// therefore not reporting its length accurately..
	function getDependsOnOwnProps(mapToProps) {
	  return mapToProps.dependsOnOwnProps !== null && mapToProps.dependsOnOwnProps !== undefined ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1;
	}

	// Used by whenMapStateToPropsIsFunction and whenMapDispatchToPropsIsFunction,
	// this function wraps mapToProps in a proxy function which does several things:
	//
	//  * Detects whether the mapToProps function being called depends on props, which
	//    is used by selectorFactory to decide if it should reinvoke on props changes.
	//
	//  * On first call, handles mapToProps if returns another function, and treats that
	//    new function as the true mapToProps for subsequent calls.
	//
	//  * On first call, verifies the first result is a plain object, in order to warn
	//    the developer that their mapToProps function is not returning a valid result.
	//
	function wrapMapToPropsFunc(mapToProps, methodName) {
	  return function initProxySelector(dispatch, _ref) {
	    var displayName = _ref.displayName;

	    var proxy = function mapToPropsProxy(stateOrDispatch, ownProps) {
	      return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch);
	    };

	    // allow detectFactoryAndVerify to get ownProps
	    proxy.dependsOnOwnProps = true;

	    proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) {
	      proxy.mapToProps = mapToProps;
	      proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps);
	      var props = proxy(stateOrDispatch, ownProps);

	      if (typeof props === 'function') {
	        proxy.mapToProps = props;
	        proxy.dependsOnOwnProps = getDependsOnOwnProps(props);
	        props = proxy(stateOrDispatch, ownProps);
	      }

	      verifyPlainObject(props, displayName, methodName);

	      return props;
	    };

	    return proxy;
	  };
	}

	function whenMapDispatchToPropsIsFunction(mapDispatchToProps) {
	  return typeof mapDispatchToProps === 'function' ? wrapMapToPropsFunc(mapDispatchToProps, 'mapDispatchToProps') : undefined;
	}

	function whenMapDispatchToPropsIsMissing(mapDispatchToProps) {
	  return !mapDispatchToProps ? wrapMapToPropsConstant(function (dispatch) {
	    return { dispatch: dispatch };
	  }) : undefined;
	}

	function whenMapDispatchToPropsIsObject(mapDispatchToProps) {
	  return mapDispatchToProps && typeof mapDispatchToProps === 'object' ? wrapMapToPropsConstant(function (dispatch) {
	    return redux.bindActionCreators(mapDispatchToProps, dispatch);
	  }) : undefined;
	}

	var defaultMapDispatchToPropsFactories = [whenMapDispatchToPropsIsFunction, whenMapDispatchToPropsIsMissing, whenMapDispatchToPropsIsObject];

	function whenMapStateToPropsIsFunction(mapStateToProps) {
	  return typeof mapStateToProps === 'function' ? wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps') : undefined;
	}

	function whenMapStateToPropsIsMissing(mapStateToProps) {
	  return !mapStateToProps ? wrapMapToPropsConstant(function () {
	    return {};
	  }) : undefined;
	}

	var defaultMapStateToPropsFactories = [whenMapStateToPropsIsFunction, whenMapStateToPropsIsMissing];

	function defaultMergeProps(stateProps, dispatchProps, ownProps) {
	  return _extends({}, ownProps, stateProps, dispatchProps);
	}

	function wrapMergePropsFunc(mergeProps) {
	  return function initMergePropsProxy(dispatch, _ref) {
	    var displayName = _ref.displayName,
	        pure = _ref.pure,
	        areMergedPropsEqual = _ref.areMergedPropsEqual;

	    var hasRunOnce = false;
	    var mergedProps = void 0;

	    return function mergePropsProxy(stateProps, dispatchProps, ownProps) {
	      var nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps);

	      if (hasRunOnce) {
	        if (!pure || !areMergedPropsEqual(nextMergedProps, mergedProps)) mergedProps = nextMergedProps;
	      } else {
	        hasRunOnce = true;
	        mergedProps = nextMergedProps;

	        verifyPlainObject(mergedProps, displayName, 'mergeProps');
	      }

	      return mergedProps;
	    };
	  };
	}

	function whenMergePropsIsFunction(mergeProps) {
	  return typeof mergeProps === 'function' ? wrapMergePropsFunc(mergeProps) : undefined;
	}

	function whenMergePropsIsOmitted(mergeProps) {
	  return !mergeProps ? function () {
	    return defaultMergeProps;
	  } : undefined;
	}

	var defaultMergePropsFactories = [whenMergePropsIsFunction, whenMergePropsIsOmitted];

	function verify(selector, methodName, displayName) {
	  if (!selector) {
	    throw new Error('Unexpected value for ' + methodName + ' in ' + displayName + '.');
	  } else if (methodName === 'mapStateToProps' || methodName === 'mapDispatchToProps') {
	    if (!selector.hasOwnProperty('dependsOnOwnProps')) {
	      warning('The selector for ' + methodName + ' of ' + displayName + ' did not specify a value for dependsOnOwnProps.');
	    }
	  }
	}

	function verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps, displayName) {
	  verify(mapStateToProps, 'mapStateToProps', displayName);
	  verify(mapDispatchToProps, 'mapDispatchToProps', displayName);
	  verify(mergeProps, 'mergeProps', displayName);
	}

	function impureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch) {
	  return function impureFinalPropsSelector(state, ownProps) {
	    return mergeProps(mapStateToProps(state, ownProps), mapDispatchToProps(dispatch, ownProps), ownProps);
	  };
	}

	function pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, _ref) {
	  var areStatesEqual = _ref.areStatesEqual,
	      areOwnPropsEqual = _ref.areOwnPropsEqual,
	      areStatePropsEqual = _ref.areStatePropsEqual;

	  var hasRunAtLeastOnce = false;
	  var state = void 0;
	  var ownProps = void 0;
	  var stateProps = void 0;
	  var dispatchProps = void 0;
	  var mergedProps = void 0;

	  function handleFirstCall(firstState, firstOwnProps) {
	    state = firstState;
	    ownProps = firstOwnProps;
	    stateProps = mapStateToProps(state, ownProps);
	    dispatchProps = mapDispatchToProps(dispatch, ownProps);
	    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
	    hasRunAtLeastOnce = true;
	    return mergedProps;
	  }

	  function handleNewPropsAndNewState() {
	    stateProps = mapStateToProps(state, ownProps);

	    if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps);

	    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
	    return mergedProps;
	  }

	  function handleNewProps() {
	    if (mapStateToProps.dependsOnOwnProps) stateProps = mapStateToProps(state, ownProps);

	    if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps);

	    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
	    return mergedProps;
	  }

	  function handleNewState() {
	    var nextStateProps = mapStateToProps(state, ownProps);
	    var statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps);
	    stateProps = nextStateProps;

	    if (statePropsChanged) mergedProps = mergeProps(stateProps, dispatchProps, ownProps);

	    return mergedProps;
	  }

	  function handleSubsequentCalls(nextState, nextOwnProps) {
	    var propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps);
	    var stateChanged = !areStatesEqual(nextState, state);
	    state = nextState;
	    ownProps = nextOwnProps;

	    if (propsChanged && stateChanged) return handleNewPropsAndNewState();
	    if (propsChanged) return handleNewProps();
	    if (stateChanged) return handleNewState();
	    return mergedProps;
	  }

	  return function pureFinalPropsSelector(nextState, nextOwnProps) {
	    return hasRunAtLeastOnce ? handleSubsequentCalls(nextState, nextOwnProps) : handleFirstCall(nextState, nextOwnProps);
	  };
	}

	// TODO: Add more comments

	// If pure is true, the selector returned by selectorFactory will memoize its results,
	// allowing connectAdvanced's shouldComponentUpdate to return false if final
	// props have not changed. If false, the selector will always return a new
	// object and shouldComponentUpdate will always return true.

	function finalPropsSelectorFactory(dispatch, _ref2) {
	  var initMapStateToProps = _ref2.initMapStateToProps,
	      initMapDispatchToProps = _ref2.initMapDispatchToProps,
	      initMergeProps = _ref2.initMergeProps,
	      options = objectWithoutProperties(_ref2, ['initMapStateToProps', 'initMapDispatchToProps', 'initMergeProps']);

	  var mapStateToProps = initMapStateToProps(dispatch, options);
	  var mapDispatchToProps = initMapDispatchToProps(dispatch, options);
	  var mergeProps = initMergeProps(dispatch, options);

	  {
	    verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps, options.displayName);
	  }

	  var selectorFactory = options.pure ? pureFinalPropsSelectorFactory : impureFinalPropsSelectorFactory;

	  return selectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options);
	}

	/*
	  connect is a facade over connectAdvanced. It turns its args into a compatible
	  selectorFactory, which has the signature:

	    (dispatch, options) => (nextState, nextOwnProps) => nextFinalProps

	  connect passes its args to connectAdvanced as options, which will in turn pass them to
	  selectorFactory each time a Connect component instance is instantiated or hot reloaded.

	  selectorFactory returns a final props selector from its mapStateToProps,
	  mapStateToPropsFactories, mapDispatchToProps, mapDispatchToPropsFactories, mergeProps,
	  mergePropsFactories, and pure args.

	  The resulting final props selector is called by the Connect component instance whenever
	  it receives new props or store state.
	 */

	function match(arg, factories, name) {
	  for (var i = factories.length - 1; i >= 0; i--) {
	    var result = factories[i](arg);
	    if (result) return result;
	  }

	  return function (dispatch, options) {
	    throw new Error('Invalid value of type ' + typeof arg + ' for ' + name + ' argument when connecting component ' + options.wrappedComponentName + '.');
	  };
	}

	function strictEqual(a, b) {
	  return a === b;
	}

	// createConnect with default args builds the 'official' connect behavior. Calling it with
	// different options opens up some testing and extensibility scenarios
	function createConnect() {
	  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
	      _ref$connectHOC = _ref.connectHOC,
	      connectHOC = _ref$connectHOC === undefined ? connectAdvanced : _ref$connectHOC,
	      _ref$mapStateToPropsF = _ref.mapStateToPropsFactories,
	      mapStateToPropsFactories = _ref$mapStateToPropsF === undefined ? defaultMapStateToPropsFactories : _ref$mapStateToPropsF,
	      _ref$mapDispatchToPro = _ref.mapDispatchToPropsFactories,
	      mapDispatchToPropsFactories = _ref$mapDispatchToPro === undefined ? defaultMapDispatchToPropsFactories : _ref$mapDispatchToPro,
	      _ref$mergePropsFactor = _ref.mergePropsFactories,
	      mergePropsFactories = _ref$mergePropsFactor === undefined ? defaultMergePropsFactories : _ref$mergePropsFactor,
	      _ref$selectorFactory = _ref.selectorFactory,
	      selectorFactory = _ref$selectorFactory === undefined ? finalPropsSelectorFactory : _ref$selectorFactory;

	  return function connect(mapStateToProps, mapDispatchToProps, mergeProps) {
	    var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
	        _ref2$pure = _ref2.pure,
	        pure = _ref2$pure === undefined ? true : _ref2$pure,
	        _ref2$areStatesEqual = _ref2.areStatesEqual,
	        areStatesEqual = _ref2$areStatesEqual === undefined ? strictEqual : _ref2$areStatesEqual,
	        _ref2$areOwnPropsEqua = _ref2.areOwnPropsEqual,
	        areOwnPropsEqual = _ref2$areOwnPropsEqua === undefined ? shallowEqual : _ref2$areOwnPropsEqua,
	        _ref2$areStatePropsEq = _ref2.areStatePropsEqual,
	        areStatePropsEqual = _ref2$areStatePropsEq === undefined ? shallowEqual : _ref2$areStatePropsEq,
	        _ref2$areMergedPropsE = _ref2.areMergedPropsEqual,
	        areMergedPropsEqual = _ref2$areMergedPropsE === undefined ? shallowEqual : _ref2$areMergedPropsE,
	        extraOptions = objectWithoutProperties(_ref2, ['pure', 'areStatesEqual', 'areOwnPropsEqual', 'areStatePropsEqual', 'areMergedPropsEqual']);

	    var initMapStateToProps = match(mapStateToProps, mapStateToPropsFactories, 'mapStateToProps');
	    var initMapDispatchToProps = match(mapDispatchToProps, mapDispatchToPropsFactories, 'mapDispatchToProps');
	    var initMergeProps = match(mergeProps, mergePropsFactories, 'mergeProps');

	    return connectHOC(selectorFactory, _extends({
	      // used in error messages
	      methodName: 'connect',

	      // used to compute Connect's displayName from the wrapped component's displayName.
	      getDisplayName: function getDisplayName(name) {
	        return 'Connect(' + name + ')';
	      },

	      // if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes
	      shouldHandleStateChanges: Boolean(mapStateToProps),

	      // passed through to selectorFactory
	      initMapStateToProps: initMapStateToProps,
	      initMapDispatchToProps: initMapDispatchToProps,
	      initMergeProps: initMergeProps,
	      pure: pure,
	      areStatesEqual: areStatesEqual,
	      areOwnPropsEqual: areOwnPropsEqual,
	      areStatePropsEqual: areStatePropsEqual,
	      areMergedPropsEqual: areMergedPropsEqual

	    }, extraOptions));
	  };
	}

	var connect = createConnect();

	exports.Provider = Provider;
	exports.connectAdvanced = connectAdvanced;
	exports.Context = Context;
	exports.connect = connect;

	Object.defineProperty(exports, '__esModule', { value: true });

})));


text:
Command Line
============

Aside from integrating with SBT and maven, Scrooge can also be run directly
from the command line. One way to do so is to run the main files of the
'scrooge-generator' or 'scrooge-linter' projects with the help of SBT. This
requires having the Scrooge project available locally.

To start, clone the Scrooge repository from GitHub, change into
the Scrooge directory, and checkout the master branch:

.. code-block:: bash

    $ git clone https://github.com/twitter/scrooge.git
    $ cd scrooge
    $ git checkout master

Working off of the master branch will ensure that you're using the latest
released version of Scrooge.

scrooge-generator
~~~~~~~~~~~~~~~~~

The 'scrooge-generator' project is responsible for converting Thrift IDL
files into generated code. Running it from the command line requires
running the 'com.twitter.scrooge.Main' object.

To get command line help:

.. code-block:: bash

    $ ./sbt 'scrooge-generator/runMain com.twitter.scrooge.Main --help'

To generate source with content written to the current directory:

.. code-block:: bash

    $ ./sbt 'scrooge-generator/runMain com.twitter.scrooge.Main <thrift-file1> [<thrift-file2> ...]'

To generate source with content written to a specified directory, using
extra include paths, rebuilding only those files that have changed:

.. code-block:: bash

    $ ./sbt 'scrooge-generator/runMain com.twitter.scrooge.Main -d <target-dir> -i <include-path> -s <thrift-file1> [<thrift-file2> ...]'

As an example, to generate Scala code for the 'user.thrift' file from the
'scrooge-maven-demo', you can run the following command:

.. code-block:: bash

    $ ./sbt 'scrooge-generator/runMain com.twitter.scrooge.Main -d generated -i demos/scrooge-maven-demo/src/main/thrift -s user.thrift'

This will output the 'User.scala' and 'UserService.scala' files in namespaced
directories underneath the 'generated' directory.

A complete command line help menu for scrooge-generator:

.. code-block:: none

  Usage: scrooge [options] <files...>

  --help                                    show this help screen
  -V, --version                             print version and quit
  -v, --verbose                             log verbose messages about progress
  -d, --dest <path>                         write generated code to a folder (default: .)
  -i, --include-path <path>                 path(s) to search for included thrift files (may be used multiple times)
  -n, --namespace-map <oldname>=<newname>   map old namespace to new (may be used multiple times)
  --default-java-namespace <name>           Use <name> as default namespace if the thrift file doesn't define its own namespace. If this option is not specified either, then use "thrift" as default namespace
  --disable-strict                          issue warnings on non-severe parse errors instead of aborting
  --gen-file-map <path>                     generate map.txt in the destination folder to specify the mapping from input thrift files to output Scala/Java files
  --dry-run                                 parses and validates source thrift files, reporting any errors, but does not emit any generated source code.  can be used with --gen-file-mapping to get the file mapping
  -s, --skip-unchanged                      Don't re-generate if the target is newer than the input
  -l, --language <value>                    name of language to generate code in (currently supported languages: java, lua, scala, cocoa, android, swift)
  --java-ser-enum-type                      Encode a thrift enum as o.a.t.p.TType.ENUM instead of TType.I32
  --language-flag <flag>                    Pass arguments to supported language generators. To generate Scala 2.13 compatible `scala.Seq` alias as `scala.collection.immutable.Seq`, please use "immutable-sequences".
  --scala-warn-on-java-ns-fallback          Print a warning when the scala generator falls back to the java namespace
  --finagle                                 generate finagle classes
  --gen-adapt                               Generate code for adaptive decoding for scala.
  --java-passthrough                        Enable java passthrough
  <files...>                                thrift files to compile

scrooge-linter
~~~~~~~~~~~~~~

The 'scrooge-linter' project is responsible for verifying that a Thrift
IDL file complies with Scrooge's understanding of the Thrift grammar. It
can be useful when making modifications to Thrift files to check it via
the 'scrooge-linter' without running the full on 'scrooge-generator'.

To get command line help:

.. code-block:: bash

    $ ./sbt 'scrooge-linter/runMain com.twitter.scrooge.linter.Main --help'

To lint a specific file (or files):

.. code-block:: bash

    $ ./sbt 'scrooge-linter/runMain com.twitter.scrooge.linter.Main <files...>'

As an example, to lint the 'user.thrift' file from the 'scrooge-maven-demo', you
can run the following command:

.. code-block:: bash

    $ ./sbt 'scrooge-linter/runMain com.twitter.scrooge.linter.Main -n demos/scrooge-maven-demo/src/main/thrift user.thrift'

A complete command line help menu for scrooge-linter:

.. code-block:: none

  Usage: scrooge-linter [options] <files...>

  --help                                 show this help screen
  -V, --version                          print version and quit
  -v, --verbose                          log verbose messages about progress
  -i, --ignore-errors                    return 0 if linter errors are found. If not set, linter returns 1.
  -n, --include-path <path>              path(s) to search for included thrift files (may be used multiple times)
  -e, --enable-rule <rule-name>          rules to be enabled.
    Available: Namespaces, CompilerOptimizedMethodParamLimit, RelativeIncludes, CamelCase, RequiredFieldDefault, Keywords, TransitivePersistence, FieldIndexGreaterThanZeroRule, MalformedDocstring, MapKeyType, DocumentedPersisted
      Default: Namespaces, CompilerOptimizedMethodParamLimit, RelativeIncludes, CamelCase, RequiredFieldDefault, Keywords, TransitivePersistence, FieldIndexGreaterThanZeroRule, MalformedDocstring, MapKeyType
  -d, --disable-rule <rule-name>         rules to be disabled.
  -p, --ignore-parse-errors              continue if parsing errors are found.
  -w, --warnings                         show linter warnings (default = False)
  --disable-strict                       issue warnings on non-severe parse errors instead of aborting
  --fatal-warnings                       convert warnings to errors
  <files...>                             thrift files to compile

redpajama_set_name: RedPajamaGithub


text:
#pragma once

#include <opencv2/core.hpp>
#include <pmdsdk2.h> // PMD Libraries
#include "openark/camera/DepthCamera.h"

namespace ark {

    /**
    * Class defining the behavior of a PMD Camera.
    * Example on how to read from sensor and visualize its output
    * @include SensorIO.cpp
    */
    class PMDCamera : public DepthCamera
    {
    public:
        /**
        * Public constructor initializing the PMD Camera.
        * @param use_live_sensor uses input from real sensor if TRUE. Otherwise reads from input file. Default is set to TRUE.
        */
        explicit PMDCamera(bool use_live_sensor = true);

        /**
        * Destructor for the PMD Camera.
        */
        ~PMDCamera();

        /**
        * Gets new frame from sensor.
        * Updates xyzMap, ampMap, and flagMap. Resets clusters.
        */
        void update(cv::Mat & xyz_map, cv::Mat & rgb_map, cv::Mat & ir_map, cv::Mat & fisheye_map,
                             cv::Mat & amp_map, cv::Mat & flag_map) override;

        /**
         * Get the camera's model name.
         */
        const std::string getModelName() const override;

        /** get camera frame width */
        int getWidth() const override;

        /** get camera frame height */
        int getHeight() const override;

        float flagMapConfidenceThreshold() const override;

        int ampMapInvalidFlagValue() const override;

        /**
         * Returns true if a flag map is available from this camera.
         */
        bool hasAmpMap() const override;

        /**
         * Returns true if a flag map is available from this camera.
         */
        bool hasFlagMap() const override;

        /** Shared pointer to PMD camera instance */
        typedef std::shared_ptr<PMDCamera> Ptr;
    private:
        /**
        * Getter method for the x-coordinate at (i,j).
        * @param i ith row
        * @param j jth column
        * @return x-coodinate at (i,j)
        */
        float getX(int i, int j) const;

        /**
        * Getter method for the x-coordinate at (i,j).
        * @param i ith row
        * @param j jth column
        * @return x-coodinate at (i,j)
        */
        float getY(int i, int j) const;

        /**
        * Getter method for the x-coordinate at (i,j).
        * @param i ith row
        * @param j jth column
        * @return x-coodinate at (i,j)
        */
        float getZ(int i, int j) const;

        // Private Variables
        const char* SOURCE_PLUGIN = "camboardpico";
        const char* SOURCE_PARAM = "";
        const char* PROC_PLUGIN = "camboardpicoproc";
        const char* PROC_PARAM = "";
        PMDHandle hnd;
        PMDDataDescription dd;
        char err[128]; // Char array for storing PMD's error log
        int numPixels;
        float* dists;
        float* amps;
        cv::Mat frame;
    };

}
    /*
    * \include SensorIO.cpp
    * Example of how to read from sensor
    */


text:
//
// Data structure used to read bits from an input source as a stream.
//
// This file is designed to be #included by other source files to
// make a complete decoder.
//

#include "lha_decoder.h"
#include <string.h>

typedef struct {

	// Callback function to invoke to read more data from the
	// input stream.

	LHADecoderCallback callback;
	void *callback_data;

	// Bits from the input stream that are waiting to be read.

	uint32_t bit_buffer;
	unsigned int bits;

} BitStreamReader;

// Initialize bit stream reader structure.
static void bit_stream_reader_init(BitStreamReader *reader,
                                   LHADecoderCallback callback,
                                   void *callback_data)
{
	reader->callback = callback;
	reader->callback_data = callback_data;

	reader->bits = 0;
	reader->bit_buffer = 0;
}

// Return the next n bits waiting to be read from the input stream,
// without removing any.  Returns -1 for failure.

static int peek_bits(BitStreamReader *reader,
                     unsigned int n)
{
	uint8_t buf[4];
	unsigned int fill_bytes;
	size_t bytes;

	if (n == 0) {
		return 0;
	}

	// If there are not enough bits in the buffer to satisfy this
	// request, we need to fill up the buffer with more bits.

	while (reader->bits < n) {

		// Maximum number of bytes we can fill?

		fill_bytes = (32 - reader->bits) / 8;

		// Read from input and fill bit_buffer.

		memset(buf, 0, sizeof(buf));
		bytes = reader->callback(buf, fill_bytes,
		                         reader->callback_data);

		// End of file?

		if (bytes == 0) {
			return -1;
		}

		reader->bit_buffer |= (uint32_t) buf[0] << (24 - reader->bits);
		reader->bit_buffer |= (uint32_t) buf[1] << (16 - reader->bits);
		reader->bit_buffer |= (uint32_t) buf[2] << (8 - reader->bits);
		reader->bit_buffer |= (uint32_t) buf[3];

		reader->bits += bytes * 8;
	}

	return (signed int) (reader->bit_buffer >> (32 - n));
}

// Read a bit from the input stream.
// Returns -1 for failure.

static int read_bits(BitStreamReader *reader,
                     unsigned int n)
{
	int result;

	result = peek_bits(reader, n);

	if (result >= 0) {
		reader->bit_buffer <<= n;
		reader->bits -= n;
	}

	return result;
}

// Read a bit from the input stream.
// Returns -1 for failure.

static int read_bit(BitStreamReader *reader)
{
	return read_bits(reader, 1);
}


text:
<?php
namespace TYPO3\Flow\I18n\Cldr\Reader\Exception;

use TYPO3\Flow\I18n\Exception\InvalidArgumentException;

/**
 * The "Unsupported Number Format" exception
 *
 * @api
 */
class UnsupportedNumberFormatException extends InvalidArgumentException
{
}


text:
title: "One Key Install"
date: 2016-08-25 11:23
---

[TOC][]()

Treat every command as **CentOS 6.0**.

# Basic

## zsh

Referer [github](https://github.com/robbyrussell/oh-my-zsh/wiki/Installing-ZSH)

```bash
yum install zsh
```

## oh-my-zsh

Need install `zsh` first!

Referer [github](https://github.com/robbyrussell/oh-my-zsh)

```bash
sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"
```

## z

[github](https://github.com/rupa/z)
```bash
git clone https://github.com/rupa/z.git
source z/z.sh
```

# Network

Referer [github](https://github.com/)

```bash
yum install httpie
```

```bash
pip install -U httpie
```


text:
package com.hhx.manage.service;

import java.util.List;
import java.util.Map;

import com.hhx.manage.page.PageResult;

public interface ExpertScoreService {

	public PageResult<Map<String,Object>> queryExpGroupListByParam(Map<String, Object> param);

	public void createExpertScoreGroup(Map<String, Object> param);

	public void updateExpertScoreGroup(Map<String, Object> param);

	public void batchDeleteExpScoreGroup(List<Integer> ids);

	public List<Map<String, Object>> queryExpListByExpGroupId(Integer group_id);

	public void batchDeleteExpFromGroup(List<Integer> ids);

	public void batchSetExpForJudge(List<Integer> ids);

	public void batchSetExpNotForJudge(List<Integer> ids);

	public void batchAddExpForGoup(List<Map<String, Object>> objs);

	public PageResult<Map<String, Object>> queryExpListByParam(Map<String, Object> param);

	public int checkLoginUserIsJudge(int userId);

	public PageResult<Map<String, Object>> getNeedScoreExpListByExpId(Map<String, Object> param);

	public PageResult<Map<String, Object>> getExpGetScoreDetailListByExpId(Map<String, Object> param);

	//专家得分详情列表
	public PageResult<Map<String, Object>> queryExpScoreDetailList(Map<String, Object> param);
	//查询某个专家所在的小组以及所在小组是由哪个小组评分的
	public Map<String, Integer> getScoreGroupId(int expId);

	public PageResult<Map<String, Object>> queryNeedScoreJudgeList(Map<String, Object> param);

	public Map<String, Object> queryExpBasicMsgByExpId(int expId);

	public int checkSomeExpScoreForOtherExp(Map<String, Integer> param);

	public void updateSomeExpScoreForOtherExp(Map<String, Integer> param);

	public void saveSomeExpScoreForOtherExp(Map<String, Integer> param);

	public int queryExpIsSetSort(int expId);

	public void insertExpSetSortStat(int expId);

	public int queryExpIsSetSomeSortForExp(int judgeId,int sort);

	public String checkSomeExpIsFininshSort(int judgeId);

	public void saveExpRemark(int judgeId,int expId,String remark);
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

namespace MvcCodeRouting.Web.Mvc.Tests.Routing {

   [TestClass]
   public class FromRouteAttributeBehavior {

      readonly RouteCollection routes;

      public FromRouteAttributeBehavior() {
         routes = TestUtil.GetRouteCollection();
      }

      [TestMethod]
      public void UseCustomName() {

         var controller = typeof(FromRouteAttr.CustomNameController);

         routes.Clear();
         routes.MapCodeRoutes(controller);

         Assert.IsNotNull(routes.At(0).Url.Contains("{b}"));
      }

      [TestMethod]
      public void UsesSpecifiedBinder() {

         var controller = typeof(FromRouteAttr.SpecifiedBinderController);

         routes.Clear();
         routes.MapCodeRoutes(controller);

         var httpContextMock = new Mock<HttpContextBase>();
         httpContextMock.Setup(c => c.Request.AppRelativeCurrentExecutionFilePath).Returns("~/Foo/yes");

         var httpResponseMock = new Mock<HttpResponseBase>();
         httpContextMock.Setup(c => c.Response).Returns(httpResponseMock.Object);

         var routeData = routes.GetRouteData(httpContextMock.Object);

         var controllerInstance = (ControllerBase)Activator.CreateInstance(controller);
         controllerInstance.ValidateRequest = false;

         var requestContext = new RequestContext(httpContextMock.Object, routeData);
         var controllerContext = new ControllerContext(requestContext, controllerInstance);

         controllerInstance.ValueProvider = new ValueProviderCollection(new IValueProvider[] { new RouteDataValueProvider(controllerContext) });

         ((IController)controllerInstance).Execute(requestContext);

         httpResponseMock.Verify(c => c.Write(It.Is<string>(s => s == "True")), Times.AtLeastOnce());
      }

      [TestMethod]
      public void UsesSpecifiedBinder_Property() {

         var controller = typeof(FromRouteAttr.SpecifiedBinderPropertyController);

         routes.Clear();
         routes.MapCodeRoutes(controller);

         var httpContextMock = new Mock<HttpContextBase>();
         httpContextMock.Setup(c => c.Request.AppRelativeCurrentExecutionFilePath).Returns("~/yes");

         var routeData = routes.GetRouteData(httpContextMock.Object);

         var controllerInstance = new FromRouteAttr.SpecifiedBinderPropertyController {
            ValidateRequest = false
         };

         var requestContext = new RequestContext(httpContextMock.Object, routeData);
         var controllerContext = new ControllerContext(requestContext, controllerInstance);

         controllerInstance.ValueProvider = new ValueProviderCollection(new IValueProvider[] { new RouteDataValueProvider(controllerContext) });

         ((IController)controllerInstance).Execute(requestContext);

         Assert.IsTrue(controllerInstance.a);
      }
   }
}

namespace MvcCodeRouting.Web.Mvc.Tests.Routing.FromRouteAttr {

   public class CustomNameController : Controller {

      public string Foo([FromRoute("b")]string a) {
         return a;
      }
   }

   public class SpecifiedBinderController : Controller {

      public bool Foo([FromRoute(Constraint = "yes|no", BinderType = typeof(YesNoModelBinder))]bool a) {
         return a;
      }
   }

   public class SpecifiedBinderPropertyController : Controller {

      [FromRoute(Constraint = "yes|no", BinderType = typeof(YesNoModelBinder))]
      public bool a { get; set; }

      protected override void Initialize(RequestContext requestContext) {
         base.Initialize(requestContext);
         this.BindRouteProperties();
      }

      public void Index() { }
   }

   class YesNoModelBinder : IModelBinder {

      public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) {

         ValueProviderResult vpResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);

         if (vpResult.RawValue is bool)
            return (bool)vpResult.RawValue;

         switch (vpResult.AttemptedValue) {
            case "yes":
               return true;
            case "no":
               return false;

            default:
               throw new InvalidOperationException();
         }
      }
   }
}


text:
import datetime
import re

from .constants import TypeCodes

def parse_date(value):
    """
    YYMMDD Format.
    """
    return datetime.datetime.strptime(value, '%y%m%d').date()

def write_date(date):
    return date.strftime('%y%m%d')

def parse_time(value):
    clock_pattern = re.compile(r'\d\d:\d\d:\d\d')

    if clock_pattern.match(value):
        return parse_clock_time(value)
    else:
        return parse_military_time(value)

def parse_clock_time(value):
    return datetime.datetime.strptime(value, '%H:%M:%S').time()

def parse_military_time(value):
    """
    Military Format, 24 hours. 0001 through 2400.
    Times are stated in military format (0000 through 2400).
    0000 indicates the beginning of the day and 2400 indicates the end of the day
    for the date indicated.
    Some processors use 9999 to indicate the end of the day.
    Be prepared to recognize 9999 as end-of-day when receiving transmissions.
    """
    # 9999 indicates end of the day
    # 2400 indicates end of the day but 24:00 not allowed so
    # it's really 23:59
    if value == '9999' or value == '2400':
        return datetime.time.max
    return datetime.datetime.strptime(value, '%H%M').time()

def write_time(time, clock_format_for_intra_day=False):
    if clock_format_for_intra_day and time != datetime.time.max:
        return write_clock_time(time)
    else:
        return write_military_time(time)

def write_clock_time(time):
    date = datetime.datetime.now().replace(hour=time.hour, minute=time.minute, second=time.second)
    return datetime.datetime.strftime(date, '%H:%M:%S')

def write_military_time(time):
    if time == datetime.time.max:
        return '2400'
    else:
        date = datetime.datetime.now().replace(hour=time.hour, minute=time.minute)
        return datetime.datetime.strftime(date, '%H%M')

def parse_type_code(value):
    return TypeCodes[value]

def convert_to_string(value):
    if value is None:
        return ''
    else:
        return str(value)


text:
package com.iluwatar;

public abstract class Mage extends Prototype {

	@Override
	public abstract Mage clone() throws CloneNotSupportedException;

}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.ServiceFabric.Actors;

namespace PublishingActor.Interfaces
{
	public interface IPublishingActor : IActor
	{
		Task<string> PublishMessageOneAsync();

        Task<string> PublishMessageTwoAsync();
    }
}


text:
package relver

import (
	"fmt"
	"path/filepath"

	bosherr "github.com/cloudfoundry/bosh-utils/errors"
	boshsys "github.com/cloudfoundry/bosh-utils/system"
)

type RelVer struct {
	source     string
	versionRaw string

	releasesIndexDir string
	fs               boshsys.FileSystem
}

func (r RelVer) Read(fileName string) ([]byte, error) {
	foundPaths, err := r.fs.Glob(filepath.Join(r.releasesIndexDir, r.source, "*-"+r.versionRaw, fileName))
	if err != nil {
		return nil, bosherr.WrapError(err, "Globbing release versions")
	}

	if l := len(foundPaths); l != 1 {
		return nil, fmt.Errorf("expected 1 glob match, but found %d", l)
	}

	contents, err := r.fs.ReadFile(foundPaths[0])
	if err != nil {
		return nil, bosherr.WrapError(err, "Reading release file")
	}

	return contents, err
}

func (r RelVer) ReadOptinal(fileName string) ([]byte, bool, error) {
	foundPaths, err := r.fs.Glob(filepath.Join(r.releasesIndexDir, r.source, "*-"+r.versionRaw, fileName))
	if err != nil {
		return nil, false, bosherr.WrapError(err, "Globbing release versions")
	}

	if len(foundPaths) > 1 {
		return nil, false, bosherr.WrapError(err, "Finding release version")
	}

	if len(foundPaths) == 1 {
		contents, err := r.fs.ReadFile(foundPaths[0])
		if err != nil {
			return nil, false, bosherr.WrapError(err, "Reading release file")
		}

		return contents, true, err
	}

	return nil, false, nil
}


text:
<?php
/**
 * RepositoryFactory
 *
 * @category  AxalianAchievementsDoctrine\ServiceFactory\Repository
 * @package   AxalianAchievementsDoctrine\ServiceFactory\Repository
 * @author    Michel Maas <michel@michelmaas.com>
 */

namespace AxalianAchievementsDoctrine\ServiceFactory\Repository;

use Zend\ServiceManager\AbstractFactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class RepositoryFactory implements AbstractFactoryInterface
{
    /**
     * {@inheritDoc}
     */
    public function canCreateServiceWithName(ServiceLocatorInterface $serviceLocator, $name, $requestedName)
    {
        return (strpos($requestedName, '\\Repository\\') !== false);
    }

    /**
     * {@inheritDoc}
     */
    public function createServiceWithName(ServiceLocatorInterface $serviceLocator, $name, $requestedName)
    {
        $entityClass = $this->getEntityClassName($requestedName);
        $repository = $serviceLocator->get('doctrine.entitymanager.orm_default')->getRepository($entityClass);

        return $repository;
    }

    /**
     * Get the entity class name of a repository class name
     *
     * @param  string $repositoryClass
     * @return string
     */
    protected function getEntityClassName($repositoryClass)
    {
        $repositoryClass = str_replace('\\Repository\\', '\\Entity\\', $repositoryClass);
        $repositoryClass =
            (substr($repositoryClass, -10) === 'Repository') ?
            substr($repositoryClass, 0, -10) :
            $repositoryClass;

        return $repositoryClass;
    }
}


text:
<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">#bdbdbd</item>
        <item name="colorPrimaryDark">#9e9e9e</item>
        <item name="colorAccent">@color/accent</item>
    </style>
    <!-- bottom navigation bar style -->
    <style name="ThemeOverlay.Shrine.BottomNavigation" parent="">
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <item name="windowNoTitle">true</item>
    </style>

    <!-- Tab text size -->
    <style name="CustomTextAppearance" parent="TextAppearance.Design.Tab">
        <item name="android:textSize">12sp</item>
    </style>

    <dimen name="design_fab_size_mini">48dp</dimen>
    <dimen name="design_fab_size_normal">72dp</dimen>
</resources>


text:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using CefSharp;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Logging;
using Positron.Server.Hosting;

namespace Positron.UI.Internal
{
    internal class DisplayHandler : IDisplayHandler
    {
        private readonly PositronWindow _window;
        private readonly IConsoleLogger _consoleLogger;
        private readonly IWebHost _webHost;
        private readonly ILogger<DisplayHandler> _logger;

        private CancellationTokenSource _previousFaviconRequest;

        public DisplayHandler(PositronWindow window, IConsoleLogger consoleLogger, IWebHost webHost, ILogger<DisplayHandler> logger)
        {
            _window = window;
            _consoleLogger = consoleLogger;
            _webHost = webHost;
            _logger = logger;
        }

        public void OnAddressChanged(IWebBrowser browserControl, AddressChangedEventArgs addressChangedArgs)
        {
        }

        public void OnTitleChanged(IWebBrowser browserControl, TitleChangedEventArgs titleChangedArgs)
        {
            _window.Dispatcher.InvokeAsync(() => {
                _window.Title = titleChangedArgs.Title;
            });
        }

        public void OnFaviconUrlChange(IWebBrowser browserControl, IBrowser browser, IList<string> urls)
        {
            if (_previousFaviconRequest != null)
            {
                _previousFaviconRequest.Cancel();
            }

            _previousFaviconRequest = new CancellationTokenSource();
            var cancellationToken = _previousFaviconRequest.Token;

            _window.Dispatcher.InvokeAsync(async () =>
            {
                foreach (var uriString in urls)
                {
                    if (cancellationToken.IsCancellationRequested)
                    {
                        // Stop loop if cancelled
                        break;
                    }

                    try
                    {
                        BitmapImage image;

                        if (uriString.StartsWith("http://positron/"))
                        {
                            image = await LoadPositronImage(new Uri(uriString));
                        }
                        else
                        {
                            // For normal urls, use built in WPF image loader
                            image = new BitmapImage(new Uri(uriString));
                        }

                        if (cancellationToken.IsCancellationRequested)
                        {
                            // Don't set image if we've cancelled, let new task set new image
                            break;
                        }

                        _window.Icon = image;

                        break;
                    }
                    catch (Exception ex)
                    {
                        _logger.LogInformation(LoggerEventIds.FaviconError, ex, "Unable to load favicon {0}", uriString);

                        // Ignore error and try next url
                    }
                }
            }, DispatcherPriority.Normal, cancellationToken);
        }

        public void OnFullscreenModeChange(IWebBrowser browserControl, IBrowser browser, bool fullscreen)
        {
        }

        public bool OnTooltipChanged(IWebBrowser browserControl, string text)
        {
            return false;
        }

        public void OnStatusMessage(IWebBrowser browserControl, StatusMessageEventArgs statusMessageArgs)
        {
        }

        public bool OnConsoleMessage(IWebBrowser browserControl, ConsoleMessageEventArgs consoleMessageArgs)
        {
            try
            {
                _consoleLogger?.WriteMessage(consoleMessageArgs);
            }
            catch
            {
                // ignored
            }

            return true;
        }

        private async Task<BitmapImage> LoadPositronImage(Uri uri)
        {
            using (var client = new HttpClient(new PositronHttpMessageHandler(_webHost)))
            {
                var image = new BitmapImage();
                image.BeginInit();
                image.StreamSource = await client.GetStreamAsync(uri);
                image.EndInit();

                return image;
            }
        }
    }
}