text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory(require("react"));
  	else if(typeof define === 'function' && define.amd)
  		define(["react"], factory);
  	else if(typeof exports === 'object')
  		exports["ReactRouter"] = factory(require("react"));
  	else
  		root["ReactRouter"] = factory(root["React"]);
  })(this, function(__WEBPACK_EXTERNAL_MODULE_2__) {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.createMemoryHistory = exports.hashHistory = exports.browserHistory = exports.applyRouterMiddleware = exports.formatPattern = exports.useRouterHistory = exports.match = exports.routerShape = exports.locationShape = exports.PropTypes = exports.RoutingContext = exports.RouterContext = exports.createRoutes = exports.useRoutes = exports.RouteContext = exports.Lifecycle = exports.History = exports.Route = exports.Redirect = exports.IndexRoute = exports.IndexRedirect = exports.withRouter = exports.IndexLink = exports.Link = exports.Router = undefined;
  
  	var _RouteUtils = __webpack_require__(5);
  
  	Object.defineProperty(exports, 'createRoutes', {
  	  enumerable: true,
  	  get: function get() {
  	    return _RouteUtils.createRoutes;
  	  }
  	});
  
  	var _PropTypes2 = __webpack_require__(15);
  
  	Object.defineProperty(exports, 'locationShape', {
  	  enumerable: true,
  	  get: function get() {
  	    return _PropTypes2.locationShape;
  	  }
  	});
  	Object.defineProperty(exports, 'routerShape', {
  	  enumerable: true,
  	  get: function get() {
  	    return _PropTypes2.routerShape;
  	  }
  	});
  
  	var _PatternUtils = __webpack_require__(8);
  
  	Object.defineProperty(exports, 'formatPattern', {
  	  enumerable: true,
  	  get: function get() {
  	    return _PatternUtils.formatPattern;
  	  }
  	});
  
  	var _Router2 = __webpack_require__(39);
  
  	var _Router3 = _interopRequireDefault(_Router2);
  
  	var _Link2 = __webpack_require__(20);
  
  	var _Link3 = _interopRequireDefault(_Link2);
  
  	var _IndexLink2 = __webpack_require__(33);
  
  	var _IndexLink3 = _interopRequireDefault(_IndexLink2);
  
  	var _withRouter2 = __webpack_require__(52);
  
  	var _withRouter3 = _interopRequireDefault(_withRouter2);
  
  	var _IndexRedirect2 = __webpack_require__(34);
  
  	var _IndexRedirect3 = _interopRequireDefault(_IndexRedirect2);
  
  	var _IndexRoute2 = __webpack_require__(35);
  
  	var _IndexRoute3 = _interopRequireDefault(_IndexRoute2);
  
  	var _Redirect2 = __webpack_require__(21);
  
  	var _Redirect3 = _interopRequireDefault(_Redirect2);
  
  	var _Route2 = __webpack_require__(37);
  
  	var _Route3 = _interopRequireDefault(_Route2);
  
  	var _History2 = __webpack_require__(32);
  
  	var _History3 = _interopRequireDefault(_History2);
  
  	var _Lifecycle2 = __webpack_require__(36);
  
  	var _Lifecycle3 = _interopRequireDefault(_Lifecycle2);
  
  	var _RouteContext2 = __webpack_require__(38);
  
  	var _RouteContext3 = _interopRequireDefault(_RouteContext2);
  
  	var _useRoutes2 = __webpack_require__(51);
  
  	var _useRoutes3 = _interopRequireDefault(_useRoutes2);
  
  	var _RouterContext2 = __webpack_require__(10);
  
  	var _RouterContext3 = _interopRequireDefault(_RouterContext2);
  
  	var _RoutingContext2 = __webpack_require__(40);
  
  	var _RoutingContext3 = _interopRequireDefault(_RoutingContext2);
  
  	var _PropTypes3 = _interopRequireDefault(_PropTypes2);
  
  	var _match2 = __webpack_require__(49);
  
  	var _match3 = _interopRequireDefault(_match2);
  
  	var _useRouterHistory2 = __webpack_require__(26);
  
  	var _useRouterHistory3 = _interopRequireDefault(_useRouterHistory2);
  
  	var _applyRouterMiddleware2 = __webpack_require__(42);
  
  	var _applyRouterMiddleware3 = _interopRequireDefault(_applyRouterMiddleware2);
  
  	var _browserHistory2 = __webpack_require__(43);
  
  	var _browserHistory3 = _interopRequireDefault(_browserHistory2);
  
  	var _hashHistory2 = __webpack_require__(47);
  
  	var _hashHistory3 = _interopRequireDefault(_hashHistory2);
  
  	var _createMemoryHistory2 = __webpack_require__(23);
  
  	var _createMemoryHistory3 = _interopRequireDefault(_createMemoryHistory2);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.Router = _Router3.default; /* components */
  
  	exports.Link = _Link3.default;
  	exports.IndexLink = _IndexLink3.default;
  	exports.withRouter = _withRouter3.default;
  
  	/* components (configuration) */
  
  	exports.IndexRedirect = _IndexRedirect3.default;
  	exports.IndexRoute = _IndexRoute3.default;
  	exports.Redirect = _Redirect3.default;
  	exports.Route = _Route3.default;
  
  	/* mixins */
  
  	exports.History = _History3.default;
  	exports.Lifecycle = _Lifecycle3.default;
  	exports.RouteContext = _RouteContext3.default;
  
  	/* utils */
  
  	exports.useRoutes = _useRoutes3.default;
  	exports.RouterContext = _RouterContext3.default;
  	exports.RoutingContext = _RoutingContext3.default;
  	exports.PropTypes = _PropTypes3.default;
  	exports.match = _match3.default;
  	exports.useRouterHistory = _useRouterHistory3.default;
  	exports.applyRouterMiddleware = _applyRouterMiddleware3.default;
  
  	/* histories */
  
  	exports.browserHistory = _browserHistory3.default;
  	exports.hashHistory = _hashHistory3.default;
  	exports.createMemoryHistory = _createMemoryHistory3.default;
  
  /***/ },
  /* 1 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.default = routerWarning;
  	exports._resetWarned = _resetWarned;
  
  	var _warning = __webpack_require__(63);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var warned = {};
  
  	function routerWarning(falseToWarn, message) {
  	  // Only issue deprecation warnings once.
  	  if (message.indexOf('deprecated') !== -1) {
  	    if (warned[message]) {
  	      return;
  	    }
  
  	    warned[message] = true;
  	  }
  
  	  message = '[react-router] ' + message;
  
  	  for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
  	    args[_key - 2] = arguments[_key];
  	  }
  
  	  _warning2.default.apply(undefined, [falseToWarn, message].concat(args));
  	}
  
  	function _resetWarned() {
  	  warned = {};
  	}
  
  /***/ },
  /* 2 */
  /***/ function(module, exports) {
  
  	module.exports = __WEBPACK_EXTERNAL_MODULE_2__;
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * Copyright 2013-2015, Facebook, Inc.
  	 * All rights reserved.
  	 *
  	 * This source code is licensed under the BSD-style license found in the
  	 * LICENSE file in the root directory of this source tree. An additional grant
  	 * of patent rights can be found in the PATENTS file in the same directory.
  	 */
  
  	'use strict';
  
  	/**
  	 * Use invariant() to assert state which your program assumes to be true.
  	 *
  	 * Provide sprintf-style format (only %s is supported) and arguments
  	 * to provide information about what broke and what you were
  	 * expecting.
  	 *
  	 * The invariant message will be stripped in production, but the invariant
  	 * will remain to ensure logic does not differ in production.
  	 */
  
  	var invariant = function(condition, format, a, b, c, d, e, f) {
  	  if (true) {
  	    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;
  	  }
  	};
  
  	module.exports = invariant;
  
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * Copyright 2014-2015, Facebook, Inc.
  	 * All rights reserved.
  	 *
  	 * This source code is licensed under the BSD-style license found in the
  	 * LICENSE file in the root directory of this source tree. An additional grant
  	 * of patent rights can be found in the PATENTS file in the same directory.
  	 */
  
  	'use strict';
  
  	/**
  	 * Similar to invariant but only logs a warning if the condition is not met.
  	 * This can be used to log issues in development environments in critical
  	 * paths. Removing the logging code for production environments will keep the
  	 * same logic and follow the same code paths.
  	 */
  
  	var warning = function() {};
  
  	if (true) {
  	  warning = function(condition, format, args) {
  	    var len = arguments.length;
  	    args = new Array(len > 2 ? len - 2 : 0);
  	    for (var key = 2; key < len; key++) {
  	      args[key - 2] = arguments[key];
  	    }
  	    if (format === undefined) {
  	      throw new Error(
  	        '`warning(condition, format, ...args)` requires a warning ' +
  	        'message argument'
  	      );
  	    }
  
  	    if (format.length < 10 || (/^[s\W]*$/).test(format)) {
  	      throw new Error(
  	        'The warning format should be able to uniquely identify this ' +
  	        'warning. Please, use a more descriptive format than: ' + format
  	      );
  	    }
  
  	    if (!condition) {
  	      var argIndex = 0;
  	      var message = 'Warning: ' +
  	        format.replace(/%s/g, function() {
  	          return args[argIndex++];
  	        });
  	      if (typeof console !== 'undefined') {
  	        console.error(message);
  	      }
  	      try {
  	        // This error was thrown as a convenience so that you can use this stack
  	        // to find the callsite that caused this warning to fire.
  	        throw new Error(message);
  	      } catch(x) {}
  	    }
  	  };
  	}
  
  	module.exports = warning;
  
  
  /***/ },
  /* 5 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	exports.isReactChildren = isReactChildren;
  	exports.createRouteFromReactElement = createRouteFromReactElement;
  	exports.createRoutesFromReactChildren = createRoutesFromReactChildren;
  	exports.createRoutes = createRoutes;
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function isValidChild(object) {
  	  return object == null || _react2.default.isValidElement(object);
  	}
  
  	function isReactChildren(object) {
  	  return isValidChild(object) || Array.isArray(object) && object.every(isValidChild);
  	}
  
  	function createRoute(defaultProps, props) {
  	  return _extends({}, defaultProps, props);
  	}
  
  	function createRouteFromReactElement(element) {
  	  var type = element.type;
  	  var route = createRoute(type.defaultProps, element.props);
  
  	  if (route.children) {
  	    var childRoutes = createRoutesFromReactChildren(route.children, route);
  
  	    if (childRoutes.length) route.childRoutes = childRoutes;
  
  	    delete route.children;
  	  }
  
  	  return route;
  	}
  
  	/**
  	 * Creates and returns a routes object from the given ReactChildren. JSX
  	 * provides a convenient way to visualize how routes in the hierarchy are
  	 * nested.
  	 *
  	 *   import { Route, createRoutesFromReactChildren } from 'react-router'
  	 *
  	 *   const routes = createRoutesFromReactChildren(
  	 *     <Route component={App}>
  	 *       <Route path="home" component={Dashboard}/>
  	 *       <Route path="news" component={NewsFeed}/>
  	 *     </Route>
  	 *   )
  	 *
  	 * Note: This method is automatically used when you provide <Route> children
  	 * to a <Router> component.
  	 */
  	function createRoutesFromReactChildren(children, parentRoute) {
  	  var routes = [];
  
  	  _react2.default.Children.forEach(children, function (element) {
  	    if (_react2.default.isValidElement(element)) {
  	      // Component classes may have a static create* method.
  	      if (element.type.createRouteFromReactElement) {
  	        var route = element.type.createRouteFromReactElement(element, parentRoute);
  
  	        if (route) routes.push(route);
  	      } else {
  	        routes.push(createRouteFromReactElement(element));
  	      }
  	    }
  	  });
  
  	  return routes;
  	}
  
  	/**
  	 * Creates and returns an array of routes from the given object which
  	 * may be a JSX route, a plain object route, or an array of either.
  	 */
  	function createRoutes(routes) {
  	  if (isReactChildren(routes)) {
  	    routes = createRoutesFromReactChildren(routes);
  	  } else if (routes && !Array.isArray(routes)) {
  	    routes = [routes];
  	  }
  
  	  return routes;
  	}
  
  /***/ },
  /* 6 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.routes = exports.route = exports.components = exports.component = exports.history = undefined;
  	exports.falsy = falsy;
  
  	var _react = __webpack_require__(2);
  
  	var _propTypes = require('prop-types');
  
  	var func = _propTypes.func;
  	var object = _propTypes.object;
  	var arrayOf = _propTypes.arrayOf;
  	var oneOfType = _propTypes.oneOfType;
  	var element = _propTypes.element;
  	var shape = _propTypes.shape;
  	var string = _propTypes.string;
  	function falsy(props, propName, componentName) {
  	  if (props[propName]) return new Error('<' + componentName + '> should not have a "' + propName + '" prop');
  	}
  
  	var history = exports.history = shape({
  	  listen: func.isRequired,
  	  push: func.isRequired,
  	  replace: func.isRequired,
  	  go: func.isRequired,
  	  goBack: func.isRequired,
  	  goForward: func.isRequired
  	});
  
  	var component = exports.component = oneOfType([func, string]);
  	var components = exports.components = oneOfType([component, object]);
  	var route = exports.route = oneOfType([object, element]);
  	var routes = exports.routes = oneOfType([route, arrayOf(route)]);
  
  /***/ },
  /* 7 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.extractPath = extractPath;
  	exports.parsePath = parsePath;
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	function extractPath(string) {
  	  var match = string.match(/^https?:\/\/[^\/]*/);
  
  	  if (match == null) return string;
  
  	  return string.substring(match[0].length);
  	}
  
  	function parsePath(path) {
  	  var pathname = extractPath(path);
  	  var search = '';
  	  var hash = '';
  
  	   true ? _warning2['default'](path === pathname, 'A path must be pathname + search + hash only, not a fully qualified URL like "%s"', path) : undefined;
  
  	  var hashIndex = pathname.indexOf('#');
  	  if (hashIndex !== -1) {
  	    hash = pathname.substring(hashIndex);
  	    pathname = pathname.substring(0, hashIndex);
  	  }
  
  	  var searchIndex = pathname.indexOf('?');
  	  if (searchIndex !== -1) {
  	    search = pathname.substring(searchIndex);
  	    pathname = pathname.substring(0, searchIndex);
  	  }
  
  	  if (pathname === '') pathname = '/';
  
  	  return {
  	    pathname: pathname,
  	    search: search,
  	    hash: hash
  	  };
  	}
  
  /***/ },
  /* 8 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.compilePattern = compilePattern;
  	exports.matchPattern = matchPattern;
  	exports.getParamNames = getParamNames;
  	exports.getParams = getParams;
  	exports.formatPattern = formatPattern;
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function escapeRegExp(string) {
  	  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  	}
  
  	function _compilePattern(pattern) {
  	  var regexpSource = '';
  	  var paramNames = [];
  	  var tokens = [];
  
  	  var match = void 0,
  	      lastIndex = 0,
  	      matcher = /:([a-zA-Z_$][a-zA-Z0-9_$]*)|\*\*|\*|\(|\)/g;
  	  while (match = matcher.exec(pattern)) {
  	    if (match.index !== lastIndex) {
  	      tokens.push(pattern.slice(lastIndex, match.index));
  	      regexpSource += escapeRegExp(pattern.slice(lastIndex, match.index));
  	    }
  
  	    if (match[1]) {
  	      regexpSource += '([^/]+)';
  	      paramNames.push(match[1]);
  	    } else if (match[0] === '**') {
  	      regexpSource += '(.*)';
  	      paramNames.push('splat');
  	    } else if (match[0] === '*') {
  	      regexpSource += '(.*?)';
  	      paramNames.push('splat');
  	    } else if (match[0] === '(') {
  	      regexpSource += '(?:';
  	    } else if (match[0] === ')') {
  	      regexpSource += ')?';
  	    }
  
  	    tokens.push(match[0]);
  
  	    lastIndex = matcher.lastIndex;
  	  }
  
  	  if (lastIndex !== pattern.length) {
  	    tokens.push(pattern.slice(lastIndex, pattern.length));
  	    regexpSource += escapeRegExp(pattern.slice(lastIndex, pattern.length));
  	  }
  
  	  return {
  	    pattern: pattern,
  	    regexpSource: regexpSource,
  	    paramNames: paramNames,
  	    tokens: tokens
  	  };
  	}
  
  	var CompiledPatternsCache = Object.create(null);
  
  	function compilePattern(pattern) {
  	  if (!CompiledPatternsCache[pattern]) CompiledPatternsCache[pattern] = _compilePattern(pattern);
  
  	  return CompiledPatternsCache[pattern];
  	}
  
  	/**
  	 * Attempts to match a pattern on the given pathname. Patterns may use
  	 * the following special characters:
  	 *
  	 * - :paramName     Matches a URL segment up to the next /, ?, or #. The
  	 *                  captured string is considered a "param"
  	 * - ()             Wraps a segment of the URL that is optional
  	 * - *              Consumes (non-greedy) all characters up to the next
  	 *                  character in the pattern, or to the end of the URL if
  	 *                  there is none
  	 * - **             Consumes (greedy) all characters up to the next character
  	 *                  in the pattern, or to the end of the URL if there is none
  	 *
  	 *  The function calls callback(error, matched) when finished.
  	 * The return value is an object with the following properties:
  	 *
  	 * - remainingPathname
  	 * - paramNames
  	 * - paramValues
  	 */
  	function matchPattern(pattern, pathname) {
  	  // Ensure pattern starts with leading slash for consistency with pathname.
  	  if (pattern.charAt(0) !== '/') {
  	    pattern = '/' + pattern;
  	  }
  
  	  var _compilePattern2 = compilePattern(pattern);
  
  	  var regexpSource = _compilePattern2.regexpSource;
  	  var paramNames = _compilePattern2.paramNames;
  	  var tokens = _compilePattern2.tokens;
  
  
  	  if (pattern.charAt(pattern.length - 1) !== '/') {
  	    regexpSource += '/?'; // Allow optional path separator at end.
  	  }
  
  	  // Special-case patterns like '*' for catch-all routes.
  	  if (tokens[tokens.length - 1] === '*') {
  	    regexpSource += '$';
  	  }
  
  	  var match = pathname.match(new RegExp('^' + regexpSource, 'i'));
  	  if (match == null) {
  	    return null;
  	  }
  
  	  var matchedPath = match[0];
  	  var remainingPathname = pathname.substr(matchedPath.length);
  
  	  if (remainingPathname) {
  	    // Require that the match ends at a path separator, if we didn't match
  	    // the full path, so any remaining pathname is a new path segment.
  	    if (matchedPath.charAt(matchedPath.length - 1) !== '/') {
  	      return null;
  	    }
  
  	    // If there is a remaining pathname, treat the path separator as part of
  	    // the remaining pathname for properly continuing the match.
  	    remainingPathname = '/' + remainingPathname;
  	  }
  
  	  return {
  	    remainingPathname: remainingPathname,
  	    paramNames: paramNames,
  	    paramValues: match.slice(1).map(function (v) {
  	      return v && decodeURIComponent(v);
  	    })
  	  };
  	}
  
  	function getParamNames(pattern) {
  	  return compilePattern(pattern).paramNames;
  	}
  
  	function getParams(pattern, pathname) {
  	  var match = matchPattern(pattern, pathname);
  	  if (!match) {
  	    return null;
  	  }
  
  	  var paramNames = match.paramNames;
  	  var paramValues = match.paramValues;
  
  	  var params = {};
  
  	  paramNames.forEach(function (paramName, index) {
  	    params[paramName] = paramValues[index];
  	  });
  
  	  return params;
  	}
  
  	/**
  	 * Returns a version of the given pattern with params interpolated. Throws
  	 * if there is a dynamic segment of the pattern for which there is no param.
  	 */
  	function formatPattern(pattern, params) {
  	  params = params || {};
  
  	  var _compilePattern3 = compilePattern(pattern);
  
  	  var tokens = _compilePattern3.tokens;
  
  	  var parenCount = 0,
  	      pathname = '',
  	      splatIndex = 0;
  
  	  var token = void 0,
  	      paramName = void 0,
  	      paramValue = void 0;
  	  for (var i = 0, len = tokens.length; i < len; ++i) {
  	    token = tokens[i];
  
  	    if (token === '*' || token === '**') {
  	      paramValue = Array.isArray(params.splat) ? params.splat[splatIndex++] : params.splat;
  
  	      !(paramValue != null || parenCount > 0) ?  true ? (0, _invariant2.default)(false, 'Missing splat #%s for path "%s"', splatIndex, pattern) : (0, _invariant2.default)(false) : void 0;
  
  	      if (paramValue != null) pathname += encodeURI(paramValue);
  	    } else if (token === '(') {
  	      parenCount += 1;
  	    } else if (token === ')') {
  	      parenCount -= 1;
  	    } else if (token.charAt(0) === ':') {
  	      paramName = token.substring(1);
  	      paramValue = params[paramName];
  
  	      !(paramValue != null || parenCount > 0) ?  true ? (0, _invariant2.default)(false, 'Missing "%s" parameter for path "%s"', paramName, pattern) : (0, _invariant2.default)(false) : void 0;
  
  	      if (paramValue != null) pathname += encodeURIComponent(paramValue);
  	    } else {
  	      pathname += token;
  	    }
  	  }
  
  	  return pathname.replace(/\/+/g, '/');
  	}
  
  /***/ },
  /* 9 */
  /***/ function(module, exports) {
  
  	/**
  	 * Indicates that navigation was caused by a call to history.push.
  	 */
  	'use strict';
  
  	exports.__esModule = true;
  	var PUSH = 'PUSH';
  
  	exports.PUSH = PUSH;
  	/**
  	 * Indicates that navigation was caused by a call to history.replace.
  	 */
  	var REPLACE = 'REPLACE';
  
  	exports.REPLACE = REPLACE;
  	/**
  	 * Indicates that navigation was caused by some other action such
  	 * as using a browser's back/forward buttons and/or manually manipulating
  	 * the URL in a browser's location bar. This is the default.
  	 *
  	 * See https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onpopstate
  	 * for more information.
  	 */
  	var POP = 'POP';
  
  	exports.POP = POP;
  	exports['default'] = {
  	  PUSH: PUSH,
  	  REPLACE: REPLACE,
  	  POP: POP
  	};
  
  /***/ },
  /* 10 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
  
  	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 _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var createReactClass = require('create-react-class');
  
  	var _deprecateObjectProperties = __webpack_require__(11);
  
  	var _deprecateObjectProperties2 = _interopRequireDefault(_deprecateObjectProperties);
  
  	var _getRouteParams = __webpack_require__(46);
  
  	var _getRouteParams2 = _interopRequireDefault(_getRouteParams);
  
  	var _RouteUtils = __webpack_require__(5);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _propTypes = require('prop-types');
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var _React$PropTypes = _propTypes;
  	var array = _React$PropTypes.array;
  	var func = _React$PropTypes.func;
  	var object = _React$PropTypes.object;
  
  	/**
  	 * A <RouterContext> renders the component tree for a given router state
  	 * and sets the history object and the current location in context.
  	 */
  
  	var RouterContext = createReactClass({
  	  displayName: 'RouterContext',
  
  
  	  propTypes: {
  	    history: object,
  	    router: object.isRequired,
  	    location: object.isRequired,
  	    routes: array.isRequired,
  	    params: object.isRequired,
  	    components: array.isRequired,
  	    createElement: func.isRequired
  	  },
  
  	  getDefaultProps: function getDefaultProps() {
  	    return {
  	      createElement: _react2.default.createElement
  	    };
  	  },
  
  
  	  childContextTypes: {
  	    history: object,
  	    location: object.isRequired,
  	    router: object.isRequired
  	  },
  
  	  getChildContext: function getChildContext() {
  	    var _props = this.props;
  	    var router = _props.router;
  	    var history = _props.history;
  	    var location = _props.location;
  
  	    if (!router) {
  	       true ? (0, _routerWarning2.default)(false, '`<RouterContext>` expects a `router` rather than a `history`') : void 0;
  
  	      router = _extends({}, history, {
  	        setRouteLeaveHook: history.listenBeforeLeavingRoute
  	      });
  	      delete router.listenBeforeLeavingRoute;
  	    }
  
  	    if (true) {
  	      location = (0, _deprecateObjectProperties2.default)(location, '`context.location` is deprecated, please use a route component\'s `props.location` instead. http://tiny.cc/router-accessinglocation');
  	    }
  
  	    return { history: history, location: location, router: router };
  	  },
  	  createElement: function createElement(component, props) {
  	    return component == null ? null : this.props.createElement(component, props);
  	  },
  	  render: function render() {
  	    var _this = this;
  
  	    var _props2 = this.props;
  	    var history = _props2.history;
  	    var location = _props2.location;
  	    var routes = _props2.routes;
  	    var params = _props2.params;
  	    var components = _props2.components;
  
  	    var element = null;
  
  	    if (components) {
  	      element = components.reduceRight(function (element, components, index) {
  	        if (components == null) return element; // Don't create new children; use the grandchildren.
  
  	        var route = routes[index];
  	        var routeParams = (0, _getRouteParams2.default)(route, params);
  	        var props = {
  	          history: history,
  	          location: location,
  	          params: params,
  	          route: route,
  	          routeParams: routeParams,
  	          routes: routes
  	        };
  
  	        if ((0, _RouteUtils.isReactChildren)(element)) {
  	          props.children = element;
  	        } else if (element) {
  	          for (var prop in element) {
  	            if (Object.prototype.hasOwnProperty.call(element, prop)) props[prop] = element[prop];
  	          }
  	        }
  
  	        if ((typeof components === 'undefined' ? 'undefined' : _typeof(components)) === 'object') {
  	          var elements = {};
  
  	          for (var key in components) {
  	            if (Object.prototype.hasOwnProperty.call(components, key)) {
  	              // Pass through the key as a prop to createElement to allow
  	              // custom createElement functions to know which named component
  	              // they're rendering, for e.g. matching up to fetched data.
  	              elements[key] = _this.createElement(components[key], _extends({
  	                key: key }, props));
  	            }
  	          }
  
  	          return elements;
  	        }
  
  	        return _this.createElement(components, props);
  	      }, element);
  	    }
  
  	    !(element === null || element === false || _react2.default.isValidElement(element)) ?  true ? (0, _invariant2.default)(false, 'The root route must render a single element') : (0, _invariant2.default)(false) : void 0;
  
  	    return element;
  	  }
  	});
  
  	exports.default = RouterContext;
  
  /***/ },
  /* 11 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.canUseMembrane = undefined;
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var canUseMembrane = exports.canUseMembrane = false;
  
  	// No-op by default.
  	var deprecateObjectProperties = function deprecateObjectProperties(object) {
  	  return object;
  	};
  
  	if (true) {
  	  try {
  	    if (Object.defineProperty({}, 'x', {
  	      get: function get() {
  	        return true;
  	      }
  	    }).x) {
  	      exports.canUseMembrane = canUseMembrane = true;
  	    }
  	    /* eslint-disable no-empty */
  	  } catch (e) {}
  	  /* eslint-enable no-empty */
  
  	  if (canUseMembrane) {
  	    deprecateObjectProperties = function deprecateObjectProperties(object, message) {
  	      // Wrap the deprecated object in a membrane to warn on property access.
  	      var membrane = {};
  
  	      var _loop = function _loop(prop) {
  	        if (!Object.prototype.hasOwnProperty.call(object, prop)) {
  	          return 'continue';
  	        }
  
  	        if (typeof object[prop] === 'function') {
  	          // Can't use fat arrow here because of use of arguments below.
  	          membrane[prop] = function () {
  	             true ? (0, _routerWarning2.default)(false, message) : void 0;
  	            return object[prop].apply(object, arguments);
  	          };
  	          return 'continue';
  	        }
  
  	        // These properties are non-enumerable to prevent React dev tools from
  	        // seeing them and causing spurious warnings when accessing them. In
  	        // principle this could be done with a proxy, but support for the
  	        // ownKeys trap on proxies is not universal, even among browsers that
  	        // otherwise support proxies.
  	        Object.defineProperty(membrane, prop, {
  	          get: function get() {
  	             true ? (0, _routerWarning2.default)(false, message) : void 0;
  	            return object[prop];
  	          }
  	        });
  	      };
  
  	      for (var prop in object) {
  	        var _ret = _loop(prop);
  
  	        if (_ret === 'continue') continue;
  	      }
  
  	      return membrane;
  	    };
  	  }
  	}
  
  	exports.default = deprecateObjectProperties;
  
  /***/ },
  /* 12 */
  /***/ function(module, exports) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
  	exports.canUseDOM = canUseDOM;
  
  /***/ },
  /* 13 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	var _queryString = __webpack_require__(61);
  
  	var _runTransitionHook = __webpack_require__(19);
  
  	var _runTransitionHook2 = _interopRequireDefault(_runTransitionHook);
  
  	var _PathUtils = __webpack_require__(7);
  
  	var _deprecate = __webpack_require__(18);
  
  	var _deprecate2 = _interopRequireDefault(_deprecate);
  
  	var SEARCH_BASE_KEY = '$searchBase';
  
  	function defaultStringifyQuery(query) {
  	  return _queryString.stringify(query).replace(/%20/g, '+');
  	}
  
  	var defaultParseQueryString = _queryString.parse;
  
  	function isNestedObject(object) {
  	  for (var p in object) {
  	    if (Object.prototype.hasOwnProperty.call(object, p) && typeof object[p] === 'object' && !Array.isArray(object[p]) && object[p] !== null) return true;
  	  }return false;
  	}
  
  	/**
  	 * Returns a new createHistory function that may be used to create
  	 * history objects that know how to handle URL queries.
  	 */
  	function useQueries(createHistory) {
  	  return function () {
  	    var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
  	    var history = createHistory(options);
  
  	    var stringifyQuery = options.stringifyQuery;
  	    var parseQueryString = options.parseQueryString;
  
  	    if (typeof stringifyQuery !== 'function') stringifyQuery = defaultStringifyQuery;
  
  	    if (typeof parseQueryString !== 'function') parseQueryString = defaultParseQueryString;
  
  	    function addQuery(location) {
  	      if (location.query == null) {
  	        var search = location.search;
  
  	        location.query = parseQueryString(search.substring(1));
  	        location[SEARCH_BASE_KEY] = { search: search, searchBase: '' };
  	      }
  
  	      // TODO: Instead of all the book-keeping here, this should just strip the
  	      // stringified query from the search.
  
  	      return location;
  	    }
  
  	    function appendQuery(location, query) {
  	      var _extends2;
  
  	      var searchBaseSpec = location[SEARCH_BASE_KEY];
  	      var queryString = query ? stringifyQuery(query) : '';
  	      if (!searchBaseSpec && !queryString) {
  	        return location;
  	      }
  
  	       true ? _warning2['default'](stringifyQuery !== defaultStringifyQuery || !isNestedObject(query), 'useQueries does not stringify nested query objects by default; ' + 'use a custom stringifyQuery function') : undefined;
  
  	      if (typeof location === 'string') location = _PathUtils.parsePath(location);
  
  	      var searchBase = undefined;
  	      if (searchBaseSpec && location.search === searchBaseSpec.search) {
  	        searchBase = searchBaseSpec.searchBase;
  	      } else {
  	        searchBase = location.search || '';
  	      }
  
  	      var search = searchBase;
  	      if (queryString) {
  	        search += (search ? '&' : '?') + queryString;
  	      }
  
  	      return _extends({}, location, (_extends2 = {
  	        search: search
  	      }, _extends2[SEARCH_BASE_KEY] = { search: search, searchBase: searchBase }, _extends2));
  	    }
  
  	    // Override all read methods with query-aware versions.
  	    function listenBefore(hook) {
  	      return history.listenBefore(function (location, callback) {
  	        _runTransitionHook2['default'](hook, addQuery(location), callback);
  	      });
  	    }
  
  	    function listen(listener) {
  	      return history.listen(function (location) {
  	        listener(addQuery(location));
  	      });
  	    }
  
  	    // Override all write methods with query-aware versions.
  	    function push(location) {
  	      history.push(appendQuery(location, location.query));
  	    }
  
  	    function replace(location) {
  	      history.replace(appendQuery(location, location.query));
  	    }
  
  	    function createPath(location, query) {
  	       true ? _warning2['default'](!query, 'the query argument to createPath is deprecated; use a location descriptor instead') : undefined;
  
  	      return history.createPath(appendQuery(location, query || location.query));
  	    }
  
  	    function createHref(location, query) {
  	       true ? _warning2['default'](!query, 'the query argument to createHref is deprecated; use a location descriptor instead') : undefined;
  
  	      return history.createHref(appendQuery(location, query || location.query));
  	    }
  
  	    function createLocation(location) {
  	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
  	        args[_key - 1] = arguments[_key];
  	      }
  
  	      var fullLocation = history.createLocation.apply(history, [appendQuery(location, location.query)].concat(args));
  	      if (location.query) {
  	        fullLocation.query = location.query;
  	      }
  	      return addQuery(fullLocation);
  	    }
  
  	    // deprecated
  	    function pushState(state, path, query) {
  	      if (typeof path === 'string') path = _PathUtils.parsePath(path);
  
  	      push(_extends({ state: state }, path, { query: query }));
  	    }
  
  	    // deprecated
  	    function replaceState(state, path, query) {
  	      if (typeof path === 'string') path = _PathUtils.parsePath(path);
  
  	      replace(_extends({ state: state }, path, { query: query }));
  	    }
  
  	    return _extends({}, history, {
  	      listenBefore: listenBefore,
  	      listen: listen,
  	      push: push,
  	      replace: replace,
  	      createPath: createPath,
  	      createHref: createHref,
  	      createLocation: createLocation,
  
  	      pushState: _deprecate2['default'](pushState, 'pushState is deprecated; use push instead'),
  	      replaceState: _deprecate2['default'](replaceState, 'replaceState is deprecated; use replace instead')
  	    });
  	  };
  	}
  
  	exports['default'] = useQueries;
  	module.exports = exports['default'];
  
  /***/ },
  /* 14 */
  /***/ function(module, exports) {
  
  	"use strict";
  
  	exports.__esModule = true;
  	exports.loopAsync = loopAsync;
  	exports.mapAsync = mapAsync;
  	function loopAsync(turns, work, callback) {
  	  var currentTurn = 0,
  	      isDone = false;
  	  var sync = false,
  	      hasNext = false,
  	      doneArgs = void 0;
  
  	  function done() {
  	    isDone = true;
  	    if (sync) {
  	      // Iterate instead of recursing if possible.
  	      doneArgs = [].concat(Array.prototype.slice.call(arguments));
  	      return;
  	    }
  
  	    callback.apply(this, arguments);
  	  }
  
  	  function next() {
  	    if (isDone) {
  	      return;
  	    }
  
  	    hasNext = true;
  	    if (sync) {
  	      // Iterate instead of recursing if possible.
  	      return;
  	    }
  
  	    sync = true;
  
  	    while (!isDone && currentTurn < turns && hasNext) {
  	      hasNext = false;
  	      work.call(this, currentTurn++, next, done);
  	    }
  
  	    sync = false;
  
  	    if (isDone) {
  	      // This means the loop finished synchronously.
  	      callback.apply(this, doneArgs);
  	      return;
  	    }
  
  	    if (currentTurn >= turns && hasNext) {
  	      isDone = true;
  	      callback();
  	    }
  	  }
  
  	  next();
  	}
  
  	function mapAsync(array, work, callback) {
  	  var length = array.length;
  	  var values = [];
  
  	  if (length === 0) return callback(null, values);
  
  	  var isDone = false,
  	      doneCount = 0;
  
  	  function done(index, error, value) {
  	    if (isDone) return;
  
  	    if (error) {
  	      isDone = true;
  	      callback(error);
  	    } else {
  	      values[index] = value;
  
  	      isDone = ++doneCount === length;
  
  	      if (isDone) callback(null, values);
  	    }
  	  }
  
  	  array.forEach(function (item, index) {
  	    work(item, index, function (error, value) {
  	      done(index, error, value);
  	    });
  	  });
  	}
  
  /***/ },
  /* 15 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.router = exports.routes = exports.route = exports.components = exports.component = exports.location = exports.history = exports.falsy = exports.locationShape = exports.routerShape = undefined;
  
  	var _react = __webpack_require__(2);
  
  	var _deprecateObjectProperties = __webpack_require__(11);
  
  	var _deprecateObjectProperties2 = _interopRequireDefault(_deprecateObjectProperties);
  
  	var _InternalPropTypes = __webpack_require__(6);
  
  	var InternalPropTypes = _interopRequireWildcard(_InternalPropTypes);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var func = _propTypes.func;
  	var object = _propTypes.object;
  	var shape = _propTypes.shape;
  	var string = _propTypes.string;
  	var routerShape = exports.routerShape = shape({
  	  push: func.isRequired,
  	  replace: func.isRequired,
  	  go: func.isRequired,
  	  goBack: func.isRequired,
  	  goForward: func.isRequired,
  	  setRouteLeaveHook: func.isRequired,
  	  isActive: func.isRequired
  	});
  
  	var locationShape = exports.locationShape = shape({
  	  pathname: string.isRequired,
  	  search: string.isRequired,
  	  state: object,
  	  action: string.isRequired,
  	  key: string
  	});
  
  	// Deprecated stuff below:
  
  	var falsy = exports.falsy = InternalPropTypes.falsy;
  	var history = exports.history = InternalPropTypes.history;
  	var location = exports.location = locationShape;
  	var component = exports.component = InternalPropTypes.component;
  	var components = exports.components = InternalPropTypes.components;
  	var route = exports.route = InternalPropTypes.route;
  	var routes = exports.routes = InternalPropTypes.routes;
  	var router = exports.router = routerShape;
  
  	if (true) {
  	  (function () {
  	    var deprecatePropType = function deprecatePropType(propType, message) {
  	      return function () {
  	         true ? (0, _routerWarning2.default)(false, message) : void 0;
  	        return propType.apply(undefined, arguments);
  	      };
  	    };
  
  	    var deprecateInternalPropType = function deprecateInternalPropType(propType) {
  	      return deprecatePropType(propType, 'This prop type is not intended for external use, and was previously exported by mistake. These internal prop types are deprecated for external use, and will be removed in a later version.');
  	    };
  
  	    var deprecateRenamedPropType = function deprecateRenamedPropType(propType, name) {
  	      return deprecatePropType(propType, 'The `' + name + '` prop type is now exported as `' + name + 'Shape` to avoid name conflicts. This export is deprecated and will be removed in a later version.');
  	    };
  
  	    exports.falsy = falsy = deprecateInternalPropType(falsy);
  	    exports.history = history = deprecateInternalPropType(history);
  	    exports.component = component = deprecateInternalPropType(component);
  	    exports.components = components = deprecateInternalPropType(components);
  	    exports.route = route = deprecateInternalPropType(route);
  	    exports.routes = routes = deprecateInternalPropType(routes);
  
  	    exports.location = location = deprecateRenamedPropType(location, 'location');
  	    exports.router = router = deprecateRenamedPropType(router, 'router');
  	  })();
  	}
  
  	var defaultExport = {
  	  falsy: falsy,
  	  history: history,
  	  location: location,
  	  component: component,
  	  components: components,
  	  route: route,
  	  // For some reason, routes was never here.
  	  router: router
  	};
  
  	if (true) {
  	  defaultExport = (0, _deprecateObjectProperties2.default)(defaultExport, 'The default export from `react-router/lib/PropTypes` is deprecated. Please use the named exports instead.');
  	}
  
  	exports.default = defaultExport;
  
  /***/ },
  /* 16 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	exports.default = createTransitionManager;
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _computeChangedRoutes2 = __webpack_require__(44);
  
  	var _computeChangedRoutes3 = _interopRequireDefault(_computeChangedRoutes2);
  
  	var _TransitionUtils = __webpack_require__(41);
  
  	var _isActive2 = __webpack_require__(48);
  
  	var _isActive3 = _interopRequireDefault(_isActive2);
  
  	var _getComponents = __webpack_require__(45);
  
  	var _getComponents2 = _interopRequireDefault(_getComponents);
  
  	var _matchRoutes = __webpack_require__(50);
  
  	var _matchRoutes2 = _interopRequireDefault(_matchRoutes);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function hasAnyProperties(object) {
  	  for (var p in object) {
  	    if (Object.prototype.hasOwnProperty.call(object, p)) return true;
  	  }return false;
  	}
  
  	function createTransitionManager(history, routes) {
  	  var state = {};
  
  	  // Signature should be (location, indexOnly), but needs to support (path,
  	  // query, indexOnly)
  	  function isActive(location) {
  	    var indexOnlyOrDeprecatedQuery = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
  	    var deprecatedIndexOnly = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];
  
  	    var indexOnly = void 0;
  	    if (indexOnlyOrDeprecatedQuery && indexOnlyOrDeprecatedQuery !== true || deprecatedIndexOnly !== null) {
  	       true ? (0, _routerWarning2.default)(false, '`isActive(pathname, query, indexOnly) is deprecated; use `isActive(location, indexOnly)` with a location descriptor instead. http://tiny.cc/router-isActivedeprecated') : void 0;
  	      location = { pathname: location, query: indexOnlyOrDeprecatedQuery };
  	      indexOnly = deprecatedIndexOnly || false;
  	    } else {
  	      location = history.createLocation(location);
  	      indexOnly = indexOnlyOrDeprecatedQuery;
  	    }
  
  	    return (0, _isActive3.default)(location, indexOnly, state.location, state.routes, state.params);
  	  }
  
  	  var partialNextState = void 0;
  
  	  function match(location, callback) {
  	    if (partialNextState && partialNextState.location === location) {
  	      // Continue from where we left off.
  	      finishMatch(partialNextState, callback);
  	    } else {
  	      (0, _matchRoutes2.default)(routes, location, function (error, nextState) {
  	        if (error) {
  	          callback(error);
  	        } else if (nextState) {
  	          finishMatch(_extends({}, nextState, { location: location }), callback);
  	        } else {
  	          callback();
  	        }
  	      });
  	    }
  	  }
  
  	  function finishMatch(nextState, callback) {
  	    var _computeChangedRoutes = (0, _computeChangedRoutes3.default)(state, nextState);
  
  	    var leaveRoutes = _computeChangedRoutes.leaveRoutes;
  	    var changeRoutes = _computeChangedRoutes.changeRoutes;
  	    var enterRoutes = _computeChangedRoutes.enterRoutes;
  
  
  	    (0, _TransitionUtils.runLeaveHooks)(leaveRoutes, state);
  
  	    // Tear down confirmation hooks for left routes
  	    leaveRoutes.filter(function (route) {
  	      return enterRoutes.indexOf(route) === -1;
  	    }).forEach(removeListenBeforeHooksForRoute);
  
  	    // change and enter hooks are run in series
  	    (0, _TransitionUtils.runChangeHooks)(changeRoutes, state, nextState, function (error, redirectInfo) {
  	      if (error || redirectInfo) return handleErrorOrRedirect(error, redirectInfo);
  
  	      (0, _TransitionUtils.runEnterHooks)(enterRoutes, nextState, finishEnterHooks);
  	    });
  
  	    function finishEnterHooks(error, redirectInfo) {
  	      if (error || redirectInfo) return handleErrorOrRedirect(error, redirectInfo);
  
  	      // TODO: Fetch components after state is updated.
  	      (0, _getComponents2.default)(nextState, function (error, components) {
  	        if (error) {
  	          callback(error);
  	        } else {
  	          // TODO: Make match a pure function and have some other API
  	          // for "match and update state".
  	          callback(null, null, state = _extends({}, nextState, { components: components }));
  	        }
  	      });
  	    }
  
  	    function handleErrorOrRedirect(error, redirectInfo) {
  	      if (error) callback(error);else callback(null, redirectInfo);
  	    }
  	  }
  
  	  var RouteGuid = 1;
  
  	  function getRouteID(route) {
  	    var create = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];
  
  	    return route.__id__ || create && (route.__id__ = RouteGuid++);
  	  }
  
  	  var RouteHooks = Object.create(null);
  
  	  function getRouteHooksForRoutes(routes) {
  	    return routes.reduce(function (hooks, route) {
  	      hooks.push.apply(hooks, RouteHooks[getRouteID(route)]);
  	      return hooks;
  	    }, []);
  	  }
  
  	  function transitionHook(location, callback) {
  	    (0, _matchRoutes2.default)(routes, location, function (error, nextState) {
  	      if (nextState == null) {
  	        // TODO: We didn't actually match anything, but hang
  	        // onto error/nextState so we don't have to matchRoutes
  	        // again in the listen callback.
  	        callback();
  	        return;
  	      }
  
  	      // Cache some state here so we don't have to
  	      // matchRoutes() again in the listen callback.
  	      partialNextState = _extends({}, nextState, { location: location });
  
  	      var hooks = getRouteHooksForRoutes((0, _computeChangedRoutes3.default)(state, partialNextState).leaveRoutes);
  
  	      var result = void 0;
  	      for (var i = 0, len = hooks.length; result == null && i < len; ++i) {
  	        // Passing the location arg here indicates to
  	        // the user that this is a transition hook.
  	        result = hooks[i](location);
  	      }
  
  	      callback(result);
  	    });
  	  }
  
  	  /* istanbul ignore next: untestable with Karma */
  	  function beforeUnloadHook() {
  	    // Synchronously check to see if any route hooks want
  	    // to prevent the current window/tab from closing.
  	    if (state.routes) {
  	      var hooks = getRouteHooksForRoutes(state.routes);
  
  	      var message = void 0;
  	      for (var i = 0, len = hooks.length; typeof message !== 'string' && i < len; ++i) {
  	        // Passing no args indicates to the user that this is a
  	        // beforeunload hook. We don't know the next location.
  	        message = hooks[i]();
  	      }
  
  	      return message;
  	    }
  	  }
  
  	  var unlistenBefore = void 0,
  	      unlistenBeforeUnload = void 0;
  
  	  function removeListenBeforeHooksForRoute(route) {
  	    var routeID = getRouteID(route, false);
  	    if (!routeID) {
  	      return;
  	    }
  
  	    delete RouteHooks[routeID];
  
  	    if (!hasAnyProperties(RouteHooks)) {
  	      // teardown transition & beforeunload hooks
  	      if (unlistenBefore) {
  	        unlistenBefore();
  	        unlistenBefore = null;
  	      }
  
  	      if (unlistenBeforeUnload) {
  	        unlistenBeforeUnload();
  	        unlistenBeforeUnload = null;
  	      }
  	    }
  	  }
  
  	  /**
  	   * Registers the given hook function to run before leaving the given route.
  	   *
  	   * During a normal transition, the hook function receives the next location
  	   * as its only argument and can return either a prompt message (string) to show the user,
  	   * to make sure they want to leave the page; or `false`, to prevent the transition.
  	   * Any other return value will have no effect.
  	   *
  	   * During the beforeunload event (in browsers) the hook receives no arguments.
  	   * In this case it must return a prompt message to prevent the transition.
  	   *
  	   * Returns a function that may be used to unbind the listener.
  	   */
  	  function listenBeforeLeavingRoute(route, hook) {
  	    // TODO: Warn if they register for a route that isn't currently
  	    // active. They're probably doing something wrong, like re-creating
  	    // route objects on every location change.
  	    var routeID = getRouteID(route);
  	    var hooks = RouteHooks[routeID];
  
  	    if (!hooks) {
  	      var thereWereNoRouteHooks = !hasAnyProperties(RouteHooks);
  
  	      RouteHooks[routeID] = [hook];
  
  	      if (thereWereNoRouteHooks) {
  	        // setup transition & beforeunload hooks
  	        unlistenBefore = history.listenBefore(transitionHook);
  
  	        if (history.listenBeforeUnload) unlistenBeforeUnload = history.listenBeforeUnload(beforeUnloadHook);
  	      }
  	    } else {
  	      if (hooks.indexOf(hook) === -1) {
  	         true ? (0, _routerWarning2.default)(false, 'adding multiple leave hooks for the same route is deprecated; manage multiple confirmations in your own code instead') : void 0;
  
  	        hooks.push(hook);
  	      }
  	    }
  
  	    return function () {
  	      var hooks = RouteHooks[routeID];
  
  	      if (hooks) {
  	        var newHooks = hooks.filter(function (item) {
  	          return item !== hook;
  	        });
  
  	        if (newHooks.length === 0) {
  	          removeListenBeforeHooksForRoute(route);
  	        } else {
  	          RouteHooks[routeID] = newHooks;
  	        }
  	      }
  	    };
  	  }
  
  	  /**
  	   * This is the API for stateful environments. As the location
  	   * changes, we update state and call the listener. We can also
  	   * gracefully handle errors and redirects.
  	   */
  	  function listen(listener) {
  	    // TODO: Only use a single history listener. Otherwise we'll
  	    // end up with multiple concurrent calls to match.
  	    return history.listen(function (location) {
  	      if (state.location === location) {
  	        listener(null, state);
  	      } else {
  	        match(location, function (error, redirectLocation, nextState) {
  	          if (error) {
  	            listener(error);
  	          } else if (redirectLocation) {
  	            history.replace(redirectLocation);
  	          } else if (nextState) {
  	            listener(null, nextState);
  	          } else {
  	             true ? (0, _routerWarning2.default)(false, 'Location "%s" did not match any routes', location.pathname + location.search + location.hash) : void 0;
  	          }
  	        });
  	      }
  	    });
  	  }
  
  	  return {
  	    isActive: isActive,
  	    match: match,
  	    listenBeforeLeavingRoute: listenBeforeLeavingRoute,
  	    listen: listen
  	  };
  	}
  
  	//export default useRoutes
  
  /***/ },
  /* 17 */
  /***/ function(module, exports) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.addEventListener = addEventListener;
  	exports.removeEventListener = removeEventListener;
  	exports.getHashPath = getHashPath;
  	exports.replaceHashPath = replaceHashPath;
  	exports.getWindowPath = getWindowPath;
  	exports.go = go;
  	exports.getUserConfirmation = getUserConfirmation;
  	exports.supportsHistory = supportsHistory;
  	exports.supportsGoWithoutReloadUsingHash = supportsGoWithoutReloadUsingHash;
  
  	function addEventListener(node, event, listener) {
  	  if (node.addEventListener) {
  	    node.addEventListener(event, listener, false);
  	  } else {
  	    node.attachEvent('on' + event, listener);
  	  }
  	}
  
  	function removeEventListener(node, event, listener) {
  	  if (node.removeEventListener) {
  	    node.removeEventListener(event, listener, false);
  	  } else {
  	    node.detachEvent('on' + event, listener);
  	  }
  	}
  
  	function getHashPath() {
  	  // We can't use window.location.hash here because it's not
  	  // consistent across browsers - Firefox will pre-decode it!
  	  return window.location.href.split('#')[1] || '';
  	}
  
  	function replaceHashPath(path) {
  	  window.location.replace(window.location.pathname + window.location.search + '#' + path);
  	}
  
  	function getWindowPath() {
  	  return window.location.pathname + window.location.search + window.location.hash;
  	}
  
  	function go(n) {
  	  if (n) window.history.go(n);
  	}
  
  	function getUserConfirmation(message, callback) {
  	  callback(window.confirm(message));
  	}
  
  	/**
  	 * Returns true if the HTML5 history API is supported. Taken from Modernizr.
  	 *
  	 * https://github.com/Modernizr/Modernizr/blob/master/LICENSE
  	 * https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
  	 * changed to avoid false negatives for Windows Phones: https://github.com/rackt/react-router/issues/586
  	 */
  
  	function supportsHistory() {
  	  var ua = navigator.userAgent;
  	  if ((ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) && ua.indexOf('Mobile Safari') !== -1 && ua.indexOf('Chrome') === -1 && ua.indexOf('Windows Phone') === -1) {
  	    return false;
  	  }
  	  return window.history && 'pushState' in window.history;
  	}
  
  	/**
  	 * Returns false if using go(n) with hash history causes a full page reload.
  	 */
  
  	function supportsGoWithoutReloadUsingHash() {
  	  var ua = navigator.userAgent;
  	  return ua.indexOf('Firefox') === -1;
  	}
  
  /***/ },
  /* 18 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	function deprecate(fn, message) {
  	  return function () {
  	     true ? _warning2['default'](false, '[history] ' + message) : undefined;
  	    return fn.apply(this, arguments);
  	  };
  	}
  
  	exports['default'] = deprecate;
  	module.exports = exports['default'];
  
  /***/ },
  /* 19 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	function runTransitionHook(hook, location, callback) {
  	  var result = hook(location, callback);
  
  	  if (hook.length < 2) {
  	    // Assume the hook runs synchronously and automatically
  	    // call the callback with the return value.
  	    callback(result);
  	  } else {
  	     true ? _warning2['default'](result === undefined, 'You should not "return" in a transition hook with a callback argument; call the callback instead') : undefined;
  	  }
  	}
  
  	exports['default'] = runTransitionHook;
  	module.exports = exports['default'];
  
  /***/ },
  /* 20 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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 _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _PropTypes = __webpack_require__(15);
  
  	var _propTypes = require('prop-types');
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function _objectWithoutProperties(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 _React$PropTypes = _propTypes;
  	var bool = _React$PropTypes.bool;
  	var object = _React$PropTypes.object;
  	var string = _React$PropTypes.string;
  	var func = _React$PropTypes.func;
  	var oneOfType = _React$PropTypes.oneOfType;
  
  
  	function isLeftClickEvent(event) {
  	  return event.button === 0;
  	}
  
  	function isModifiedEvent(event) {
  	  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
  	}
  
  	// TODO: De-duplicate against hasAnyProperties in createTransitionManager.
  	function isEmptyObject(object) {
  	  for (var p in object) {
  	    if (Object.prototype.hasOwnProperty.call(object, p)) return false;
  	  }return true;
  	}
  
  	function createLocationDescriptor(to, _ref) {
  	  var query = _ref.query;
  	  var hash = _ref.hash;
  	  var state = _ref.state;
  
  	  if (query || hash || state) {
  	    return { pathname: to, query: query, hash: hash, state: state };
  	  }
  
  	  return to;
  	}
  
  	/**
  	 * A <Link> is used to create an <a> element that links to a route.
  	 * When that route is active, the link gets the value of its
  	 * activeClassName prop.
  	 *
  	 * For example, assuming you have the following route:
  	 *
  	 *   <Route path="/posts/:postID" component={Post} />
  	 *
  	 * You could use the following component to link to that route:
  	 *
  	 *   <Link to={`/posts/${post.id}`} />
  	 *
  	 * Links may pass along location state and/or query string parameters
  	 * in the state/query props, respectively.
  	 *
  	 *   <Link ... query={{ show: true }} state={{ the: 'state' }} />
  	 */
  	var Link = createReactClass({
  	  displayName: 'Link',
  
  
  	  contextTypes: {
  	    router: _PropTypes.routerShape
  	  },
  
  	  propTypes: {
  	    to: oneOfType([string, object]),
  	    query: object,
  	    hash: string,
  	    state: object,
  	    activeStyle: object,
  	    activeClassName: string,
  	    onlyActiveOnIndex: bool.isRequired,
  	    onClick: func,
  	    target: string
  	  },
  
  	  getDefaultProps: function getDefaultProps() {
  	    return {
  	      onlyActiveOnIndex: false,
  	      style: {}
  	    };
  	  },
  	  handleClick: function handleClick(event) {
  	    if (this.props.onClick) this.props.onClick(event);
  
  	    if (event.defaultPrevented) return;
  
  	    !this.context.router ?  true ? (0, _invariant2.default)(false, '<Link>s rendered outside of a router context cannot navigate.') : (0, _invariant2.default)(false) : void 0;
  
  	    if (isModifiedEvent(event) || !isLeftClickEvent(event)) return;
  
  	    // If target prop is set (e.g. to "_blank"), let browser handle link.
  	    /* istanbul ignore if: untestable with Karma */
  	    if (this.props.target) return;
  
  	    event.preventDefault();
  
  	    var _props = this.props;
  	    var to = _props.to;
  	    var query = _props.query;
  	    var hash = _props.hash;
  	    var state = _props.state;
  
  	    var location = createLocationDescriptor(to, { query: query, hash: hash, state: state });
  
  	    this.context.router.push(location);
  	  },
  	  render: function render() {
  	    var _props2 = this.props;
  	    var to = _props2.to;
  	    var query = _props2.query;
  	    var hash = _props2.hash;
  	    var state = _props2.state;
  	    var activeClassName = _props2.activeClassName;
  	    var activeStyle = _props2.activeStyle;
  	    var onlyActiveOnIndex = _props2.onlyActiveOnIndex;
  
  	    var props = _objectWithoutProperties(_props2, ['to', 'query', 'hash', 'state', 'activeClassName', 'activeStyle', 'onlyActiveOnIndex']);
  
  	     true ? (0, _routerWarning2.default)(!(query || hash || state), 'the `query`, `hash`, and `state` props on `<Link>` are deprecated, use `<Link to={{ pathname, query, hash, state }}/>. http://tiny.cc/router-isActivedeprecated') : void 0;
  
  	    // Ignore if rendered outside the context of router, simplifies unit testing.
  	    var router = this.context.router;
  
  
  	    if (router) {
  	      // If user does not specify a `to` prop, return an empty anchor tag.
  	      if (to == null) {
  	        return _react2.default.createElement('a', props);
  	      }
  
  	      var location = createLocationDescriptor(to, { query: query, hash: hash, state: state });
  	      props.href = router.createHref(location);
  
  	      if (activeClassName || activeStyle != null && !isEmptyObject(activeStyle)) {
  	        if (router.isActive(location, onlyActiveOnIndex)) {
  	          if (activeClassName) {
  	            if (props.className) {
  	              props.className += ' ' + activeClassName;
  	            } else {
  	              props.className = activeClassName;
  	            }
  	          }
  
  	          if (activeStyle) props.style = _extends({}, props.style, activeStyle);
  	        }
  	      }
  	    }
  
  	    return _react2.default.createElement('a', _extends({}, props, { onClick: this.handleClick }));
  	  }
  	});
  
  	exports.default = Link;
  
  /***/ },
  /* 21 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _RouteUtils = __webpack_require__(5);
  
  	var _PatternUtils = __webpack_require__(8);
  
  	var _InternalPropTypes = __webpack_require__(6);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var _React$PropTypes = _propTypes;
  	var string = _React$PropTypes.string;
  	var object = _React$PropTypes.object;
  
  	/**
  	 * A <Redirect> is used to declare another URL path a client should
  	 * be sent to when they request a given URL.
  	 *
  	 * Redirects are placed alongside routes in the route configuration
  	 * and are traversed in the same manner.
  	 */
  
  	var Redirect = createReactClass({
  	  displayName: 'Redirect',
  
  
  	  statics: {
  	    createRouteFromReactElement: function createRouteFromReactElement(element) {
  	      var route = (0, _RouteUtils.createRouteFromReactElement)(element);
  
  	      if (route.from) route.path = route.from;
  
  	      route.onEnter = function (nextState, replace) {
  	        var location = nextState.location;
  	        var params = nextState.params;
  
  
  	        var pathname = void 0;
  	        if (route.to.charAt(0) === '/') {
  	          pathname = (0, _PatternUtils.formatPattern)(route.to, params);
  	        } else if (!route.to) {
  	          pathname = location.pathname;
  	        } else {
  	          var routeIndex = nextState.routes.indexOf(route);
  	          var parentPattern = Redirect.getRoutePattern(nextState.routes, routeIndex - 1);
  	          var pattern = parentPattern.replace(/\/*$/, '/') + route.to;
  	          pathname = (0, _PatternUtils.formatPattern)(pattern, params);
  	        }
  
  	        replace({
  	          pathname: pathname,
  	          query: route.query || location.query,
  	          state: route.state || location.state
  	        });
  	      };
  
  	      return route;
  	    },
  	    getRoutePattern: function getRoutePattern(routes, routeIndex) {
  	      var parentPattern = '';
  
  	      for (var i = routeIndex; i >= 0; i--) {
  	        var route = routes[i];
  	        var pattern = route.path || '';
  
  	        parentPattern = pattern.replace(/\/*$/, '/') + parentPattern;
  
  	        if (pattern.indexOf('/') === 0) break;
  	      }
  
  	      return '/' + parentPattern;
  	    }
  	  },
  
  	  propTypes: {
  	    path: string,
  	    from: string, // Alias for path
  	    to: string.isRequired,
  	    query: object,
  	    state: object,
  	    onEnter: _InternalPropTypes.falsy,
  	    children: _InternalPropTypes.falsy
  	  },
  
  	  /* istanbul ignore next: sanity check */
  	  render: function render() {
  	     true ?  true ? (0, _invariant2.default)(false, '<Redirect> elements are for router configuration only and should not be rendered') : (0, _invariant2.default)(false) : void 0;
  	  }
  	});
  
  	exports.default = Redirect;
  
  /***/ },
  /* 22 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	exports.createRouterObject = createRouterObject;
  	exports.createRoutingHistory = createRoutingHistory;
  
  	var _deprecateObjectProperties = __webpack_require__(11);
  
  	var _deprecateObjectProperties2 = _interopRequireDefault(_deprecateObjectProperties);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function createRouterObject(history, transitionManager) {
  	  return _extends({}, history, {
  	    setRouteLeaveHook: transitionManager.listenBeforeLeavingRoute,
  	    isActive: transitionManager.isActive
  	  });
  	}
  
  	// deprecated
  	function createRoutingHistory(history, transitionManager) {
  	  history = _extends({}, history, transitionManager);
  
  	  if (true) {
  	    history = (0, _deprecateObjectProperties2.default)(history, '`props.history` and `context.history` are deprecated. Please use `context.router`. http://tiny.cc/router-contextchanges');
  	  }
  
  	  return history;
  	}
  
  /***/ },
  /* 23 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.default = createMemoryHistory;
  
  	var _useQueries = __webpack_require__(13);
  
  	var _useQueries2 = _interopRequireDefault(_useQueries);
  
  	var _useBasename = __webpack_require__(31);
  
  	var _useBasename2 = _interopRequireDefault(_useBasename);
  
  	var _createMemoryHistory = __webpack_require__(59);
  
  	var _createMemoryHistory2 = _interopRequireDefault(_createMemoryHistory);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function createMemoryHistory(options) {
  	  // signatures and type checking differ between `useRoutes` and
  	  // `createMemoryHistory`, have to create `memoryHistory` first because
  	  // `useQueries` doesn't understand the signature
  	  var memoryHistory = (0, _createMemoryHistory2.default)(options);
  	  var createHistory = function createHistory() {
  	    return memoryHistory;
  	  };
  	  var history = (0, _useQueries2.default)((0, _useBasename2.default)(createHistory))(options);
  	  history.__v2_compatible__ = true;
  	  return history;
  	}
  
  /***/ },
  /* 24 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	exports.default = function (createHistory) {
  	  var history = void 0;
  	  if (canUseDOM) history = (0, _useRouterHistory2.default)(createHistory)();
  	  return history;
  	};
  
  	var _useRouterHistory = __webpack_require__(26);
  
  	var _useRouterHistory2 = _interopRequireDefault(_useRouterHistory);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
  
  /***/ },
  /* 25 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	exports.default = makeStateWithLocation;
  
  	var _deprecateObjectProperties = __webpack_require__(11);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function makeStateWithLocation(state, location) {
  	  if (("development") !== 'production' && _deprecateObjectProperties.canUseMembrane) {
  	    var stateWithLocation = _extends({}, state);
  
  	    // I don't use deprecateObjectProperties here because I want to keep the
  	    // same code path between development and production, in that we just
  	    // assign extra properties to the copy of the state object in both cases.
  
  	    var _loop = function _loop(prop) {
  	      if (!Object.prototype.hasOwnProperty.call(location, prop)) {
  	        return 'continue';
  	      }
  
  	      Object.defineProperty(stateWithLocation, prop, {
  	        get: function get() {
  	           true ? (0, _routerWarning2.default)(false, 'Accessing location properties directly from the first argument to `getComponent`, `getComponents`, `getChildRoutes`, and `getIndexRoute` is deprecated. That argument is now the router state (`nextState` or `partialNextState`) rather than the location. To access the location, use `nextState.location` or `partialNextState.location`.') : void 0;
  	          return location[prop];
  	        }
  	      });
  	    };
  
  	    for (var prop in location) {
  	      var _ret = _loop(prop);
  
  	      if (_ret === 'continue') continue;
  	    }
  
  	    return stateWithLocation;
  	  }
  
  	  return _extends({}, state, location);
  	}
  
  /***/ },
  /* 26 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.default = useRouterHistory;
  
  	var _useQueries = __webpack_require__(13);
  
  	var _useQueries2 = _interopRequireDefault(_useQueries);
  
  	var _useBasename = __webpack_require__(31);
  
  	var _useBasename2 = _interopRequireDefault(_useBasename);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function useRouterHistory(createHistory) {
  	  return function (options) {
  	    var history = (0, _useQueries2.default)((0, _useBasename2.default)(createHistory))(options);
  	    history.__v2_compatible__ = true;
  	    return history;
  	  };
  	}
  
  /***/ },
  /* 27 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/*eslint-disable no-empty */
  	'use strict';
  
  	exports.__esModule = true;
  	exports.saveState = saveState;
  	exports.readState = readState;
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	var KeyPrefix = '@@History/';
  	var QuotaExceededErrors = ['QuotaExceededError', 'QUOTA_EXCEEDED_ERR'];
  
  	var SecurityError = 'SecurityError';
  
  	function createKey(key) {
  	  return KeyPrefix + key;
  	}
  
  	function saveState(key, state) {
  	  try {
  	    if (state == null) {
  	      window.sessionStorage.removeItem(createKey(key));
  	    } else {
  	      window.sessionStorage.setItem(createKey(key), JSON.stringify(state));
  	    }
  	  } catch (error) {
  	    if (error.name === SecurityError) {
  	      // Blocking cookies in Chrome/Firefox/Safari throws SecurityError on any
  	      // attempt to access window.sessionStorage.
  	       true ? _warning2['default'](false, '[history] Unable to save state; sessionStorage is not available due to security settings') : undefined;
  
  	      return;
  	    }
  
  	    if (QuotaExceededErrors.indexOf(error.name) >= 0 && window.sessionStorage.length === 0) {
  	      // Safari "private mode" throws QuotaExceededError.
  	       true ? _warning2['default'](false, '[history] Unable to save state; sessionStorage is not available in Safari private mode') : undefined;
  
  	      return;
  	    }
  
  	    throw error;
  	  }
  	}
  
  	function readState(key) {
  	  var json = undefined;
  	  try {
  	    json = window.sessionStorage.getItem(createKey(key));
  	  } catch (error) {
  	    if (error.name === SecurityError) {
  	      // Blocking cookies in Chrome/Firefox/Safari throws SecurityError on any
  	      // attempt to access window.sessionStorage.
  	       true ? _warning2['default'](false, '[history] Unable to read state; sessionStorage is not available due to security settings') : undefined;
  
  	      return null;
  	    }
  	  }
  
  	  if (json) {
  	    try {
  	      return JSON.parse(json);
  	    } catch (error) {
  	      // Ignore invalid JSON.
  	    }
  	  }
  
  	  return null;
  	}
  
  /***/ },
  /* 28 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _ExecutionEnvironment = __webpack_require__(12);
  
  	var _DOMUtils = __webpack_require__(17);
  
  	var _createHistory = __webpack_require__(30);
  
  	var _createHistory2 = _interopRequireDefault(_createHistory);
  
  	function createDOMHistory(options) {
  	  var history = _createHistory2['default'](_extends({
  	    getUserConfirmation: _DOMUtils.getUserConfirmation
  	  }, options, {
  	    go: _DOMUtils.go
  	  }));
  
  	  function listen(listener) {
  	    !_ExecutionEnvironment.canUseDOM ?  true ? _invariant2['default'](false, 'DOM history needs a DOM') : _invariant2['default'](false) : undefined;
  
  	    return history.listen(listener);
  	  }
  
  	  return _extends({}, history, {
  	    listen: listen
  	  });
  	}
  
  	exports['default'] = createDOMHistory;
  	module.exports = exports['default'];
  
  /***/ },
  /* 29 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _Actions = __webpack_require__(9);
  
  	var _PathUtils = __webpack_require__(7);
  
  	var _ExecutionEnvironment = __webpack_require__(12);
  
  	var _DOMUtils = __webpack_require__(17);
  
  	var _DOMStateStorage = __webpack_require__(27);
  
  	var _createDOMHistory = __webpack_require__(28);
  
  	var _createDOMHistory2 = _interopRequireDefault(_createDOMHistory);
  
  	function isAbsolutePath(path) {
  	  return typeof path === 'string' && path.charAt(0) === '/';
  	}
  
  	function ensureSlash() {
  	  var path = _DOMUtils.getHashPath();
  
  	  if (isAbsolutePath(path)) return true;
  
  	  _DOMUtils.replaceHashPath('/' + path);
  
  	  return false;
  	}
  
  	function addQueryStringValueToPath(path, key, value) {
  	  return path + (path.indexOf('?') === -1 ? '?' : '&') + (key + '=' + value);
  	}
  
  	function stripQueryStringValueFromPath(path, key) {
  	  return path.replace(new RegExp('[?&]?' + key + '=[a-zA-Z0-9]+'), '');
  	}
  
  	function getQueryStringValueFromPath(path, key) {
  	  var match = path.match(new RegExp('\\?.*?\\b' + key + '=(.+?)\\b'));
  	  return match && match[1];
  	}
  
  	var DefaultQueryKey = '_k';
  
  	function createHashHistory() {
  	  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
  	  !_ExecutionEnvironment.canUseDOM ?  true ? _invariant2['default'](false, 'Hash history needs a DOM') : _invariant2['default'](false) : undefined;
  
  	  var queryKey = options.queryKey;
  
  	  if (queryKey === undefined || !!queryKey) queryKey = typeof queryKey === 'string' ? queryKey : DefaultQueryKey;
  
  	  function getCurrentLocation() {
  	    var path = _DOMUtils.getHashPath();
  
  	    var key = undefined,
  	        state = undefined;
  	    if (queryKey) {
  	      key = getQueryStringValueFromPath(path, queryKey);
  	      path = stripQueryStringValueFromPath(path, queryKey);
  
  	      if (key) {
  	        state = _DOMStateStorage.readState(key);
  	      } else {
  	        state = null;
  	        key = history.createKey();
  	        _DOMUtils.replaceHashPath(addQueryStringValueToPath(path, queryKey, key));
  	      }
  	    } else {
  	      key = state = null;
  	    }
  
  	    var location = _PathUtils.parsePath(path);
  
  	    return history.createLocation(_extends({}, location, { state: state }), undefined, key);
  	  }
  
  	  function startHashChangeListener(_ref) {
  	    var transitionTo = _ref.transitionTo;
  
  	    function hashChangeListener() {
  	      if (!ensureSlash()) return; // Always make sure hashes are preceeded with a /.
  
  	      transitionTo(getCurrentLocation());
  	    }
  
  	    ensureSlash();
  	    _DOMUtils.addEventListener(window, 'hashchange', hashChangeListener);
  
  	    return function () {
  	      _DOMUtils.removeEventListener(window, 'hashchange', hashChangeListener);
  	    };
  	  }
  
  	  function finishTransition(location) {
  	    var basename = location.basename;
  	    var pathname = location.pathname;
  	    var search = location.search;
  	    var state = location.state;
  	    var action = location.action;
  	    var key = location.key;
  
  	    if (action === _Actions.POP) return; // Nothing to do.
  
  	    var path = (basename || '') + pathname + search;
  
  	    if (queryKey) {
  	      path = addQueryStringValueToPath(path, queryKey, key);
  	      _DOMStateStorage.saveState(key, state);
  	    } else {
  	      // Drop key and state.
  	      location.key = location.state = null;
  	    }
  
  	    var currentHash = _DOMUtils.getHashPath();
  
  	    if (action === _Actions.PUSH) {
  	      if (currentHash !== path) {
  	        window.location.hash = path;
  	      } else {
  	         true ? _warning2['default'](false, 'You cannot PUSH the same path using hash history') : undefined;
  	      }
  	    } else if (currentHash !== path) {
  	      // REPLACE
  	      _DOMUtils.replaceHashPath(path);
  	    }
  	  }
  
  	  var history = _createDOMHistory2['default'](_extends({}, options, {
  	    getCurrentLocation: getCurrentLocation,
  	    finishTransition: finishTransition,
  	    saveState: _DOMStateStorage.saveState
  	  }));
  
  	  var listenerCount = 0,
  	      stopHashChangeListener = undefined;
  
  	  function listenBefore(listener) {
  	    if (++listenerCount === 1) stopHashChangeListener = startHashChangeListener(history);
  
  	    var unlisten = history.listenBefore(listener);
  
  	    return function () {
  	      unlisten();
  
  	      if (--listenerCount === 0) stopHashChangeListener();
  	    };
  	  }
  
  	  function listen(listener) {
  	    if (++listenerCount === 1) stopHashChangeListener = startHashChangeListener(history);
  
  	    var unlisten = history.listen(listener);
  
  	    return function () {
  	      unlisten();
  
  	      if (--listenerCount === 0) stopHashChangeListener();
  	    };
  	  }
  
  	  function push(location) {
  	     true ? _warning2['default'](queryKey || location.state == null, 'You cannot use state without a queryKey it will be dropped') : undefined;
  
  	    history.push(location);
  	  }
  
  	  function replace(location) {
  	     true ? _warning2['default'](queryKey || location.state == null, 'You cannot use state without a queryKey it will be dropped') : undefined;
  
  	    history.replace(location);
  	  }
  
  	  var goIsSupportedWithoutReload = _DOMUtils.supportsGoWithoutReloadUsingHash();
  
  	  function go(n) {
  	     true ? _warning2['default'](goIsSupportedWithoutReload, 'Hash history go(n) causes a full page reload in this browser') : undefined;
  
  	    history.go(n);
  	  }
  
  	  function createHref(path) {
  	    return '#' + history.createHref(path);
  	  }
  
  	  // deprecated
  	  function registerTransitionHook(hook) {
  	    if (++listenerCount === 1) stopHashChangeListener = startHashChangeListener(history);
  
  	    history.registerTransitionHook(hook);
  	  }
  
  	  // deprecated
  	  function unregisterTransitionHook(hook) {
  	    history.unregisterTransitionHook(hook);
  
  	    if (--listenerCount === 0) stopHashChangeListener();
  	  }
  
  	  // deprecated
  	  function pushState(state, path) {
  	     true ? _warning2['default'](queryKey || state == null, 'You cannot use state without a queryKey it will be dropped') : undefined;
  
  	    history.pushState(state, path);
  	  }
  
  	  // deprecated
  	  function replaceState(state, path) {
  	     true ? _warning2['default'](queryKey || state == null, 'You cannot use state without a queryKey it will be dropped') : undefined;
  
  	    history.replaceState(state, path);
  	  }
  
  	  return _extends({}, history, {
  	    listenBefore: listenBefore,
  	    listen: listen,
  	    push: push,
  	    replace: replace,
  	    go: go,
  	    createHref: createHref,
  
  	    registerTransitionHook: registerTransitionHook, // deprecated - warning is in createHistory
  	    unregisterTransitionHook: unregisterTransitionHook, // deprecated - warning is in createHistory
  	    pushState: pushState, // deprecated - warning is in createHistory
  	    replaceState: replaceState // deprecated - warning is in createHistory
  	  });
  	}
  
  	exports['default'] = createHashHistory;
  	module.exports = exports['default'];
  
  /***/ },
  /* 30 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	var _deepEqual = __webpack_require__(53);
  
  	var _deepEqual2 = _interopRequireDefault(_deepEqual);
  
  	var _PathUtils = __webpack_require__(7);
  
  	var _AsyncUtils = __webpack_require__(56);
  
  	var _Actions = __webpack_require__(9);
  
  	var _createLocation2 = __webpack_require__(58);
  
  	var _createLocation3 = _interopRequireDefault(_createLocation2);
  
  	var _runTransitionHook = __webpack_require__(19);
  
  	var _runTransitionHook2 = _interopRequireDefault(_runTransitionHook);
  
  	var _deprecate = __webpack_require__(18);
  
  	var _deprecate2 = _interopRequireDefault(_deprecate);
  
  	function createRandomKey(length) {
  	  return Math.random().toString(36).substr(2, length);
  	}
  
  	function locationsAreEqual(a, b) {
  	  return a.pathname === b.pathname && a.search === b.search &&
  	  //a.action === b.action && // Different action !== location change.
  	  a.key === b.key && _deepEqual2['default'](a.state, b.state);
  	}
  
  	var DefaultKeyLength = 6;
  
  	function createHistory() {
  	  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  	  var getCurrentLocation = options.getCurrentLocation;
  	  var finishTransition = options.finishTransition;
  	  var saveState = options.saveState;
  	  var go = options.go;
  	  var getUserConfirmation = options.getUserConfirmation;
  	  var keyLength = options.keyLength;
  
  	  if (typeof keyLength !== 'number') keyLength = DefaultKeyLength;
  
  	  var transitionHooks = [];
  
  	  function listenBefore(hook) {
  	    transitionHooks.push(hook);
  
  	    return function () {
  	      transitionHooks = transitionHooks.filter(function (item) {
  	        return item !== hook;
  	      });
  	    };
  	  }
  
  	  var allKeys = [];
  	  var changeListeners = [];
  	  var location = undefined;
  
  	  function getCurrent() {
  	    if (pendingLocation && pendingLocation.action === _Actions.POP) {
  	      return allKeys.indexOf(pendingLocation.key);
  	    } else if (location) {
  	      return allKeys.indexOf(location.key);
  	    } else {
  	      return -1;
  	    }
  	  }
  
  	  function updateLocation(newLocation) {
  	    var current = getCurrent();
  
  	    location = newLocation;
  
  	    if (location.action === _Actions.PUSH) {
  	      allKeys = [].concat(allKeys.slice(0, current + 1), [location.key]);
  	    } else if (location.action === _Actions.REPLACE) {
  	      allKeys[current] = location.key;
  	    }
  
  	    changeListeners.forEach(function (listener) {
  	      listener(location);
  	    });
  	  }
  
  	  function listen(listener) {
  	    changeListeners.push(listener);
  
  	    if (location) {
  	      listener(location);
  	    } else {
  	      var _location = getCurrentLocation();
  	      allKeys = [_location.key];
  	      updateLocation(_location);
  	    }
  
  	    return function () {
  	      changeListeners = changeListeners.filter(function (item) {
  	        return item !== listener;
  	      });
  	    };
  	  }
  
  	  function confirmTransitionTo(location, callback) {
  	    _AsyncUtils.loopAsync(transitionHooks.length, function (index, next, done) {
  	      _runTransitionHook2['default'](transitionHooks[index], location, function (result) {
  	        if (result != null) {
  	          done(result);
  	        } else {
  	          next();
  	        }
  	      });
  	    }, function (message) {
  	      if (getUserConfirmation && typeof message === 'string') {
  	        getUserConfirmation(message, function (ok) {
  	          callback(ok !== false);
  	        });
  	      } else {
  	        callback(message !== false);
  	      }
  	    });
  	  }
  
  	  var pendingLocation = undefined;
  
  	  function transitionTo(nextLocation) {
  	    if (location && locationsAreEqual(location, nextLocation)) return; // Nothing to do.
  
  	    pendingLocation = nextLocation;
  
  	    confirmTransitionTo(nextLocation, function (ok) {
  	      if (pendingLocation !== nextLocation) return; // Transition was interrupted.
  
  	      if (ok) {
  	        // treat PUSH to current path like REPLACE to be consistent with browsers
  	        if (nextLocation.action === _Actions.PUSH) {
  	          var prevPath = createPath(location);
  	          var nextPath = createPath(nextLocation);
  
  	          if (nextPath === prevPath && _deepEqual2['default'](location.state, nextLocation.state)) nextLocation.action = _Actions.REPLACE;
  	        }
  
  	        if (finishTransition(nextLocation) !== false) updateLocation(nextLocation);
  	      } else if (location && nextLocation.action === _Actions.POP) {
  	        var prevIndex = allKeys.indexOf(location.key);
  	        var nextIndex = allKeys.indexOf(nextLocation.key);
  
  	        if (prevIndex !== -1 && nextIndex !== -1) go(prevIndex - nextIndex); // Restore the URL.
  	      }
  	    });
  	  }
  
  	  function push(location) {
  	    transitionTo(createLocation(location, _Actions.PUSH, createKey()));
  	  }
  
  	  function replace(location) {
  	    transitionTo(createLocation(location, _Actions.REPLACE, createKey()));
  	  }
  
  	  function goBack() {
  	    go(-1);
  	  }
  
  	  function goForward() {
  	    go(1);
  	  }
  
  	  function createKey() {
  	    return createRandomKey(keyLength);
  	  }
  
  	  function createPath(location) {
  	    if (location == null || typeof location === 'string') return location;
  
  	    var pathname = location.pathname;
  	    var search = location.search;
  	    var hash = location.hash;
  
  	    var result = pathname;
  
  	    if (search) result += search;
  
  	    if (hash) result += hash;
  
  	    return result;
  	  }
  
  	  function createHref(location) {
  	    return createPath(location);
  	  }
  
  	  function createLocation(location, action) {
  	    var key = arguments.length <= 2 || arguments[2] === undefined ? createKey() : arguments[2];
  
  	    if (typeof action === 'object') {
  	       true ? _warning2['default'](false, 'The state (2nd) argument to history.createLocation is deprecated; use a ' + 'location descriptor instead') : undefined;
  
  	      if (typeof location === 'string') location = _PathUtils.parsePath(location);
  
  	      location = _extends({}, location, { state: action });
  
  	      action = key;
  	      key = arguments[3] || createKey();
  	    }
  
  	    return _createLocation3['default'](location, action, key);
  	  }
  
  	  // deprecated
  	  function setState(state) {
  	    if (location) {
  	      updateLocationState(location, state);
  	      updateLocation(location);
  	    } else {
  	      updateLocationState(getCurrentLocation(), state);
  	    }
  	  }
  
  	  function updateLocationState(location, state) {
  	    location.state = _extends({}, location.state, state);
  	    saveState(location.key, location.state);
  	  }
  
  	  // deprecated
  	  function registerTransitionHook(hook) {
  	    if (transitionHooks.indexOf(hook) === -1) transitionHooks.push(hook);
  	  }
  
  	  // deprecated
  	  function unregisterTransitionHook(hook) {
  	    transitionHooks = transitionHooks.filter(function (item) {
  	      return item !== hook;
  	    });
  	  }
  
  	  // deprecated
  	  function pushState(state, path) {
  	    if (typeof path === 'string') path = _PathUtils.parsePath(path);
  
  	    push(_extends({ state: state }, path));
  	  }
  
  	  // deprecated
  	  function replaceState(state, path) {
  	    if (typeof path === 'string') path = _PathUtils.parsePath(path);
  
  	    replace(_extends({ state: state }, path));
  	  }
  
  	  return {
  	    listenBefore: listenBefore,
  	    listen: listen,
  	    transitionTo: transitionTo,
  	    push: push,
  	    replace: replace,
  	    go: go,
  	    goBack: goBack,
  	    goForward: goForward,
  	    createKey: createKey,
  	    createPath: createPath,
  	    createHref: createHref,
  	    createLocation: createLocation,
  
  	    setState: _deprecate2['default'](setState, 'setState is deprecated; use location.key to save state instead'),
  	    registerTransitionHook: _deprecate2['default'](registerTransitionHook, 'registerTransitionHook is deprecated; use listenBefore instead'),
  	    unregisterTransitionHook: _deprecate2['default'](unregisterTransitionHook, 'unregisterTransitionHook is deprecated; use the callback returned from listenBefore instead'),
  	    pushState: _deprecate2['default'](pushState, 'pushState is deprecated; use push instead'),
  	    replaceState: _deprecate2['default'](replaceState, 'replaceState is deprecated; use replace instead')
  	  };
  	}
  
  	exports['default'] = createHistory;
  	module.exports = exports['default'];
  
  /***/ },
  /* 31 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	var _ExecutionEnvironment = __webpack_require__(12);
  
  	var _PathUtils = __webpack_require__(7);
  
  	var _runTransitionHook = __webpack_require__(19);
  
  	var _runTransitionHook2 = _interopRequireDefault(_runTransitionHook);
  
  	var _deprecate = __webpack_require__(18);
  
  	var _deprecate2 = _interopRequireDefault(_deprecate);
  
  	function useBasename(createHistory) {
  	  return function () {
  	    var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
  	    var history = createHistory(options);
  
  	    var basename = options.basename;
  
  	    var checkedBaseHref = false;
  
  	    function checkBaseHref() {
  	      if (checkedBaseHref) {
  	        return;
  	      }
  
  	      // Automatically use the value of <base href> in HTML
  	      // documents as basename if it's not explicitly given.
  	      if (basename == null && _ExecutionEnvironment.canUseDOM) {
  	        var base = document.getElementsByTagName('base')[0];
  	        var baseHref = base && base.getAttribute('href');
  
  	        if (baseHref != null) {
  	          basename = baseHref;
  
  	           true ? _warning2['default'](false, 'Automatically setting basename using <base href> is deprecated and will ' + 'be removed in the next major release. The semantics of <base href> are ' + 'subtly different from basename. Please pass the basename explicitly in ' + 'the options to createHistory') : undefined;
  	        }
  	      }
  
  	      checkedBaseHref = true;
  	    }
  
  	    function addBasename(location) {
  	      checkBaseHref();
  
  	      if (basename && location.basename == null) {
  	        if (location.pathname.indexOf(basename) === 0) {
  	          location.pathname = location.pathname.substring(basename.length);
  	          location.basename = basename;
  
  	          if (location.pathname === '') location.pathname = '/';
  	        } else {
  	          location.basename = '';
  	        }
  	      }
  
  	      return location;
  	    }
  
  	    function prependBasename(location) {
  	      checkBaseHref();
  
  	      if (!basename) return location;
  
  	      if (typeof location === 'string') location = _PathUtils.parsePath(location);
  
  	      var pname = location.pathname;
  	      var normalizedBasename = basename.slice(-1) === '/' ? basename : basename + '/';
  	      var normalizedPathname = pname.charAt(0) === '/' ? pname.slice(1) : pname;
  	      var pathname = normalizedBasename + normalizedPathname;
  
  	      return _extends({}, location, {
  	        pathname: pathname
  	      });
  	    }
  
  	    // Override all read methods with basename-aware versions.
  	    function listenBefore(hook) {
  	      return history.listenBefore(function (location, callback) {
  	        _runTransitionHook2['default'](hook, addBasename(location), callback);
  	      });
  	    }
  
  	    function listen(listener) {
  	      return history.listen(function (location) {
  	        listener(addBasename(location));
  	      });
  	    }
  
  	    // Override all write methods with basename-aware versions.
  	    function push(location) {
  	      history.push(prependBasename(location));
  	    }
  
  	    function replace(location) {
  	      history.replace(prependBasename(location));
  	    }
  
  	    function createPath(location) {
  	      return history.createPath(prependBasename(location));
  	    }
  
  	    function createHref(location) {
  	      return history.createHref(prependBasename(location));
  	    }
  
  	    function createLocation(location) {
  	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
  	        args[_key - 1] = arguments[_key];
  	      }
  
  	      return addBasename(history.createLocation.apply(history, [prependBasename(location)].concat(args)));
  	    }
  
  	    // deprecated
  	    function pushState(state, path) {
  	      if (typeof path === 'string') path = _PathUtils.parsePath(path);
  
  	      push(_extends({ state: state }, path));
  	    }
  
  	    // deprecated
  	    function replaceState(state, path) {
  	      if (typeof path === 'string') path = _PathUtils.parsePath(path);
  
  	      replace(_extends({ state: state }, path));
  	    }
  
  	    return _extends({}, history, {
  	      listenBefore: listenBefore,
  	      listen: listen,
  	      push: push,
  	      replace: replace,
  	      createPath: createPath,
  	      createHref: createHref,
  	      createLocation: createLocation,
  
  	      pushState: _deprecate2['default'](pushState, 'pushState is deprecated; use push instead'),
  	      replaceState: _deprecate2['default'](replaceState, 'replaceState is deprecated; use replace instead')
  	    });
  	  };
  	}
  
  	exports['default'] = useBasename;
  	module.exports = exports['default'];
  
  /***/ },
  /* 32 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _InternalPropTypes = __webpack_require__(6);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	/**
  	 * A mixin that adds the "history" instance variable to components.
  	 */
  	var History = {
  
  	  contextTypes: {
  	    history: _InternalPropTypes.history
  	  },
  
  	  componentWillMount: function componentWillMount() {
  	     true ? (0, _routerWarning2.default)(false, 'the `History` mixin is deprecated, please access `context.router` with your own `contextTypes`. http://tiny.cc/router-historymixin') : void 0;
  	    this.history = this.context.history;
  	  }
  	};
  
  	exports.default = History;
  
  /***/ },
  /* 33 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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 _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _Link = __webpack_require__(20);
  
  	var _Link2 = _interopRequireDefault(_Link);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	/**
  	 * An <IndexLink> is used to link to an <IndexRoute>.
  	 */
  	var IndexLink = createReactClass({
  	  displayName: 'IndexLink',
  	  render: function render() {
  	    return _react2.default.createElement(_Link2.default, _extends({}, this.props, { onlyActiveOnIndex: true }));
  	  }
  	});
  
  	exports.default = IndexLink;
  
  /***/ },
  /* 34 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _Redirect = __webpack_require__(21);
  
  	var _Redirect2 = _interopRequireDefault(_Redirect);
  
  	var _InternalPropTypes = __webpack_require__(6);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var _React$PropTypes = _propTypes;
  	var string = _React$PropTypes.string;
  	var object = _React$PropTypes.object;
  
  	/**
  	 * An <IndexRedirect> is used to redirect from an indexRoute.
  	 */
  
  	var IndexRedirect = createReactClass({
  	  displayName: 'IndexRedirect',
  
  
  	  statics: {
  	    createRouteFromReactElement: function createRouteFromReactElement(element, parentRoute) {
  	      /* istanbul ignore else: sanity check */
  	      if (parentRoute) {
  	        parentRoute.indexRoute = _Redirect2.default.createRouteFromReactElement(element);
  	      } else {
  	         true ? (0, _routerWarning2.default)(false, 'An <IndexRedirect> does not make sense at the root of your route config') : void 0;
  	      }
  	    }
  	  },
  
  	  propTypes: {
  	    to: string.isRequired,
  	    query: object,
  	    state: object,
  	    onEnter: _InternalPropTypes.falsy,
  	    children: _InternalPropTypes.falsy
  	  },
  
  	  /* istanbul ignore next: sanity check */
  	  render: function render() {
  	     true ?  true ? (0, _invariant2.default)(false, '<IndexRedirect> elements are for router configuration only and should not be rendered') : (0, _invariant2.default)(false) : void 0;
  	  }
  	});
  
  	exports.default = IndexRedirect;
  
  /***/ },
  /* 35 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _RouteUtils = __webpack_require__(5);
  
  	var _InternalPropTypes = __webpack_require__(6);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var func = _propTypes.func;
  
  	/**
  	 * An <IndexRoute> is used to specify its parent's <Route indexRoute> in
  	 * a JSX route config.
  	 */
  
  	var IndexRoute = createReactClass({
  	  displayName: 'IndexRoute',
  
  
  	  statics: {
  	    createRouteFromReactElement: function createRouteFromReactElement(element, parentRoute) {
  	      /* istanbul ignore else: sanity check */
  	      if (parentRoute) {
  	        parentRoute.indexRoute = (0, _RouteUtils.createRouteFromReactElement)(element);
  	      } else {
  	         true ? (0, _routerWarning2.default)(false, 'An <IndexRoute> does not make sense at the root of your route config') : void 0;
  	      }
  	    }
  	  },
  
  	  propTypes: {
  	    path: _InternalPropTypes.falsy,
  	    component: _InternalPropTypes.component,
  	    components: _InternalPropTypes.components,
  	    getComponent: func,
  	    getComponents: func
  	  },
  
  	  /* istanbul ignore next: sanity check */
  	  render: function render() {
  	     true ?  true ? (0, _invariant2.default)(false, '<IndexRoute> elements are for router configuration only and should not be rendered') : (0, _invariant2.default)(false) : void 0;
  	  }
  	});
  
  	exports.default = IndexRoute;
  
  /***/ },
  /* 36 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var object = _propTypes.object;
  
  	/**
  	 * The Lifecycle mixin adds the routerWillLeave lifecycle method to a
  	 * component that may be used to cancel a transition or prompt the user
  	 * for confirmation.
  	 *
  	 * On standard transitions, routerWillLeave receives a single argument: the
  	 * location we're transitioning to. To cancel the transition, return false.
  	 * To prompt the user for confirmation, return a prompt message (string).
  	 *
  	 * During the beforeunload event (assuming you're using the useBeforeUnload
  	 * history enhancer), routerWillLeave does not receive a location object
  	 * because it isn't possible for us to know the location we're transitioning
  	 * to. In this case routerWillLeave must return a prompt message to prevent
  	 * the user from closing the window/tab.
  	 */
  
  	var Lifecycle = {
  
  	  contextTypes: {
  	    history: object.isRequired,
  	    // Nested children receive the route as context, either
  	    // set by the route component using the RouteContext mixin
  	    // or by some other ancestor.
  	    route: object
  	  },
  
  	  propTypes: {
  	    // Route components receive the route object as a prop.
  	    route: object
  	  },
  
  	  componentDidMount: function componentDidMount() {
  	     true ? (0, _routerWarning2.default)(false, 'the `Lifecycle` mixin is deprecated, please use `context.router.setRouteLeaveHook(route, hook)`. http://tiny.cc/router-lifecyclemixin') : void 0;
  	    !this.routerWillLeave ?  true ? (0, _invariant2.default)(false, 'The Lifecycle mixin requires you to define a routerWillLeave method') : (0, _invariant2.default)(false) : void 0;
  
  	    var route = this.props.route || this.context.route;
  
  	    !route ?  true ? (0, _invariant2.default)(false, 'The Lifecycle mixin must be used on either a) a <Route component> or ' + 'b) a descendant of a <Route component> that uses the RouteContext mixin') : (0, _invariant2.default)(false) : void 0;
  
  	    this._unlistenBeforeLeavingRoute = this.context.history.listenBeforeLeavingRoute(route, this.routerWillLeave);
  	  },
  	  componentWillUnmount: function componentWillUnmount() {
  	    if (this._unlistenBeforeLeavingRoute) this._unlistenBeforeLeavingRoute();
  	  }
  	};
  
  	exports.default = Lifecycle;
  
  /***/ },
  /* 37 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _RouteUtils = __webpack_require__(5);
  
  	var _InternalPropTypes = __webpack_require__(6);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var _React$PropTypes = _propTypes;
  	var string = _React$PropTypes.string;
  	var func = _React$PropTypes.func;
  
  	/**
  	 * A <Route> is used to declare which components are rendered to the
  	 * page when the URL matches a given pattern.
  	 *
  	 * Routes are arranged in a nested tree structure. When a new URL is
  	 * requested, the tree is searched depth-first to find a route whose
  	 * path matches the URL.  When one is found, all routes in the tree
  	 * that lead to it are considered "active" and their components are
  	 * rendered into the DOM, nested in the same order as in the tree.
  	 */
  
  	var Route = createReactClass({
  	  displayName: 'Route',
  
  
  	  statics: {
  	    createRouteFromReactElement: _RouteUtils.createRouteFromReactElement
  	  },
  
  	  propTypes: {
  	    path: string,
  	    component: _InternalPropTypes.component,
  	    components: _InternalPropTypes.components,
  	    getComponent: func,
  	    getComponents: func
  	  },
  
  	  /* istanbul ignore next: sanity check */
  	  render: function render() {
  	     true ?  true ? (0, _invariant2.default)(false, '<Route> elements are for router configuration only and should not be rendered') : (0, _invariant2.default)(false) : void 0;
  	  }
  	});
  
  	exports.default = Route;
  
  /***/ },
  /* 38 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var object = _propTypes.object;
  
  	/**
  	 * The RouteContext mixin provides a convenient way for route
  	 * components to set the route in context. This is needed for
  	 * routes that render elements that want to use the Lifecycle
  	 * mixin to prevent transitions.
  	 */
  
  	var RouteContext = {
  
  	  propTypes: {
  	    route: object.isRequired
  	  },
  
  	  childContextTypes: {
  	    route: object.isRequired
  	  },
  
  	  getChildContext: function getChildContext() {
  	    return {
  	      route: this.props.route
  	    };
  	  },
  	  componentWillMount: function componentWillMount() {
  	     true ? (0, _routerWarning2.default)(false, 'The `RouteContext` mixin is deprecated. You can provide `this.props.route` on context with your own `contextTypes`. http://tiny.cc/router-routecontextmixin') : void 0;
  	  }
  	};
  
  	exports.default = RouteContext;
  
  /***/ },
  /* 39 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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 _createHashHistory = __webpack_require__(29);
  
  	var _createHashHistory2 = _interopRequireDefault(_createHashHistory);
  
  	var _useQueries = __webpack_require__(13);
  
  	var _useQueries2 = _interopRequireDefault(_useQueries);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _createTransitionManager = __webpack_require__(16);
  
  	var _createTransitionManager2 = _interopRequireDefault(_createTransitionManager);
  
  	var _InternalPropTypes = __webpack_require__(6);
  
  	var _RouterContext = __webpack_require__(10);
  
  	var _RouterContext2 = _interopRequireDefault(_RouterContext);
  
  	var _RouteUtils = __webpack_require__(5);
  
  	var _RouterUtils = __webpack_require__(22);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function _objectWithoutProperties(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; }
  
  	function isDeprecatedHistory(history) {
  	  return !history || !history.__v2_compatible__;
  	}
  
  	/* istanbul ignore next: sanity check */
  	function isUnsupportedHistory(history) {
  	  // v3 histories expose getCurrentLocation, but aren't currently supported.
  	  return history && history.getCurrentLocation;
  	}
  
  	var _React$PropTypes = _propTypes;
  	var func = _React$PropTypes.func;
  	var object = _React$PropTypes.object;
  
  	/**
  	 * A <Router> is a high-level API for automatically setting up
  	 * a router that renders a <RouterContext> with all the props
  	 * it needs each time the URL changes.
  	 */
  
  	var Router = createReactClass({
  	  displayName: 'Router',
  
  
  	  propTypes: {
  	    history: object,
  	    children: _InternalPropTypes.routes,
  	    routes: _InternalPropTypes.routes, // alias for children
  	    render: func,
  	    createElement: func,
  	    onError: func,
  	    onUpdate: func,
  
  	    // Deprecated:
  	    parseQueryString: func,
  	    stringifyQuery: func,
  
  	    // PRIVATE: For client-side rehydration of server match.
  	    matchContext: object
  	  },
  
  	  getDefaultProps: function getDefaultProps() {
  	    return {
  	      render: function render(props) {
  	        return _react2.default.createElement(_RouterContext2.default, props);
  	      }
  	    };
  	  },
  	  getInitialState: function getInitialState() {
  	    return {
  	      location: null,
  	      routes: null,
  	      params: null,
  	      components: null
  	    };
  	  },
  	  handleError: function handleError(error) {
  	    if (this.props.onError) {
  	      this.props.onError.call(this, error);
  	    } else {
  	      // Throw errors by default so we don't silently swallow them!
  	      throw error; // This error probably occurred in getChildRoutes or getComponents.
  	    }
  	  },
  	  componentWillMount: function componentWillMount() {
  	    var _this = this;
  
  	    var _props = this.props;
  	    var parseQueryString = _props.parseQueryString;
  	    var stringifyQuery = _props.stringifyQuery;
  
  	     true ? (0, _routerWarning2.default)(!(parseQueryString || stringifyQuery), '`parseQueryString` and `stringifyQuery` are deprecated. Please create a custom history. http://tiny.cc/router-customquerystring') : void 0;
  
  	    var _createRouterObjects = this.createRouterObjects();
  
  	    var history = _createRouterObjects.history;
  	    var transitionManager = _createRouterObjects.transitionManager;
  	    var router = _createRouterObjects.router;
  
  
  	    this._unlisten = transitionManager.listen(function (error, state) {
  	      if (error) {
  	        _this.handleError(error);
  	      } else {
  	        _this.setState(state, _this.props.onUpdate);
  	      }
  	    });
  
  	    this.history = history;
  	    this.router = router;
  	  },
  	  createRouterObjects: function createRouterObjects() {
  	    var matchContext = this.props.matchContext;
  
  	    if (matchContext) {
  	      return matchContext;
  	    }
  
  	    var history = this.props.history;
  	    var _props2 = this.props;
  	    var routes = _props2.routes;
  	    var children = _props2.children;
  
  
  	    !!isUnsupportedHistory(history) ?  true ? (0, _invariant2.default)(false, 'You have provided a history object created with history v3.x. ' + 'This version of React Router is not compatible with v3 history ' + 'objects. Please use history v2.x instead.') : (0, _invariant2.default)(false) : void 0;
  
  	    if (isDeprecatedHistory(history)) {
  	      history = this.wrapDeprecatedHistory(history);
  	    }
  
  	    var transitionManager = (0, _createTransitionManager2.default)(history, (0, _RouteUtils.createRoutes)(routes || children));
  	    var router = (0, _RouterUtils.createRouterObject)(history, transitionManager);
  	    var routingHistory = (0, _RouterUtils.createRoutingHistory)(history, transitionManager);
  
  	    return { history: routingHistory, transitionManager: transitionManager, router: router };
  	  },
  	  wrapDeprecatedHistory: function wrapDeprecatedHistory(history) {
  	    var _props3 = this.props;
  	    var parseQueryString = _props3.parseQueryString;
  	    var stringifyQuery = _props3.stringifyQuery;
  
  
  	    var createHistory = void 0;
  	    if (history) {
  	       true ? (0, _routerWarning2.default)(false, 'It appears you have provided a deprecated history object to `<Router/>`, please use a history provided by ' + 'React Router with `import { browserHistory } from \'react-router\'` or `import { hashHistory } from \'react-router\'`. ' + 'If you are using a custom history please create it with `useRouterHistory`, see http://tiny.cc/router-usinghistory for details.') : void 0;
  	      createHistory = function createHistory() {
  	        return history;
  	      };
  	    } else {
  	       true ? (0, _routerWarning2.default)(false, '`Router` no longer defaults the history prop to hash history. Please use the `hashHistory` singleton instead. http://tiny.cc/router-defaulthistory') : void 0;
  	      createHistory = _createHashHistory2.default;
  	    }
  
  	    return (0, _useQueries2.default)(createHistory)({ parseQueryString: parseQueryString, stringifyQuery: stringifyQuery });
  	  },
  
  
  	  /* istanbul ignore next: sanity check */
  	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
  	     true ? (0, _routerWarning2.default)(nextProps.history === this.props.history, 'You cannot change <Router history>; it will be ignored') : void 0;
  
  	     true ? (0, _routerWarning2.default)((nextProps.routes || nextProps.children) === (this.props.routes || this.props.children), 'You cannot change <Router routes>; it will be ignored') : void 0;
  	  },
  	  componentWillUnmount: function componentWillUnmount() {
  	    if (this._unlisten) this._unlisten();
  	  },
  	  render: function render() {
  	    var _state = this.state;
  	    var location = _state.location;
  	    var routes = _state.routes;
  	    var params = _state.params;
  	    var components = _state.components;
  	    var _props4 = this.props;
  	    var createElement = _props4.createElement;
  	    var render = _props4.render;
  
  	    var props = _objectWithoutProperties(_props4, ['createElement', 'render']);
  
  	    if (location == null) return null; // Async match
  
  	    // Only forward non-Router-specific props to routing context, as those are
  	    // the only ones that might be custom routing context props.
  	    Object.keys(Router.propTypes).forEach(function (propType) {
  	      return delete props[propType];
  	    });
  
  	    return render(_extends({}, props, {
  	      history: this.history,
  	      router: this.router,
  	      location: location,
  	      routes: routes,
  	      params: params,
  	      components: components,
  	      createElement: createElement
  	    }));
  	  }
  	});
  
  	exports.default = Router;
  
  /***/ },
  /* 40 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _RouterContext = __webpack_require__(10);
  
  	var _RouterContext2 = _interopRequireDefault(_RouterContext);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var RoutingContext = createReactClass({
  	  displayName: 'RoutingContext',
  	  componentWillMount: function componentWillMount() {
  	     true ? (0, _routerWarning2.default)(false, '`RoutingContext` has been renamed to `RouterContext`. Please use `import { RouterContext } from \'react-router\'`. http://tiny.cc/router-routercontext') : void 0;
  	  },
  	  render: function render() {
  	    return _react2.default.createElement(_RouterContext2.default, this.props);
  	  }
  	});
  
  	exports.default = RoutingContext;
  
  /***/ },
  /* 41 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  	exports.runEnterHooks = runEnterHooks;
  	exports.runChangeHooks = runChangeHooks;
  	exports.runLeaveHooks = runLeaveHooks;
  
  	var _AsyncUtils = __webpack_require__(14);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function createTransitionHook(hook, route, asyncArity) {
  	  return function () {
  	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
  	      args[_key] = arguments[_key];
  	    }
  
  	    hook.apply(route, args);
  
  	    if (hook.length < asyncArity) {
  	      var callback = args[args.length - 1];
  	      // Assume hook executes synchronously and
  	      // automatically call the callback.
  	      callback();
  	    }
  	  };
  	}
  
  	function getEnterHooks(routes) {
  	  return routes.reduce(function (hooks, route) {
  	    if (route.onEnter) hooks.push(createTransitionHook(route.onEnter, route, 3));
  
  	    return hooks;
  	  }, []);
  	}
  
  	function getChangeHooks(routes) {
  	  return routes.reduce(function (hooks, route) {
  	    if (route.onChange) hooks.push(createTransitionHook(route.onChange, route, 4));
  	    return hooks;
  	  }, []);
  	}
  
  	function runTransitionHooks(length, iter, callback) {
  	  if (!length) {
  	    callback();
  	    return;
  	  }
  
  	  var redirectInfo = void 0;
  	  function replace(location, deprecatedPathname, deprecatedQuery) {
  	    if (deprecatedPathname) {
  	       true ? (0, _routerWarning2.default)(false, '`replaceState(state, pathname, query) is deprecated; use `replace(location)` with a location descriptor instead. http://tiny.cc/router-isActivedeprecated') : void 0;
  	      redirectInfo = {
  	        pathname: deprecatedPathname,
  	        query: deprecatedQuery,
  	        state: location
  	      };
  
  	      return;
  	    }
  
  	    redirectInfo = location;
  	  }
  
  	  (0, _AsyncUtils.loopAsync)(length, function (index, next, done) {
  	    iter(index, replace, function (error) {
  	      if (error || redirectInfo) {
  	        done(error, redirectInfo); // No need to continue.
  	      } else {
  	        next();
  	      }
  	    });
  	  }, callback);
  	}
  
  	/**
  	 * Runs all onEnter hooks in the given array of routes in order
  	 * with onEnter(nextState, replace, callback) and calls
  	 * callback(error, redirectInfo) when finished. The first hook
  	 * to use replace short-circuits the loop.
  	 *
  	 * If a hook needs to run asynchronously, it may use the callback
  	 * function. However, doing so will cause the transition to pause,
  	 * which could lead to a non-responsive UI if the hook is slow.
  	 */
  	function runEnterHooks(routes, nextState, callback) {
  	  var hooks = getEnterHooks(routes);
  	  return runTransitionHooks(hooks.length, function (index, replace, next) {
  	    hooks[index](nextState, replace, next);
  	  }, callback);
  	}
  
  	/**
  	 * Runs all onChange hooks in the given array of routes in order
  	 * with onChange(prevState, nextState, replace, callback) and calls
  	 * callback(error, redirectInfo) when finished. The first hook
  	 * to use replace short-circuits the loop.
  	 *
  	 * If a hook needs to run asynchronously, it may use the callback
  	 * function. However, doing so will cause the transition to pause,
  	 * which could lead to a non-responsive UI if the hook is slow.
  	 */
  	function runChangeHooks(routes, state, nextState, callback) {
  	  var hooks = getChangeHooks(routes);
  	  return runTransitionHooks(hooks.length, function (index, replace, next) {
  	    hooks[index](state, nextState, replace, next);
  	  }, callback);
  	}
  
  	/**
  	 * Runs all onLeave hooks in the given array of routes in order.
  	 */
  	function runLeaveHooks(routes, prevState) {
  	  for (var i = 0, len = routes.length; i < len; ++i) {
  	    if (routes[i].onLeave) routes[i].onLeave.call(routes[i], prevState);
  	  }
  	}
  
  /***/ },
  /* 42 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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 _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _RouterContext = __webpack_require__(10);
  
  	var _RouterContext2 = _interopRequireDefault(_RouterContext);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = function () {
  	  for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {
  	    middlewares[_key] = arguments[_key];
  	  }
  
  	  if (true) {
  	    middlewares.forEach(function (middleware, index) {
  	       true ? (0, _routerWarning2.default)(middleware.renderRouterContext || middleware.renderRouteComponent, 'The middleware specified at index ' + index + ' does not appear to be ' + 'a valid React Router middleware.') : void 0;
  	    });
  	  }
  
  	  var withContext = middlewares.map(function (middleware) {
  	    return middleware.renderRouterContext;
  	  }).filter(Boolean);
  	  var withComponent = middlewares.map(function (middleware) {
  	    return middleware.renderRouteComponent;
  	  }).filter(Boolean);
  
  	  var makeCreateElement = function makeCreateElement() {
  	    var baseCreateElement = arguments.length <= 0 || arguments[0] === undefined ? _react.createElement : arguments[0];
  	    return function (Component, props) {
  	      return withComponent.reduceRight(function (previous, renderRouteComponent) {
  	        return renderRouteComponent(previous, props);
  	      }, baseCreateElement(Component, props));
  	    };
  	  };
  
  	  return function (renderProps) {
  	    return withContext.reduceRight(function (previous, renderRouterContext) {
  	      return renderRouterContext(previous, renderProps);
  	    }, _react2.default.createElement(_RouterContext2.default, _extends({}, renderProps, {
  	      createElement: makeCreateElement(renderProps.createElement)
  	    })));
  	  };
  	};
  
  /***/ },
  /* 43 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _createBrowserHistory = __webpack_require__(57);
  
  	var _createBrowserHistory2 = _interopRequireDefault(_createBrowserHistory);
  
  	var _createRouterHistory = __webpack_require__(24);
  
  	var _createRouterHistory2 = _interopRequireDefault(_createRouterHistory);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = (0, _createRouterHistory2.default)(_createBrowserHistory2.default);
  
  /***/ },
  /* 44 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _PatternUtils = __webpack_require__(8);
  
  	function routeParamsChanged(route, prevState, nextState) {
  	  if (!route.path) return false;
  
  	  var paramNames = (0, _PatternUtils.getParamNames)(route.path);
  
  	  return paramNames.some(function (paramName) {
  	    return prevState.params[paramName] !== nextState.params[paramName];
  	  });
  	}
  
  	/**
  	 * Returns an object of { leaveRoutes, changeRoutes, enterRoutes } determined by
  	 * the change from prevState to nextState. We leave routes if either
  	 * 1) they are not in the next state or 2) they are in the next state
  	 * but their params have changed (i.e. /users/123 => /users/456).
  	 *
  	 * leaveRoutes are ordered starting at the leaf route of the tree
  	 * we're leaving up to the common parent route. enterRoutes are ordered
  	 * from the top of the tree we're entering down to the leaf route.
  	 *
  	 * changeRoutes are any routes that didn't leave or enter during
  	 * the transition.
  	 */
  	function computeChangedRoutes(prevState, nextState) {
  	  var prevRoutes = prevState && prevState.routes;
  	  var nextRoutes = nextState.routes;
  
  	  var leaveRoutes = void 0,
  	      changeRoutes = void 0,
  	      enterRoutes = void 0;
  	  if (prevRoutes) {
  	    (function () {
  	      var parentIsLeaving = false;
  	      leaveRoutes = prevRoutes.filter(function (route) {
  	        if (parentIsLeaving) {
  	          return true;
  	        } else {
  	          var isLeaving = nextRoutes.indexOf(route) === -1 || routeParamsChanged(route, prevState, nextState);
  	          if (isLeaving) parentIsLeaving = true;
  	          return isLeaving;
  	        }
  	      });
  
  	      // onLeave hooks start at the leaf route.
  	      leaveRoutes.reverse();
  
  	      enterRoutes = [];
  	      changeRoutes = [];
  
  	      nextRoutes.forEach(function (route) {
  	        var isNew = prevRoutes.indexOf(route) === -1;
  	        var paramsChanged = leaveRoutes.indexOf(route) !== -1;
  
  	        if (isNew || paramsChanged) enterRoutes.push(route);else changeRoutes.push(route);
  	      });
  	    })();
  	  } else {
  	    leaveRoutes = [];
  	    changeRoutes = [];
  	    enterRoutes = nextRoutes;
  	  }
  
  	  return {
  	    leaveRoutes: leaveRoutes,
  	    changeRoutes: changeRoutes,
  	    enterRoutes: enterRoutes
  	  };
  	}
  
  	exports.default = computeChangedRoutes;
  
  /***/ },
  /* 45 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _AsyncUtils = __webpack_require__(14);
  
  	var _makeStateWithLocation = __webpack_require__(25);
  
  	var _makeStateWithLocation2 = _interopRequireDefault(_makeStateWithLocation);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function getComponentsForRoute(nextState, route, callback) {
  	  if (route.component || route.components) {
  	    callback(null, route.component || route.components);
  	    return;
  	  }
  
  	  var getComponent = route.getComponent || route.getComponents;
  	  if (!getComponent) {
  	    callback();
  	    return;
  	  }
  
  	  var location = nextState.location;
  
  	  var nextStateWithLocation = (0, _makeStateWithLocation2.default)(nextState, location);
  
  	  getComponent.call(route, nextStateWithLocation, callback);
  	}
  
  	/**
  	 * Asynchronously fetches all components needed for the given router
  	 * state and calls callback(error, components) when finished.
  	 *
  	 * Note: This operation may finish synchronously if no routes have an
  	 * asynchronous getComponents method.
  	 */
  	function getComponents(nextState, callback) {
  	  (0, _AsyncUtils.mapAsync)(nextState.routes, function (route, index, callback) {
  	    getComponentsForRoute(nextState, route, callback);
  	  }, callback);
  	}
  
  	exports.default = getComponents;
  
  /***/ },
  /* 46 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _PatternUtils = __webpack_require__(8);
  
  	/**
  	 * Extracts an object of params the given route cares about from
  	 * the given params object.
  	 */
  	function getRouteParams(route, params) {
  	  var routeParams = {};
  
  	  if (!route.path) return routeParams;
  
  	  (0, _PatternUtils.getParamNames)(route.path).forEach(function (p) {
  	    if (Object.prototype.hasOwnProperty.call(params, p)) {
  	      routeParams[p] = params[p];
  	    }
  	  });
  
  	  return routeParams;
  	}
  
  	exports.default = getRouteParams;
  
  /***/ },
  /* 47 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _createHashHistory = __webpack_require__(29);
  
  	var _createHashHistory2 = _interopRequireDefault(_createHashHistory);
  
  	var _createRouterHistory = __webpack_require__(24);
  
  	var _createRouterHistory2 = _interopRequireDefault(_createRouterHistory);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = (0, _createRouterHistory2.default)(_createHashHistory2.default);
  
  /***/ },
  /* 48 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
  
  	exports.default = isActive;
  
  	var _PatternUtils = __webpack_require__(8);
  
  	function deepEqual(a, b) {
  	  if (a == b) return true;
  
  	  if (a == null || b == null) return false;
  
  	  if (Array.isArray(a)) {
  	    return Array.isArray(b) && a.length === b.length && a.every(function (item, index) {
  	      return deepEqual(item, b[index]);
  	    });
  	  }
  
  	  if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) === 'object') {
  	    for (var p in a) {
  	      if (!Object.prototype.hasOwnProperty.call(a, p)) {
  	        continue;
  	      }
  
  	      if (a[p] === undefined) {
  	        if (b[p] !== undefined) {
  	          return false;
  	        }
  	      } else if (!Object.prototype.hasOwnProperty.call(b, p)) {
  	        return false;
  	      } else if (!deepEqual(a[p], b[p])) {
  	        return false;
  	      }
  	    }
  
  	    return true;
  	  }
  
  	  return String(a) === String(b);
  	}
  
  	/**
  	 * Returns true if the current pathname matches the supplied one, net of
  	 * leading and trailing slash normalization. This is sufficient for an
  	 * indexOnly route match.
  	 */
  	function pathIsActive(pathname, currentPathname) {
  	  // Normalize leading slash for consistency. Leading slash on pathname has
  	  // already been normalized in isActive. See caveat there.
  	  if (currentPathname.charAt(0) !== '/') {
  	    currentPathname = '/' + currentPathname;
  	  }
  
  	  // Normalize the end of both path names too. Maybe `/foo/` shouldn't show
  	  // `/foo` as active, but in this case, we would already have failed the
  	  // match.
  	  if (pathname.charAt(pathname.length - 1) !== '/') {
  	    pathname += '/';
  	  }
  	  if (currentPathname.charAt(currentPathname.length - 1) !== '/') {
  	    currentPathname += '/';
  	  }
  
  	  return currentPathname === pathname;
  	}
  
  	/**
  	 * Returns true if the given pathname matches the active routes and params.
  	 */
  	function routeIsActive(pathname, routes, params) {
  	  var remainingPathname = pathname,
  	      paramNames = [],
  	      paramValues = [];
  
  	  // for...of would work here but it's probably slower post-transpilation.
  	  for (var i = 0, len = routes.length; i < len; ++i) {
  	    var route = routes[i];
  	    var pattern = route.path || '';
  
  	    if (pattern.charAt(0) === '/') {
  	      remainingPathname = pathname;
  	      paramNames = [];
  	      paramValues = [];
  	    }
  
  	    if (remainingPathname !== null && pattern) {
  	      var matched = (0, _PatternUtils.matchPattern)(pattern, remainingPathname);
  	      if (matched) {
  	        remainingPathname = matched.remainingPathname;
  	        paramNames = [].concat(paramNames, matched.paramNames);
  	        paramValues = [].concat(paramValues, matched.paramValues);
  	      } else {
  	        remainingPathname = null;
  	      }
  
  	      if (remainingPathname === '') {
  	        // We have an exact match on the route. Just check that all the params
  	        // match.
  	        // FIXME: This doesn't work on repeated params.
  	        return paramNames.every(function (paramName, index) {
  	          return String(paramValues[index]) === String(params[paramName]);
  	        });
  	      }
  	    }
  	  }
  
  	  return false;
  	}
  
  	/**
  	 * Returns true if all key/value pairs in the given query are
  	 * currently active.
  	 */
  	function queryIsActive(query, activeQuery) {
  	  if (activeQuery == null) return query == null;
  
  	  if (query == null) return true;
  
  	  return deepEqual(query, activeQuery);
  	}
  
  	/**
  	 * Returns true if a <Link> to the given pathname/query combination is
  	 * currently active.
  	 */
  	function isActive(_ref, indexOnly, currentLocation, routes, params) {
  	  var pathname = _ref.pathname;
  	  var query = _ref.query;
  
  	  if (currentLocation == null) return false;
  
  	  // TODO: This is a bit ugly. It keeps around support for treating pathnames
  	  // without preceding slashes as absolute paths, but possibly also works
  	  // around the same quirks with basenames as in matchRoutes.
  	  if (pathname.charAt(0) !== '/') {
  	    pathname = '/' + pathname;
  	  }
  
  	  if (!pathIsActive(pathname, currentLocation.pathname)) {
  	    // The path check is necessary and sufficient for indexOnly, but otherwise
  	    // we still need to check the routes.
  	    if (indexOnly || !routeIsActive(pathname, routes, params)) {
  	      return false;
  	    }
  	  }
  
  	  return queryIsActive(query, currentLocation.query);
  	}
  
  /***/ },
  /* 49 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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 _Actions = __webpack_require__(9);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _createMemoryHistory = __webpack_require__(23);
  
  	var _createMemoryHistory2 = _interopRequireDefault(_createMemoryHistory);
  
  	var _createTransitionManager = __webpack_require__(16);
  
  	var _createTransitionManager2 = _interopRequireDefault(_createTransitionManager);
  
  	var _RouteUtils = __webpack_require__(5);
  
  	var _RouterUtils = __webpack_require__(22);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function _objectWithoutProperties(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; }
  
  	/**
  	 * A high-level API to be used for server-side rendering.
  	 *
  	 * This function matches a location to a set of routes and calls
  	 * callback(error, redirectLocation, renderProps) when finished.
  	 *
  	 * Note: You probably don't want to use this in a browser unless you're using
  	 * server-side rendering with async routes.
  	 */
  	function match(_ref, callback) {
  	  var history = _ref.history;
  	  var routes = _ref.routes;
  	  var location = _ref.location;
  
  	  var options = _objectWithoutProperties(_ref, ['history', 'routes', 'location']);
  
  	  !(history || location) ?  true ? (0, _invariant2.default)(false, 'match needs a history or a location') : (0, _invariant2.default)(false) : void 0;
  
  	  history = history ? history : (0, _createMemoryHistory2.default)(options);
  	  var transitionManager = (0, _createTransitionManager2.default)(history, (0, _RouteUtils.createRoutes)(routes));
  
  	  var unlisten = void 0;
  
  	  if (location) {
  	    // Allow match({ location: '/the/path', ... })
  	    location = history.createLocation(location);
  	  } else {
  	    // Pick up the location from the history via synchronous history.listen
  	    // call if needed.
  	    unlisten = history.listen(function (historyLocation) {
  	      location = historyLocation;
  	    });
  	  }
  
  	  var router = (0, _RouterUtils.createRouterObject)(history, transitionManager);
  	  history = (0, _RouterUtils.createRoutingHistory)(history, transitionManager);
  
  	  transitionManager.match(location, function (error, redirectLocation, nextState) {
  	    callback(error, redirectLocation && router.createLocation(redirectLocation, _Actions.REPLACE), nextState && _extends({}, nextState, {
  	      history: history,
  	      router: router,
  	      matchContext: { history: history, transitionManager: transitionManager, router: router }
  	    }));
  
  	    // Defer removing the listener to here to prevent DOM histories from having
  	    // to unwind DOM event listeners unnecessarily, in case callback renders a
  	    // <Router> and attaches another history listener.
  	    if (unlisten) {
  	      unlisten();
  	    }
  	  });
  	}
  
  	exports.default = match;
  
  /***/ },
  /* 50 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
  
  	exports.default = matchRoutes;
  
  	var _AsyncUtils = __webpack_require__(14);
  
  	var _makeStateWithLocation = __webpack_require__(25);
  
  	var _makeStateWithLocation2 = _interopRequireDefault(_makeStateWithLocation);
  
  	var _PatternUtils = __webpack_require__(8);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	var _RouteUtils = __webpack_require__(5);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function getChildRoutes(route, location, paramNames, paramValues, callback) {
  	  if (route.childRoutes) {
  	    return [null, route.childRoutes];
  	  }
  	  if (!route.getChildRoutes) {
  	    return [];
  	  }
  
  	  var sync = true,
  	      result = void 0;
  
  	  var partialNextState = {
  	    location: location,
  	    params: createParams(paramNames, paramValues)
  	  };
  
  	  var partialNextStateWithLocation = (0, _makeStateWithLocation2.default)(partialNextState, location);
  
  	  route.getChildRoutes(partialNextStateWithLocation, function (error, childRoutes) {
  	    childRoutes = !error && (0, _RouteUtils.createRoutes)(childRoutes);
  	    if (sync) {
  	      result = [error, childRoutes];
  	      return;
  	    }
  
  	    callback(error, childRoutes);
  	  });
  
  	  sync = false;
  	  return result; // Might be undefined.
  	}
  
  	function getIndexRoute(route, location, paramNames, paramValues, callback) {
  	  if (route.indexRoute) {
  	    callback(null, route.indexRoute);
  	  } else if (route.getIndexRoute) {
  	    var partialNextState = {
  	      location: location,
  	      params: createParams(paramNames, paramValues)
  	    };
  
  	    var partialNextStateWithLocation = (0, _makeStateWithLocation2.default)(partialNextState, location);
  
  	    route.getIndexRoute(partialNextStateWithLocation, function (error, indexRoute) {
  	      callback(error, !error && (0, _RouteUtils.createRoutes)(indexRoute)[0]);
  	    });
  	  } else if (route.childRoutes) {
  	    (function () {
  	      var pathless = route.childRoutes.filter(function (childRoute) {
  	        return !childRoute.path;
  	      });
  
  	      (0, _AsyncUtils.loopAsync)(pathless.length, function (index, next, done) {
  	        getIndexRoute(pathless[index], location, paramNames, paramValues, function (error, indexRoute) {
  	          if (error || indexRoute) {
  	            var routes = [pathless[index]].concat(Array.isArray(indexRoute) ? indexRoute : [indexRoute]);
  	            done(error, routes);
  	          } else {
  	            next();
  	          }
  	        });
  	      }, function (err, routes) {
  	        callback(null, routes);
  	      });
  	    })();
  	  } else {
  	    callback();
  	  }
  	}
  
  	function assignParams(params, paramNames, paramValues) {
  	  return paramNames.reduce(function (params, paramName, index) {
  	    var paramValue = paramValues && paramValues[index];
  
  	    if (Array.isArray(params[paramName])) {
  	      params[paramName].push(paramValue);
  	    } else if (paramName in params) {
  	      params[paramName] = [params[paramName], paramValue];
  	    } else {
  	      params[paramName] = paramValue;
  	    }
  
  	    return params;
  	  }, params);
  	}
  
  	function createParams(paramNames, paramValues) {
  	  return assignParams({}, paramNames, paramValues);
  	}
  
  	function matchRouteDeep(route, location, remainingPathname, paramNames, paramValues, callback) {
  	  var pattern = route.path || '';
  
  	  if (pattern.charAt(0) === '/') {
  	    remainingPathname = location.pathname;
  	    paramNames = [];
  	    paramValues = [];
  	  }
  
  	  // Only try to match the path if the route actually has a pattern, and if
  	  // we're not just searching for potential nested absolute paths.
  	  if (remainingPathname !== null && pattern) {
  	    try {
  	      var matched = (0, _PatternUtils.matchPattern)(pattern, remainingPathname);
  	      if (matched) {
  	        remainingPathname = matched.remainingPathname;
  	        paramNames = [].concat(paramNames, matched.paramNames);
  	        paramValues = [].concat(paramValues, matched.paramValues);
  	      } else {
  	        remainingPathname = null;
  	      }
  	    } catch (error) {
  	      callback(error);
  	    }
  
  	    // By assumption, pattern is non-empty here, which is the prerequisite for
  	    // actually terminating a match.
  	    if (remainingPathname === '') {
  	      var _ret2 = function () {
  	        var match = {
  	          routes: [route],
  	          params: createParams(paramNames, paramValues)
  	        };
  
  	        getIndexRoute(route, location, paramNames, paramValues, function (error, indexRoute) {
  	          if (error) {
  	            callback(error);
  	          } else {
  	            if (Array.isArray(indexRoute)) {
  	              var _match$routes;
  
  	               true ? (0, _routerWarning2.default)(indexRoute.every(function (route) {
  	                return !route.path;
  	              }), 'Index routes should not have paths') : void 0;
  	              (_match$routes = match.routes).push.apply(_match$routes, indexRoute);
  	            } else if (indexRoute) {
  	               true ? (0, _routerWarning2.default)(!indexRoute.path, 'Index routes should not have paths') : void 0;
  	              match.routes.push(indexRoute);
  	            }
  
  	            callback(null, match);
  	          }
  	        });
  
  	        return {
  	          v: void 0
  	        };
  	      }();
  
  	      if ((typeof _ret2 === 'undefined' ? 'undefined' : _typeof(_ret2)) === "object") return _ret2.v;
  	    }
  	  }
  
  	  if (remainingPathname != null || route.childRoutes) {
  	    // Either a) this route matched at least some of the path or b)
  	    // we don't have to load this route's children asynchronously. In
  	    // either case continue checking for matches in the subtree.
  	    var onChildRoutes = function onChildRoutes(error, childRoutes) {
  	      if (error) {
  	        callback(error);
  	      } else if (childRoutes) {
  	        // Check the child routes to see if any of them match.
  	        matchRoutes(childRoutes, location, function (error, match) {
  	          if (error) {
  	            callback(error);
  	          } else if (match) {
  	            // A child route matched! Augment the match and pass it up the stack.
  	            match.routes.unshift(route);
  	            callback(null, match);
  	          } else {
  	            callback();
  	          }
  	        }, remainingPathname, paramNames, paramValues);
  	      } else {
  	        callback();
  	      }
  	    };
  
  	    var result = getChildRoutes(route, location, paramNames, paramValues, onChildRoutes);
  	    if (result) {
  	      onChildRoutes.apply(undefined, result);
  	    }
  	  } else {
  	    callback();
  	  }
  	}
  
  	/**
  	 * Asynchronously matches the given location to a set of routes and calls
  	 * callback(error, state) when finished. The state object will have the
  	 * following properties:
  	 *
  	 * - routes       An array of routes that matched, in hierarchical order
  	 * - params       An object of URL parameters
  	 *
  	 * Note: This operation may finish synchronously if no routes have an
  	 * asynchronous getChildRoutes method.
  	 */
  	function matchRoutes(routes, location, callback, remainingPathname) {
  	  var paramNames = arguments.length <= 4 || arguments[4] === undefined ? [] : arguments[4];
  	  var paramValues = arguments.length <= 5 || arguments[5] === undefined ? [] : arguments[5];
  
  	  if (remainingPathname === undefined) {
  	    // TODO: This is a little bit ugly, but it works around a quirk in history
  	    // that strips the leading slash from pathnames when using basenames with
  	    // trailing slashes.
  	    if (location.pathname.charAt(0) !== '/') {
  	      location = _extends({}, location, {
  	        pathname: '/' + location.pathname
  	      });
  	    }
  	    remainingPathname = location.pathname;
  	  }
  
  	  (0, _AsyncUtils.loopAsync)(routes.length, function (index, next, done) {
  	    matchRouteDeep(routes[index], location, remainingPathname, paramNames, paramValues, function (error, match) {
  	      if (error || match) {
  	        done(error, match);
  	      } else {
  	        next();
  	      }
  	    });
  	  }, callback);
  	}
  
  /***/ },
  /* 51 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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 _useQueries = __webpack_require__(13);
  
  	var _useQueries2 = _interopRequireDefault(_useQueries);
  
  	var _createTransitionManager = __webpack_require__(16);
  
  	var _createTransitionManager2 = _interopRequireDefault(_createTransitionManager);
  
  	var _routerWarning = __webpack_require__(1);
  
  	var _routerWarning2 = _interopRequireDefault(_routerWarning);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function _objectWithoutProperties(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; }
  
  	/**
  	 * Returns a new createHistory function that may be used to create
  	 * history objects that know about routing.
  	 *
  	 * Enhances history objects with the following methods:
  	 *
  	 * - listen((error, nextState) => {})
  	 * - listenBeforeLeavingRoute(route, (nextLocation) => {})
  	 * - match(location, (error, redirectLocation, nextState) => {})
  	 * - isActive(pathname, query, indexOnly=false)
  	 */
  	function useRoutes(createHistory) {
  	   true ? (0, _routerWarning2.default)(false, '`useRoutes` is deprecated. Please use `createTransitionManager` instead.') : void 0;
  
  	  return function () {
  	    var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
  	    var routes = _ref.routes;
  
  	    var options = _objectWithoutProperties(_ref, ['routes']);
  
  	    var history = (0, _useQueries2.default)(createHistory)(options);
  	    var transitionManager = (0, _createTransitionManager2.default)(history, routes);
  	    return _extends({}, history, transitionManager);
  	  };
  	}
  
  	exports.default = useRoutes;
  
  /***/ },
  /* 52 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	exports.default = withRouter;
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _react = __webpack_require__(2);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _hoistNonReactStatics = __webpack_require__(60);
  
  	var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);
  
  	var _PropTypes = __webpack_require__(15);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	function getDisplayName(WrappedComponent) {
  	  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
  	}
  
  	function withRouter(WrappedComponent, options) {
  	  var withRef = options && options.withRef;
  
  	  var WithRouter = createReactClass({
  	    displayName: 'WithRouter',
  
  	    contextTypes: { router: _PropTypes.routerShape },
  	    propTypes: { router: _PropTypes.routerShape },
  
  	    getWrappedInstance: function getWrappedInstance() {
  	      !withRef ?  true ? (0, _invariant2.default)(false, 'To access the wrapped instance, you need to specify ' + '`{ withRef: true }` as the second argument of the withRouter() call.') : (0, _invariant2.default)(false) : void 0;
  
  	      return this.wrappedInstance;
  	    },
  	    render: function render() {
  	      var _this = this;
  
  	      var router = this.props.router || this.context.router;
  	      var props = _extends({}, this.props, { router: router });
  
  	      if (withRef) {
  	        props.ref = function (c) {
  	          _this.wrappedInstance = c;
  	        };
  	      }
  
  	      return _react2.default.createElement(WrappedComponent, props);
  	    }
  	  });
  
  	  WithRouter.displayName = 'withRouter(' + getDisplayName(WrappedComponent) + ')';
  	  WithRouter.WrappedComponent = WrappedComponent;
  
  	  return (0, _hoistNonReactStatics2.default)(WithRouter, WrappedComponent);
  	}
  
  /***/ },
  /* 53 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var pSlice = Array.prototype.slice;
  	var objectKeys = __webpack_require__(55);
  	var isArguments = __webpack_require__(54);
  
  	var deepEqual = module.exports = function (actual, expected, opts) {
  	  if (!opts) opts = {};
  	  // 7.1. All identical values are equivalent, as determined by ===.
  	  if (actual === expected) {
  	    return true;
  
  	  } else if (actual instanceof Date && expected instanceof Date) {
  	    return actual.getTime() === expected.getTime();
  
  	  // 7.3. Other pairs that do not both pass typeof value == 'object',
  	  // equivalence is determined by ==.
  	  } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {
  	    return opts.strict ? actual === expected : actual == expected;
  
  	  // 7.4. For all other Object pairs, including Array objects, equivalence is
  	  // determined by having the same number of owned properties (as verified
  	  // with Object.prototype.hasOwnProperty.call), the same set of keys
  	  // (although not necessarily the same order), equivalent values for every
  	  // corresponding key, and an identical 'prototype' property. Note: this
  	  // accounts for both named and indexed properties on Arrays.
  	  } else {
  	    return objEquiv(actual, expected, opts);
  	  }
  	}
  
  	function isUndefinedOrNull(value) {
  	  return value === null || value === undefined;
  	}
  
  	function isBuffer (x) {
  	  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;
  	  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
  	    return false;
  	  }
  	  if (x.length > 0 && typeof x[0] !== 'number') return false;
  	  return true;
  	}
  
  	function objEquiv(a, b, opts) {
  	  var i, key;
  	  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
  	    return false;
  	  // an identical 'prototype' property.
  	  if (a.prototype !== b.prototype) return false;
  	  //~~~I've managed to break Object.keys through screwy arguments passing.
  	  //   Converting to array solves the problem.
  	  if (isArguments(a)) {
  	    if (!isArguments(b)) {
  	      return false;
  	    }
  	    a = pSlice.call(a);
  	    b = pSlice.call(b);
  	    return deepEqual(a, b, opts);
  	  }
  	  if (isBuffer(a)) {
  	    if (!isBuffer(b)) {
  	      return false;
  	    }
  	    if (a.length !== b.length) return false;
  	    for (i = 0; i < a.length; i++) {
  	      if (a[i] !== b[i]) return false;
  	    }
  	    return true;
  	  }
  	  try {
  	    var ka = objectKeys(a),
  	        kb = objectKeys(b);
  	  } catch (e) {//happens when one is a string literal and the other isn't
  	    return false;
  	  }
  	  // having the same number of owned properties (keys incorporates
  	  // hasOwnProperty)
  	  if (ka.length != kb.length)
  	    return false;
  	  //the same set of keys (although not necessarily the same order),
  	  ka.sort();
  	  kb.sort();
  	  //~~~cheap key test
  	  for (i = ka.length - 1; i >= 0; i--) {
  	    if (ka[i] != kb[i])
  	      return false;
  	  }
  	  //equivalent values for every corresponding key, and
  	  //~~~possibly expensive deep test
  	  for (i = ka.length - 1; i >= 0; i--) {
  	    key = ka[i];
  	    if (!deepEqual(a[key], b[key], opts)) return false;
  	  }
  	  return typeof a === typeof b;
  	}
  
  
  /***/ },
  /* 54 */
  /***/ function(module, exports) {
  
  	var supportsArgumentsClass = (function(){
  	  return Object.prototype.toString.call(arguments)
  	})() == '[object Arguments]';
  
  	exports = module.exports = supportsArgumentsClass ? supported : unsupported;
  
  	exports.supported = supported;
  	function supported(object) {
  	  return Object.prototype.toString.call(object) == '[object Arguments]';
  	};
  
  	exports.unsupported = unsupported;
  	function unsupported(object){
  	  return object &&
  	    typeof object == 'object' &&
  	    typeof object.length == 'number' &&
  	    Object.prototype.hasOwnProperty.call(object, 'callee') &&
  	    !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||
  	    false;
  	};
  
  
  /***/ },
  /* 55 */
  /***/ function(module, exports) {
  
  	exports = module.exports = typeof Object.keys === 'function'
  	  ? Object.keys : shim;
  
  	exports.shim = shim;
  	function shim (obj) {
  	  var keys = [];
  	  for (var key in obj) keys.push(key);
  	  return keys;
  	}
  
  
  /***/ },
  /* 56 */
  /***/ function(module, exports) {
  
  	"use strict";
  
  	exports.__esModule = true;
  	var _slice = Array.prototype.slice;
  	exports.loopAsync = loopAsync;
  
  	function loopAsync(turns, work, callback) {
  	  var currentTurn = 0,
  	      isDone = false;
  	  var sync = false,
  	      hasNext = false,
  	      doneArgs = undefined;
  
  	  function done() {
  	    isDone = true;
  	    if (sync) {
  	      // Iterate instead of recursing if possible.
  	      doneArgs = [].concat(_slice.call(arguments));
  	      return;
  	    }
  
  	    callback.apply(this, arguments);
  	  }
  
  	  function next() {
  	    if (isDone) {
  	      return;
  	    }
  
  	    hasNext = true;
  	    if (sync) {
  	      // Iterate instead of recursing if possible.
  	      return;
  	    }
  
  	    sync = true;
  
  	    while (!isDone && currentTurn < turns && hasNext) {
  	      hasNext = false;
  	      work.call(this, currentTurn++, next, done);
  	    }
  
  	    sync = false;
  
  	    if (isDone) {
  	      // This means the loop finished synchronously.
  	      callback.apply(this, doneArgs);
  	      return;
  	    }
  
  	    if (currentTurn >= turns && hasNext) {
  	      isDone = true;
  	      callback();
  	    }
  	  }
  
  	  next();
  	}
  
  /***/ },
  /* 57 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _Actions = __webpack_require__(9);
  
  	var _PathUtils = __webpack_require__(7);
  
  	var _ExecutionEnvironment = __webpack_require__(12);
  
  	var _DOMUtils = __webpack_require__(17);
  
  	var _DOMStateStorage = __webpack_require__(27);
  
  	var _createDOMHistory = __webpack_require__(28);
  
  	var _createDOMHistory2 = _interopRequireDefault(_createDOMHistory);
  
  	/**
  	 * Creates and returns a history object that uses HTML5's history API
  	 * (pushState, replaceState, and the popstate event) to manage history.
  	 * This is the recommended method of managing history in browsers because
  	 * it provides the cleanest URLs.
  	 *
  	 * Note: In browsers that do not support the HTML5 history API full
  	 * page reloads will be used to preserve URLs.
  	 */
  	function createBrowserHistory() {
  	  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
  	  !_ExecutionEnvironment.canUseDOM ?  true ? _invariant2['default'](false, 'Browser history needs a DOM') : _invariant2['default'](false) : undefined;
  
  	  var forceRefresh = options.forceRefresh;
  
  	  var isSupported = _DOMUtils.supportsHistory();
  	  var useRefresh = !isSupported || forceRefresh;
  
  	  function getCurrentLocation(historyState) {
  	    try {
  	      historyState = historyState || window.history.state || {};
  	    } catch (e) {
  	      historyState = {};
  	    }
  
  	    var path = _DOMUtils.getWindowPath();
  	    var _historyState = historyState;
  	    var key = _historyState.key;
  
  	    var state = undefined;
  	    if (key) {
  	      state = _DOMStateStorage.readState(key);
  	    } else {
  	      state = null;
  	      key = history.createKey();
  
  	      if (isSupported) window.history.replaceState(_extends({}, historyState, { key: key }), null);
  	    }
  
  	    var location = _PathUtils.parsePath(path);
  
  	    return history.createLocation(_extends({}, location, { state: state }), undefined, key);
  	  }
  
  	  function startPopStateListener(_ref) {
  	    var transitionTo = _ref.transitionTo;
  
  	    function popStateListener(event) {
  	      if (event.state === undefined) return; // Ignore extraneous popstate events in WebKit.
  
  	      transitionTo(getCurrentLocation(event.state));
  	    }
  
  	    _DOMUtils.addEventListener(window, 'popstate', popStateListener);
  
  	    return function () {
  	      _DOMUtils.removeEventListener(window, 'popstate', popStateListener);
  	    };
  	  }
  
  	  function finishTransition(location) {
  	    var basename = location.basename;
  	    var pathname = location.pathname;
  	    var search = location.search;
  	    var hash = location.hash;
  	    var state = location.state;
  	    var action = location.action;
  	    var key = location.key;
  
  	    if (action === _Actions.POP) return; // Nothing to do.
  
  	    _DOMStateStorage.saveState(key, state);
  
  	    var path = (basename || '') + pathname + search + hash;
  	    var historyState = {
  	      key: key
  	    };
  
  	    if (action === _Actions.PUSH) {
  	      if (useRefresh) {
  	        window.location.href = path;
  	        return false; // Prevent location update.
  	      } else {
  	          window.history.pushState(historyState, null, path);
  	        }
  	    } else {
  	      // REPLACE
  	      if (useRefresh) {
  	        window.location.replace(path);
  	        return false; // Prevent location update.
  	      } else {
  	          window.history.replaceState(historyState, null, path);
  	        }
  	    }
  	  }
  
  	  var history = _createDOMHistory2['default'](_extends({}, options, {
  	    getCurrentLocation: getCurrentLocation,
  	    finishTransition: finishTransition,
  	    saveState: _DOMStateStorage.saveState
  	  }));
  
  	  var listenerCount = 0,
  	      stopPopStateListener = undefined;
  
  	  function listenBefore(listener) {
  	    if (++listenerCount === 1) stopPopStateListener = startPopStateListener(history);
  
  	    var unlisten = history.listenBefore(listener);
  
  	    return function () {
  	      unlisten();
  
  	      if (--listenerCount === 0) stopPopStateListener();
  	    };
  	  }
  
  	  function listen(listener) {
  	    if (++listenerCount === 1) stopPopStateListener = startPopStateListener(history);
  
  	    var unlisten = history.listen(listener);
  
  	    return function () {
  	      unlisten();
  
  	      if (--listenerCount === 0) stopPopStateListener();
  	    };
  	  }
  
  	  // deprecated
  	  function registerTransitionHook(hook) {
  	    if (++listenerCount === 1) stopPopStateListener = startPopStateListener(history);
  
  	    history.registerTransitionHook(hook);
  	  }
  
  	  // deprecated
  	  function unregisterTransitionHook(hook) {
  	    history.unregisterTransitionHook(hook);
  
  	    if (--listenerCount === 0) stopPopStateListener();
  	  }
  
  	  return _extends({}, history, {
  	    listenBefore: listenBefore,
  	    listen: listen,
  	    registerTransitionHook: registerTransitionHook,
  	    unregisterTransitionHook: unregisterTransitionHook
  	  });
  	}
  
  	exports['default'] = createBrowserHistory;
  	module.exports = exports['default'];
  
  /***/ },
  /* 58 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	var _Actions = __webpack_require__(9);
  
  	var _PathUtils = __webpack_require__(7);
  
  	function createLocation() {
  	  var location = arguments.length <= 0 || arguments[0] === undefined ? '/' : arguments[0];
  	  var action = arguments.length <= 1 || arguments[1] === undefined ? _Actions.POP : arguments[1];
  	  var key = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];
  
  	  var _fourthArg = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3];
  
  	  if (typeof location === 'string') location = _PathUtils.parsePath(location);
  
  	  if (typeof action === 'object') {
  	     true ? _warning2['default'](false, 'The state (2nd) argument to createLocation is deprecated; use a ' + 'location descriptor instead') : undefined;
  
  	    location = _extends({}, location, { state: action });
  
  	    action = key || _Actions.POP;
  	    key = _fourthArg;
  	  }
  
  	  var pathname = location.pathname || '/';
  	  var search = location.search || '';
  	  var hash = location.hash || '';
  	  var state = location.state || null;
  
  	  return {
  	    pathname: pathname,
  	    search: search,
  	    hash: hash,
  	    state: state,
  	    action: action,
  	    key: key
  	  };
  	}
  
  	exports['default'] = createLocation;
  	module.exports = exports['default'];
  
  /***/ },
  /* 59 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	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; };
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  	var _warning = __webpack_require__(4);
  
  	var _warning2 = _interopRequireDefault(_warning);
  
  	var _invariant = __webpack_require__(3);
  
  	var _invariant2 = _interopRequireDefault(_invariant);
  
  	var _PathUtils = __webpack_require__(7);
  
  	var _Actions = __webpack_require__(9);
  
  	var _createHistory = __webpack_require__(30);
  
  	var _createHistory2 = _interopRequireDefault(_createHistory);
  
  	function createStateStorage(entries) {
  	  return entries.filter(function (entry) {
  	    return entry.state;
  	  }).reduce(function (memo, entry) {
  	    memo[entry.key] = entry.state;
  	    return memo;
  	  }, {});
  	}
  
  	function createMemoryHistory() {
  	  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
  	  if (Array.isArray(options)) {
  	    options = { entries: options };
  	  } else if (typeof options === 'string') {
  	    options = { entries: [options] };
  	  }
  
  	  var history = _createHistory2['default'](_extends({}, options, {
  	    getCurrentLocation: getCurrentLocation,
  	    finishTransition: finishTransition,
  	    saveState: saveState,
  	    go: go
  	  }));
  
  	  var _options = options;
  	  var entries = _options.entries;
  	  var current = _options.current;
  
  	  if (typeof entries === 'string') {
  	    entries = [entries];
  	  } else if (!Array.isArray(entries)) {
  	    entries = ['/'];
  	  }
  
  	  entries = entries.map(function (entry) {
  	    var key = history.createKey();
  
  	    if (typeof entry === 'string') return { pathname: entry, key: key };
  
  	    if (typeof entry === 'object' && entry) return _extends({}, entry, { key: key });
  
  	     true ?  true ? _invariant2['default'](false, 'Unable to create history entry from %s', entry) : _invariant2['default'](false) : undefined;
  	  });
  
  	  if (current == null) {
  	    current = entries.length - 1;
  	  } else {
  	    !(current >= 0 && current < entries.length) ?  true ? _invariant2['default'](false, 'Current index must be >= 0 and < %s, was %s', entries.length, current) : _invariant2['default'](false) : undefined;
  	  }
  
  	  var storage = createStateStorage(entries);
  
  	  function saveState(key, state) {
  	    storage[key] = state;
  	  }
  
  	  function readState(key) {
  	    return storage[key];
  	  }
  
  	  function getCurrentLocation() {
  	    var entry = entries[current];
  	    var basename = entry.basename;
  	    var pathname = entry.pathname;
  	    var search = entry.search;
  
  	    var path = (basename || '') + pathname + (search || '');
  
  	    var key = undefined,
  	        state = undefined;
  	    if (entry.key) {
  	      key = entry.key;
  	      state = readState(key);
  	    } else {
  	      key = history.createKey();
  	      state = null;
  	      entry.key = key;
  	    }
  
  	    var location = _PathUtils.parsePath(path);
  
  	    return history.createLocation(_extends({}, location, { state: state }), undefined, key);
  	  }
  
  	  function canGo(n) {
  	    var index = current + n;
  	    return index >= 0 && index < entries.length;
  	  }
  
  	  function go(n) {
  	    if (n) {
  	      if (!canGo(n)) {
  	         true ? _warning2['default'](false, 'Cannot go(%s) there is not enough history', n) : undefined;
  	        return;
  	      }
  
  	      current += n;
  
  	      var currentLocation = getCurrentLocation();
  
  	      // change action to POP
  	      history.transitionTo(_extends({}, currentLocation, { action: _Actions.POP }));
  	    }
  	  }
  
  	  function finishTransition(location) {
  	    switch (location.action) {
  	      case _Actions.PUSH:
  	        current += 1;
  
  	        // if we are not on the top of stack
  	        // remove rest and push new
  	        if (current < entries.length) entries.splice(current);
  
  	        entries.push(location);
  	        saveState(location.key, location.state);
  	        break;
  	      case _Actions.REPLACE:
  	        entries[current] = location;
  	        saveState(location.key, location.state);
  	        break;
  	    }
  	  }
  
  	  return history;
  	}
  
  	exports['default'] = createMemoryHistory;
  	module.exports = exports['default'];
  
  /***/ },
  /* 60 */
  /***/ function(module, exports) {
  
  	/**
  	 * Copyright 2015, Yahoo! Inc.
  	 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
  	 */
  	'use strict';
  
  	var REACT_STATICS = {
  	    childContextTypes: true,
  	    contextTypes: true,
  	    defaultProps: true,
  	    displayName: true,
  	    getDefaultProps: true,
  	    mixins: true,
  	    propTypes: true,
  	    type: true
  	};
  
  	var KNOWN_STATICS = {
  	    name: true,
  	    length: true,
  	    prototype: true,
  	    caller: true,
  	    arguments: true,
  	    arity: true
  	};
  
  	var isGetOwnPropertySymbolsAvailable = typeof Object.getOwnPropertySymbols === 'function';
  
  	module.exports = function hoistNonReactStatics(targetComponent, sourceComponent, customStatics) {
  	    if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components
  	        var keys = Object.getOwnPropertyNames(sourceComponent);
  
  	        /* istanbul ignore else */
  	        if (isGetOwnPropertySymbolsAvailable) {
  	            keys = keys.concat(Object.getOwnPropertySymbols(sourceComponent));
  	        }
  
  	        for (var i = 0; i < keys.length; ++i) {
  	            if (!REACT_STATICS[keys[i]] && !KNOWN_STATICS[keys[i]] && (!customStatics || !customStatics[keys[i]])) {
  	                try {
  	                    targetComponent[keys[i]] = sourceComponent[keys[i]];
  	                } catch (error) {
  
  	                }
  	            }
  	        }
  	    }
  
  	    return targetComponent;
  	};
  
  
  /***/ },
  /* 61 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var strictUriEncode = __webpack_require__(62);
  
  	exports.extract = function (str) {
  		return str.split('?')[1] || '';
  	};
  
  	exports.parse = function (str) {
  		if (typeof str !== 'string') {
  			return {};
  		}
  
  		str = str.trim().replace(/^(\?|#|&)/, '');
  
  		if (!str) {
  			return {};
  		}
  
  		return str.split('&').reduce(function (ret, param) {
  			var parts = param.replace(/\+/g, ' ').split('=');
  			// Firefox (pre 40) decodes `%3D` to `=`
  			// https://github.com/sindresorhus/query-string/pull/37
  			var key = parts.shift();
  			var val = parts.length > 0 ? parts.join('=') : undefined;
  
  			key = decodeURIComponent(key);
  
  			// missing `=` should be `null`:
  			// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
  			val = val === undefined ? null : decodeURIComponent(val);
  
  			if (!ret.hasOwnProperty(key)) {
  				ret[key] = val;
  			} else if (Array.isArray(ret[key])) {
  				ret[key].push(val);
  			} else {
  				ret[key] = [ret[key], val];
  			}
  
  			return ret;
  		}, {});
  	};
  
  	exports.stringify = function (obj) {
  		return obj ? Object.keys(obj).sort().map(function (key) {
  			var val = obj[key];
  
  			if (val === undefined) {
  				return '';
  			}
  
  			if (val === null) {
  				return key;
  			}
  
  			if (Array.isArray(val)) {
  				return val.slice().sort().map(function (val2) {
  					return strictUriEncode(key) + '=' + strictUriEncode(val2);
  				}).join('&');
  			}
  
  			return strictUriEncode(key) + '=' + strictUriEncode(val);
  		}).filter(function (x) {
  			return x.length > 0;
  		}).join('&') : '';
  	};
  
  
  /***/ },
  /* 62 */
  /***/ function(module, exports) {
  
  	'use strict';
  	module.exports = function (str) {
  		return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
  			return '%' + c.charCodeAt(0).toString(16).toUpperCase();
  		});
  	};
  
  
  /***/ },
  /* 63 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * Copyright 2014-2015, Facebook, Inc.
  	 * All rights reserved.
  	 *
  	 * This source code is licensed under the BSD-style license found in the
  	 * LICENSE file in the root directory of this source tree. An additional grant
  	 * of patent rights can be found in the PATENTS file in the same directory.
  	 */
  
  	'use strict';
  
  	/**
  	 * Similar to invariant but only logs a warning if the condition is not met.
  	 * This can be used to log issues in development environments in critical
  	 * paths. Removing the logging code for production environments will keep the
  	 * same logic and follow the same code paths.
  	 */
  
  	var warning = function() {};
  
  	if (true) {
  	  warning = function(condition, format, args) {
  	    var len = arguments.length;
  	    args = new Array(len > 2 ? len - 2 : 0);
  	    for (var key = 2; key < len; key++) {
  	      args[key - 2] = arguments[key];
  	    }
  	    if (format === undefined) {
  	      throw new Error(
  	        '`warning(condition, format, ...args)` requires a warning ' +
  	        'message argument'
  	      );
  	    }
  
  	    if (format.length < 10 || (/^[s\W]*$/).test(format)) {
  	      throw new Error(
  	        'The warning format should be able to uniquely identify this ' +
  	        'warning. Please, use a more descriptive format than: ' + format
  	      );
  	    }
  
  	    if (!condition) {
  	      var argIndex = 0;
  	      var message = 'Warning: ' +
  	        format.replace(/%s/g, function() {
  	          return args[argIndex++];
  	        });
  	      if (typeof console !== 'undefined') {
  	        console.error(message);
  	      }
  	      try {
  	        // This error was thrown as a convenience so that you can use this stack
  	        // to find the callsite that caused this warning to fire.
  	        throw new Error(message);
  	      } catch(x) {}
  	    }
  	  };
  	}
  
  	module.exports = warning;
  
  
  /***/ }
  /******/ ])
  });
  ;
  