content: 'use strict';
  
  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; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  import React, { Component } from 'react';
  
  var _React$PropTypes = React.PropTypes;
  var bool = _React$PropTypes.bool;
  var object = _React$PropTypes.object;
  var string = _React$PropTypes.string;
  var func = _React$PropTypes.func;
  
  function isLeftClickEvent(event) {
    return event.button === 0;
  }
  
  function isModifiedEvent(event) {
    return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
  }
  
  function isEmptyObject(object) {
    for (var p in object) {
      if (object.hasOwnProperty(p)) return false;
    }return true;
  }
  
  /**
   * 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 = (function (_Component) {
    _inherits(Link, _Component);
  
    function Link() {
      _classCallCheck(this, Link);
  
      _Component.apply(this, arguments);
    }
  
    Link.prototype.handleClick = function handleClick(event) {
      var allowTransition = true;
  
      if (this.props.onClick) this.props.onClick(event);
  
      if (isModifiedEvent(event) || !isLeftClickEvent(event)) return;
  
      if (event.defaultPrevented === true) allowTransition = false;
  
      // If target prop is set (e.g. to "_blank") let browser handle link.
      /* istanbul ignore if: untestable with Karma */
      if (this.props.target) {
        if (!allowTransition) event.preventDefault();
  
        return;
      }
  
      event.preventDefault();
  
      if (allowTransition) {
        var _props = this.props;
        var state = _props.state;
        var to = _props.to;
        var query = _props.query;
        var hash = _props.hash;
  
        if (hash) to += hash;
  
        this.context.history.pushState(state, to, query);
      }
    };
  
    Link.prototype.render = function render() {
      var _this = this;
  
      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']);
  
      // Manually override onClick.
      props.onClick = function (e) {
        return _this.handleClick(e);
      };
  
      // Ignore if rendered outside the context of history, simplifies unit testing.
      var history = this.context.history;
  
      if (history) {
        props.href = history.createHref(to, query);
  
        if (hash) props.href += hash;
  
        if (activeClassName || activeStyle != null && !isEmptyObject(activeStyle)) {
          if (history.isActive(to, query, onlyActiveOnIndex)) {
            if (activeClassName) props.className += props.className === '' ? activeClassName : ' ' + activeClassName;
  
            if (activeStyle) props.style = _extends({}, props.style, activeStyle);
          }
        }
      }
  
      return React.createElement('a', props);
    };
  
    return Link;
  })(Component);
  
  Link.contextTypes = {
    history: object
  };
  
  Link.propTypes = {
    to: string.isRequired,
    query: object,
    hash: string,
    state: object,
    activeStyle: object,
    activeClassName: string,
    onlyActiveOnIndex: bool.isRequired,
    onClick: func
  };
  
  Link.defaultProps = {
    onlyActiveOnIndex: false,
    className: '',
    style: {}
  };
  
  export default Link;