content: 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 _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; }
  
  import createHashHistory from 'history/lib/createHashHistory';
  import useQueries from 'history/lib/useQueries';
  import invariant from 'invariant';
  import React from 'react';
  
  import createTransitionManager from './createTransitionManager';
  import { routes } from './InternalPropTypes';
  import RouterContext from './RouterContext';
  import { createRoutes } from './RouteUtils';
  import { createRouterObject, createRoutingHistory } from './RouterUtils';
  import warning from './routerWarning';
  
  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 = React.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 = React.createClass({
    displayName: 'Router',
  
  
    propTypes: {
      history: object,
      children: routes,
      routes: routes, // alias for children
      render: func,
      createElement: func,
      onError: func,
      onUpdate: func,
  
      // PRIVATE: For client-side rehydration of server match.
      matchContext: object
    },
  
    getDefaultProps: function getDefaultProps() {
      return {
        render: function render(props) {
          return React.createElement(RouterContext, 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;
  
      process.env.NODE_ENV !== 'production' ? warning(!(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) ? process.env.NODE_ENV !== 'production' ? invariant(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.') : invariant(false) : void 0;
  
      if (isDeprecatedHistory(history)) {
        history = this.wrapDeprecatedHistory(history);
      }
  
      var transitionManager = createTransitionManager(history, createRoutes(routes || children));
      var router = createRouterObject(history, transitionManager);
      var routingHistory = 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) {
        process.env.NODE_ENV !== 'production' ? warning(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 {
        process.env.NODE_ENV !== 'production' ? warning(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 = createHashHistory;
      }
  
      return useQueries(createHistory)({ parseQueryString: parseQueryString, stringifyQuery: stringifyQuery });
    },
  
  
    /* istanbul ignore next: sanity check */
    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
      process.env.NODE_ENV !== 'production' ? warning(nextProps.history === this.props.history, 'You cannot change <Router history>; it will be ignored') : void 0;
  
      process.env.NODE_ENV !== 'production' ? warning((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
      }));
    }
  });
  
  export default Router;