text: 'use strict'
  
  Object.defineProperty(exports, '__esModule', {
    value: 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 _createClass = (function() {
    function defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i]
        descriptor.enumerable = descriptor.enumerable || false
        descriptor.configurable = true
        if ('value' in descriptor) descriptor.writable = true
        Object.defineProperty(target, descriptor.key, descriptor)
      }
    }
    return function(Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps)
      if (staticProps) defineProperties(Constructor, staticProps)
      return Constructor
    }
  })()
  
  var _react = require('react')
  
  var _react2 = _interopRequireDefault(_react)
  
  var _propTypes = require('prop-types')
  
  var _propTypes2 = _interopRequireDefault(_propTypes)
  
  var _prefixName = require('./util/prefixName')
  
  var _prefixName2 = _interopRequireDefault(_prefixName)
  
  var _validateComponentProp = require('./util/validateComponentProp')
  
  var _validateComponentProp2 = _interopRequireDefault(_validateComponentProp)
  
  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 _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError('Cannot call a class as a function')
    }
  }
  
  function _possibleConstructorReturn(self, call) {
    if (!self) {
      throw new ReferenceError(
        "this hasn't been initialised - super() hasn't been called"
      )
    }
    return call && (typeof call === 'object' || typeof call === 'function')
      ? call
      : self
  }
  
  function _inherits(subClass, superClass) {
    if (typeof superClass !== 'function' && superClass !== null) {
      throw new TypeError(
        'Super expression must either be null or a function, not ' +
          typeof superClass
      )
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        enumerable: false,
        writable: true,
        configurable: true
      }
    })
    if (superClass)
      Object.setPrototypeOf
        ? Object.setPrototypeOf(subClass, superClass)
        : (subClass.__proto__ = superClass)
  }
  
  var FormSection = (function(_Component) {
    _inherits(FormSection, _Component)
  
    function FormSection(props, context) {
      _classCallCheck(this, FormSection)
  
      var _this = _possibleConstructorReturn(
        this,
        (FormSection.__proto__ || Object.getPrototypeOf(FormSection)).call(
          this,
          props,
          context
        )
      )
  
      if (!context._reduxForm) {
        throw new Error(
          'FormSection must be inside a component decorated with reduxForm()'
        )
      }
      return _this
    }
  
    _createClass(FormSection, [
      {
        key: 'getChildContext',
        value: function getChildContext() {
          var context = this.context,
            name = this.props.name
  
          return {
            _reduxForm: _extends({}, context._reduxForm, {
              sectionPrefix: (0, _prefixName2.default)(context, name)
            })
          }
        }
      },
      {
        key: 'render',
        value: function render() {
          var _props = this.props,
            children = _props.children,
            name = _props.name,
            component = _props.component,
            rest = _objectWithoutProperties(_props, [
              'children',
              'name',
              'component'
            ])
  
          if (_react2.default.isValidElement(children)) {
            return children
          }
  
          return (0, _react.createElement)(
            component,
            _extends({}, rest, {
              children: children
            })
          )
        }
      }
    ])
  
    return FormSection
  })(_react.Component)
  
  FormSection.propTypes = {
    name: _propTypes2.default.string.isRequired,
    component: _validateComponentProp2.default
  }
  
  FormSection.defaultProps = {
    component: 'div'
  }
  
  FormSection.childContextTypes = {
    _reduxForm: _propTypes2.default.object.isRequired
  }
  
  FormSection.contextTypes = {
    _reduxForm: _propTypes2.default.object
  }
  
  exports.default = FormSection
  