redux-form-lite/dist/redux-form-lite.js

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("react"), require("react-redux"));
	else if(typeof define === 'function' && define.amd)
		define(["react", "react-redux"], factory);
	else if(typeof exports === 'object')
		exports["ReduxFormLite"] = factory(require("react"), require("react-redux"));
	else
		root["ReduxFormLite"] = factory(root["React"], root["ReactRedux"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_17__, __WEBPACK_EXTERNAL_MODULE_23__) {
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] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.l = 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;

/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };

/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};

/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};

/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 104);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var _isPlaceholder = __webpack_require__(13);


/**
 * Optimized internal two-arity curry function.
 *
 * @private
 * @category Function
 * @param {Function} fn The function to curry.
 * @return {Function} The curried function.
 */
module.exports = function _curry2(fn) {
  return function f2(a, b) {
    switch (arguments.length) {
      case 0:
        return f2;
      case 1:
        return _isPlaceholder(a) ? f2
             : _curry1(function(_b) { return fn(a, _b); });
      default:
        return _isPlaceholder(a) && _isPlaceholder(b) ? f2
             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); })
             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); })
             : fn(a, b);
    }
  };
};


/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

var _isPlaceholder = __webpack_require__(13);


/**
 * Optimized internal one-arity curry function.
 *
 * @private
 * @category Function
 * @param {Function} fn The function to curry.
 * @return {Function} The curried function.
 */
module.exports = function _curry1(fn) {
  return function f1(a) {
    if (arguments.length === 0 || _isPlaceholder(a)) {
      return f1;
    } else {
      return fn.apply(this, arguments);
    }
  };
};


/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var _curry2 = __webpack_require__(0);
var _isPlaceholder = __webpack_require__(13);


/**
 * Optimized internal three-arity curry function.
 *
 * @private
 * @category Function
 * @param {Function} fn The function to curry.
 * @return {Function} The curried function.
 */
module.exports = function _curry3(fn) {
  return function f3(a, b, c) {
    switch (arguments.length) {
      case 0:
        return f3;
      case 1:
        return _isPlaceholder(a) ? f3
             : _curry2(function(_b, _c) { return fn(a, _b, _c); });
      case 2:
        return _isPlaceholder(a) && _isPlaceholder(b) ? f3
             : _isPlaceholder(a) ? _curry2(function(_a, _c) { return fn(_a, b, _c); })
             : _isPlaceholder(b) ? _curry2(function(_b, _c) { return fn(a, _b, _c); })
             : _curry1(function(_c) { return fn(a, b, _c); });
      default:
        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3
             : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function(_a, _b) { return fn(_a, _b, c); })
             : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function(_a, _c) { return fn(_a, b, _c); })
             : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function(_b, _c) { return fn(a, _b, _c); })
             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b, c); })
             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b, c); })
             : _isPlaceholder(c) ? _curry1(function(_c) { return fn(a, b, _c); })
             : fn(a, b, c);
    }
  };
};


/***/ },
/* 3 */
/***/ function(module, exports) {

module.exports = function _has(prop, obj) {
  return Object.prototype.hasOwnProperty.call(obj, prop);
};


/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var _has = __webpack_require__(3);
var _isArguments = __webpack_require__(74);


/**
 * Returns a list containing the names of all the enumerable own properties of
 * the supplied object.
 * Note that the order of the output array is not guaranteed to be consistent
 * across different JS platforms.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Object
 * @sig {k: v} -> [k]
 * @param {Object} obj The object to extract properties from
 * @return {Array} An array of the object's own properties.
 * @example
 *
 *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']
 */
module.exports = (function() {
  // cover IE < 9 keys issues
  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');
  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',
                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
  // Safari bug
  var hasArgsEnumBug = (function() {
    'use strict';
    return arguments.propertyIsEnumerable('length');
  }());

  var contains = function contains(list, item) {
    var idx = 0;
    while (idx < list.length) {
      if (list[idx] === item) {
        return true;
      }
      idx += 1;
    }
    return false;
  };

  return typeof Object.keys === 'function' && !hasArgsEnumBug ?
    _curry1(function keys(obj) {
      return Object(obj) !== obj ? [] : Object.keys(obj);
    }) :
    _curry1(function keys(obj) {
      if (Object(obj) !== obj) {
        return [];
      }
      var prop, nIdx;
      var ks = [];
      var checkArgsLength = hasArgsEnumBug && _isArguments(obj);
      for (prop in obj) {
        if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {
          ks[ks.length] = prop;
        }
      }
      if (hasEnumBug) {
        nIdx = nonEnumerableProps.length - 1;
        while (nIdx >= 0) {
          prop = nonEnumerableProps[nIdx];
          if (_has(prop, obj) && !contains(ks, prop)) {
            ks[ks.length] = prop;
          }
          nIdx -= 1;
        }
      }
      return ks;
    });
}());


/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {

var _assign = __webpack_require__(30);
var _curry2 = __webpack_require__(0);


/**
 * Create a new object with the own properties of the first object merged with
 * the own properties of the second object. If a key exists in both objects,
 * the value from the second object will be used.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Object
 * @sig {k: v} -> {k: v} -> {k: v}
 * @param {Object} l
 * @param {Object} r
 * @return {Object}
 * @see R.mergeWith, R.mergeWithKey
 * @example
 *
 *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
 *      //=> { 'name': 'fred', 'age': 40 }
 *
 *      var resetToDefault = R.merge(R.__, {x: 0});
 *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}
 * @symb R.merge({ x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: 5, z: 3 }
 */
module.exports = _curry2(function merge(l, r) {
  return _assign({}, l, r);
});


/***/ },
/* 6 */
/***/ function(module, exports) {

"use strict";
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: 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 && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.isString = isString;
exports.isNumber = isNumber;
exports.isPromise = isPromise;
exports.isFunction = isFunction;
exports.isEvent = isEvent;
exports.unflatten = unflatten;
exports.invariant = invariant;
function isString(cand) {
    return typeof cand === 'string';
}
function isNumber(cand) {
    return typeof cand === 'number';
}
function isPromise(cand) {
    return Boolean(cand) && (typeof cand === 'undefined' ? 'undefined' : _typeof(cand)) === 'object' && typeof cand.then === 'function';
}
function isFunction(cand) {
    return typeof cand === 'function';
}
function isEvent(cand) {
    return Boolean(cand && (typeof cand === 'undefined' ? 'undefined' : _typeof(cand)) === 'object' && isFunction(cand.preventDefault) && isFunction(cand.stopPropagation));
}
// NOTE: ugly imperative code
// A rewrite would be welcome.
function unflatten(obj) {
    var result = {};
    Object.keys(obj).forEach(function (prop) {
        return prop.split('.').reduce(function (acc, key, index, array) {
            var k = Number.isNaN(Number(key)) ? key : Number(key);
            if (index === array.length - 1) {
                return acc[k] = obj[prop];
            }
            if (acc[k]) {
                return acc[k] = acc[k];
            }
            if (!Number.isNaN(Number(array[index + 1]))) {
                return acc[k] = [];
            }
            return acc[k] = {};
        }, result);
    });
    return result;
}
function invariant(cond, msg) {
    if (cond) {
        return;
    }
    var error = new Error(msg);
    error.name = 'Invariant violation';
    throw error;
}

/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

var pipe = __webpack_require__(96);
var reverse = __webpack_require__(99);


/**
 * Performs right-to-left function composition. The rightmost function may have
 * any arity; the remaining functions must be unary.
 *
 * **Note:** The result of compose is not automatically curried.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Function
 * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)
 * @param {...Function} ...functions The functions to compose
 * @return {Function}
 * @see R.pipe
 * @example
 *
 *      var classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName
 *      var yellGreeting = R.compose(R.toUpper, classyGreeting);
 *      yellGreeting('James', 'Bond'); //=> "THE NAME'S BOND, JAMES BOND"
 *
 *      R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7
 *
 * @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))
 */
module.exports = function compose() {
  if (arguments.length === 0) {
    throw new Error('compose requires at least one argument');
  }
  return pipe.apply(this, reverse(arguments));
};


/***/ },
/* 8 */
/***/ function(module, exports) {

module.exports = function _arity(n, fn) {
  /* eslint-disable no-unused-vars */
  switch (n) {
    case 0: return function() { return fn.apply(this, arguments); };
    case 1: return function(a0) { return fn.apply(this, arguments); };
    case 2: return function(a0, a1) { return fn.apply(this, arguments); };
    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };
    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };
    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };
    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };
    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };
    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };
    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };
    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };
    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
  }
};


/***/ },
/* 9 */
/***/ function(module, exports) {

"use strict";
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
var ADD_FORM = exports.ADD_FORM = '@redux-form-lite/ADD_FORM';
var REMOVE_FORM = exports.REMOVE_FORM = '@redux-form-lite/REMOVE_FORM';
var ADD_FIELD = exports.ADD_FIELD = '@redux-form-lite/ADD_FIELD';
var REMOVE_FIELD = exports.REMOVE_FIELD = '@redux-form-lite/REMOVE_FIELD';
var TOUCH_ALL = exports.TOUCH_ALL = '@redux-form-lite/TOUCH_ALL';
var SUBMIT_START = exports.SUBMIT_START = '@redux-form-lite/SUBMIT_START';
var SUBMIT_STOP = exports.SUBMIT_STOP = '@redux-form-lite/SUBMIT_STOP';
var ADD_ARRAY = exports.ADD_ARRAY = '@redux-form-lite/ADD_ARRAY';
var REMOVE_ARRAY = exports.REMOVE_ARRAY = '@redux-form-lite/REMOVE_ARRAY';
var ARRAY_PUSH = exports.ARRAY_PUSH = '@redux-form-lite/ARRAY_PUSH';
var ARRAY_POP = exports.ARRAY_POP = '@redux-form-lite/ARRAY_POP';
var ARRAY_UNSHIFT = exports.ARRAY_UNSHIFT = '@redux-form-lite/ARRAY_UNSHIFT';
var ARRAY_SHIFT = exports.ARRAY_SHIFT = '@redux-form-lite/ARRAY_SHIFT';
var FIELD_CHANGE = exports.FIELD_CHANGE = '@redux-form-lite/FIELD_CHANGE';
var FIELD_FOCUS = exports.FIELD_FOCUS = '@redux-form-lite/FIELD_FOCUS';
var FIELD_BLUR = exports.FIELD_BLUR = '@redux-form-lite/FIELD_BLUR';
var FIELD_VALUE = exports.FIELD_VALUE = '@redux-form-lite/FIELD_VALUE';
var FIELD_ERROR = exports.FIELD_ERROR = '@redux-form-lite/FIELD_ERROR';
var addForm = exports.addForm = function addForm(name) {
    return {
        type: ADD_FORM,
        payload: { name: name }
    };
};
var removeForm = exports.removeForm = function removeForm(name) {
    return {
        type: REMOVE_FORM,
        payload: { name: name }
    };
};
var addField = exports.addField = function addField(form, id, field) {
    return {
        type: ADD_FIELD,
        payload: { form: form, id: id, field: field }
    };
};
var removeField = exports.removeField = function removeField(form, id) {
    return {
        type: REMOVE_FIELD,
        payload: { form: form, id: id }
    };
};
var touchAll = exports.touchAll = function touchAll(form) {
    return {
        type: TOUCH_ALL,
        payload: { form: form }
    };
};
var submitStart = exports.submitStart = function submitStart(form) {
    return {
        type: SUBMIT_START,
        payload: { form: form }
    };
};
var submitStop = exports.submitStop = function submitStop(form) {
    return {
        type: SUBMIT_STOP,
        payload: { form: form }
    };
};
var addArray = exports.addArray = function addArray(form, id) {
    return {
        type: ADD_ARRAY,
        payload: { form: form, id: id }
    };
};
var removeArray = exports.removeArray = function removeArray(form, id) {
    return {
        type: REMOVE_ARRAY,
        payload: { form: form, id: id }
    };
};
var arrayPush = exports.arrayPush = function arrayPush(form, id) {
    return {
        type: ARRAY_PUSH,
        payload: { form: form, id: id }
    };
};
var arrayPop = exports.arrayPop = function arrayPop(form, id) {
    return {
        type: ARRAY_POP,
        payload: { form: form, id: id }
    };
};
var arrayUnshift = exports.arrayUnshift = function arrayUnshift(form, id) {
    return {
        type: ARRAY_UNSHIFT,
        payload: { form: form, id: id }
    };
};
var arrayShift = exports.arrayShift = function arrayShift(form, id) {
    return {
        type: ARRAY_SHIFT,
        payload: { form: form, id: id }
    };
};
var fieldChange = exports.fieldChange = function fieldChange(form, field, value, error, dirty) {
    return {
        type: FIELD_CHANGE,
        payload: { form: form, field: field, value: value, error: error, dirty: dirty }
    };
};
var fieldFocus = exports.fieldFocus = function fieldFocus(form, field) {
    return {
        type: FIELD_FOCUS,
        payload: { form: form, field: field }
    };
};
var fieldBlur = exports.fieldBlur = function fieldBlur(form, field, value, error, dirty) {
    return {
        type: FIELD_BLUR,
        payload: { form: form, field: field, value: value, error: error, dirty: dirty }
    };
};
var fieldValue = exports.fieldValue = function fieldValue(form, field, value) {
    return {
        type: FIELD_VALUE,
        payload: { form: form, field: field, value: value }
    };
};
var fieldError = exports.fieldError = function fieldError(form, field, error) {
    return {
        type: FIELD_ERROR,
        payload: { form: form, field: field, error: error }
    };
};

/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

var _curry3 = __webpack_require__(2);


/**
 * Makes a shallow clone of an object, setting or overriding the specified
 * property with the given value. Note that this copies and flattens prototype
 * properties onto the new object as well. All non-primitive properties are
 * copied by reference.
 *
 * @func
 * @memberOf R
 * @since v0.8.0
 * @category Object
 * @sig String -> a -> {k: v} -> {k: v}
 * @param {String} prop The property name to set
 * @param {*} val The new value
 * @param {Object} obj The object to clone
 * @return {Object} A new object equivalent to the original except for the changed property.
 * @see R.dissoc
 * @example
 *
 *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}
 */
module.exports = _curry3(function assoc(prop, val, obj) {
  var result = {};
  for (var p in obj) {
    result[p] = obj[p];
  }
  result[prop] = val;
  return result;
});


/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

var _isArray = __webpack_require__(12);
var _isTransformer = __webpack_require__(78);


/**
 * Returns a function that dispatches with different strategies based on the
 * object in list position (last argument). If it is an array, executes [fn].
 * Otherwise, if it has a function with one of the given method names, it will
 * execute that function (functor case). Otherwise, if it is a transformer,
 * uses transducer [xf] to return a new transformer (transducer case).
 * Otherwise, it will default to executing [fn].
 *
 * @private
 * @param {Array} methodNames properties to check for a custom implementation
 * @param {Function} xf transducer to initialize if object is transformer
 * @param {Function} fn default ramda implementation
 * @return {Function} A function that dispatches on object in list position
 */
module.exports = function _dispatchable(methodNames, xf, fn) {
  return function() {
    if (arguments.length === 0) {
      return fn();
    }
    var args = Array.prototype.slice.call(arguments, 0);
    var obj = args.pop();
    if (!_isArray(obj)) {
      var idx = 0;
      while (idx < methodNames.length) {
        if (typeof obj[methodNames[idx]] === 'function') {
          return obj[methodNames[idx]].apply(obj, args);
        }
        idx += 1;
      }
      if (_isTransformer(obj)) {
        var transducer = xf.apply(null, args);
        return transducer(obj);
      }
    }
    return fn.apply(this, arguments);
  };
};


/***/ },
/* 12 */
/***/ function(module, exports) {

/**
 * Tests whether or not an object is an array.
 *
 * @private
 * @param {*} val The object to test.
 * @return {Boolean} `true` if `val` is an array, `false` otherwise.
 * @example
 *
 *      _isArray([]); //=> true
 *      _isArray(null); //=> false
 *      _isArray({}); //=> false
 */
module.exports = Array.isArray || function _isArray(val) {
  return (val != null &&
          val.length >= 0 &&
          Object.prototype.toString.call(val) === '[object Array]');
};


/***/ },
/* 13 */
/***/ function(module, exports) {

module.exports = function _isPlaceholder(a) {
  return a != null &&
         typeof a === 'object' &&
         a['@@functional/placeholder'] === true;
};


/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _dispatchable = __webpack_require__(11);
var _map = __webpack_require__(35);
var _reduce = __webpack_require__(20);
var _xmap = __webpack_require__(87);
var curryN = __webpack_require__(18);
var keys = __webpack_require__(4);


/**
 * Takes a function and
 * a [functor](https://github.com/fantasyland/fantasy-land#functor),
 * applies the function to each of the functor's values, and returns
 * a functor of the same shape.
 *
 * Ramda provides suitable `map` implementations for `Array` and `Object`,
 * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.
 *
 * Dispatches to the `map` method of the second argument, if present.
 *
 * Acts as a transducer if a transformer is given in list position.
 *
 * Also treats functions as functors and will compose them together.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig Functor f => (a -> b) -> f a -> f b
 * @param {Function} fn The function to be called on every element of the input `list`.
 * @param {Array} list The list to be iterated over.
 * @return {Array} The new list.
 * @see R.transduce, R.addIndex
 * @example
 *
 *      var double = x => x * 2;
 *
 *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]
 *
 *      R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}
 * @symb R.map(f, [a, b]) = [f(a), f(b)]
 * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }
 * @symb R.map(f, functor_o) = functor_o.map(f)
 */
module.exports = _curry2(_dispatchable(['map'], _xmap, function map(fn, functor) {
  switch (Object.prototype.toString.call(functor)) {
    case '[object Function]':
      return curryN(functor.length, function() {
        return fn.call(this, functor.apply(this, arguments));
      });
    case '[object Object]':
      return _reduce(function(acc, key) {
        acc[key] = fn(functor[key]);
        return acc;
      }, {}, keys(functor));
    default:
      return _map(fn, functor);
  }
}));


/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);


/**
 * Retrieve the value at a given path.
 *
 * @func
 * @memberOf R
 * @since v0.2.0
 * @category Object
 * @typedefn Idx = String | Int
 * @sig [Idx] -> {a} -> a | Undefined
 * @param {Array} path The path to use.
 * @param {Object} obj The object to retrieve the nested property from.
 * @return {*} The data at `path`.
 * @see R.prop
 * @example
 *
 *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2
 *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined
 */
module.exports = _curry2(function path(paths, obj) {
  var val = obj;
  var idx = 0;
  while (idx < paths.length) {
    if (val == null) {
      return;
    }
    val = val[paths[idx]];
    idx += 1;
  }
  return val;
});


/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);


/**
 * Returns a function that when supplied an object returns the indicated
 * property of that object, if it exists.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Object
 * @sig s -> {s: a} -> a | Undefined
 * @param {String} p The property name
 * @param {Object} obj The object to query
 * @return {*} The value at `obj.p`.
 * @see R.path
 * @example
 *
 *      R.prop('x', {x: 100}); //=> 100
 *      R.prop('x', {}); //=> undefined
 */
module.exports = _curry2(function prop(p, obj) { return obj[p]; });


/***/ },
/* 17 */
/***/ function(module, exports) {

module.exports = __WEBPACK_EXTERNAL_MODULE_17__;

/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {

var _arity = __webpack_require__(8);
var _curry1 = __webpack_require__(1);
var _curry2 = __webpack_require__(0);
var _curryN = __webpack_require__(68);


/**
 * Returns a curried equivalent of the provided function, with the specified
 * arity. The curried function has two unusual capabilities. First, its
 * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the
 * following are equivalent:
 *
 *   - `g(1)(2)(3)`
 *   - `g(1)(2, 3)`
 *   - `g(1, 2)(3)`
 *   - `g(1, 2, 3)`
 *
 * Secondly, the special placeholder value `R.__` may be used to specify
 * "gaps", allowing partial application of any combination of arguments,
 * regardless of their positions. If `g` is as above and `_` is `R.__`, the
 * following are equivalent:
 *
 *   - `g(1, 2, 3)`
 *   - `g(_, 2, 3)(1)`
 *   - `g(_, _, 3)(1)(2)`
 *   - `g(_, _, 3)(1, 2)`
 *   - `g(_, 2)(1)(3)`
 *   - `g(_, 2)(1, 3)`
 *   - `g(_, 2)(_, 3)(1)`
 *
 * @func
 * @memberOf R
 * @since v0.5.0
 * @category Function
 * @sig Number -> (* -> a) -> (* -> a)
 * @param {Number} length The arity for the returned function.
 * @param {Function} fn The function to curry.
 * @return {Function} A new, curried function.
 * @see R.curry
 * @example
 *
 *      var sumArgs = (...args) => R.sum(args);
 *
 *      var curriedAddFourNumbers = R.curryN(4, sumArgs);
 *      var f = curriedAddFourNumbers(1, 2);
 *      var g = f(3);
 *      g(4); //=> 10
 */
module.exports = _curry2(function curryN(length, fn) {
  if (length === 1) {
    return _curry1(fn);
  }
  return _arity(length, _curryN(length, [], fn));
});


/***/ },
/* 19 */
/***/ function(module, exports) {

module.exports = function _isString(x) {
  return Object.prototype.toString.call(x) === '[object String]';
};


/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {

var _xwrap = __webpack_require__(88);
var bind = __webpack_require__(57);
var isArrayLike = __webpack_require__(37);


module.exports = (function() {
  function _arrayReduce(xf, acc, list) {
    var idx = 0;
    var len = list.length;
    while (idx < len) {
      acc = xf['@@transducer/step'](acc, list[idx]);
      if (acc && acc['@@transducer/reduced']) {
        acc = acc['@@transducer/value'];
        break;
      }
      idx += 1;
    }
    return xf['@@transducer/result'](acc);
  }

  function _iterableReduce(xf, acc, iter) {
    var step = iter.next();
    while (!step.done) {
      acc = xf['@@transducer/step'](acc, step.value);
      if (acc && acc['@@transducer/reduced']) {
        acc = acc['@@transducer/value'];
        break;
      }
      step = iter.next();
    }
    return xf['@@transducer/result'](acc);
  }

  function _methodReduce(xf, acc, obj) {
    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));
  }

  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';
  return function _reduce(fn, acc, list) {
    if (typeof fn === 'function') {
      fn = _xwrap(fn);
    }
    if (isArrayLike(list)) {
      return _arrayReduce(fn, acc, list);
    }
    if (typeof list.reduce === 'function') {
      return _methodReduce(fn, acc, list);
    }
    if (list[symIterator] != null) {
      return _iterableReduce(fn, acc, list[symIterator]());
    }
    if (typeof list.next === 'function') {
      return _iterableReduce(fn, acc, list);
    }
    throw new TypeError('reduce: list must be array or iterable');
  };
}());


/***/ },
/* 21 */
/***/ function(module, exports) {

module.exports = {
  init: function() {
    return this.xf['@@transducer/init']();
  },
  result: function(result) {
    return this.xf['@@transducer/result'](result);
  }
};


/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {

var _contains = __webpack_require__(34);
var _curry2 = __webpack_require__(0);


/**
 * Returns a partial copy of an object omitting the keys specified.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Object
 * @sig [String] -> {String: *} -> {String: *}
 * @param {Array} names an array of String property names to omit from the new object
 * @param {Object} obj The object to copy from
 * @return {Object} A new object with properties from `names` not on it.
 * @see R.pick
 * @example
 *
 *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}
 */
module.exports = _curry2(function omit(names, obj) {
  var result = {};
  for (var prop in obj) {
    if (!_contains(prop, names)) {
      result[prop] = obj[prop];
    }
  }
  return result;
});


/***/ },
/* 23 */
/***/ function(module, exports) {

module.exports = __WEBPACK_EXTERNAL_MODULE_23__;

/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _merge = __webpack_require__(5);

var _merge2 = _interopRequireDefault(_merge);

exports.default = connectField;

var _react = __webpack_require__(17);

var React = _interopRequireWildcard(_react);

var _helpers = __webpack_require__(6);

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

function connectField(Wrapped) {
    var ConnectedField = function ConnectedField(props, _ref) {
        var reduxFormLite = _ref.reduxFormLite;

        (0, _helpers.invariant)((0, _helpers.isString)(reduxFormLite), '[redux-form-lite] Field and FieldArray must be a children of the Form component.');
        return React.createElement(Wrapped, (0, _merge2.default)(props, {
            _form: reduxFormLite
        }));
    };
    ConnectedField.contextTypes = {
        reduxFormLite: React.PropTypes.string.isRequired
    };
    ConnectedField.displayName = Wrapped.displayName;
    ConnectedField.WrappedComponent = Wrapped;
    return ConnectedField;
}

/***/ },
/* 25 */
/***/ function(module, exports) {

"use strict";
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
var form = exports.form = {
    fields: {},
    arrays: {},
    submitting: false
};
var field = exports.field = {
    value: '',
    error: null,
    visited: false,
    touched: false,
    active: false,
    dirty: false
};

/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);


/**
 * Adds two values.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Math
 * @sig Number -> Number -> Number
 * @param {Number} a
 * @param {Number} b
 * @return {Number}
 * @see R.subtract
 * @example
 *
 *      R.add(2, 3);       //=>  5
 *      R.add(7)(10);      //=> 17
 */
module.exports = _curry2(function add(a, b) {
  return Number(a) + Number(b);
});


/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _dispatchable = __webpack_require__(11);
var _xany = __webpack_require__(36);


/**
 * Returns `true` if at least one of elements of the list match the predicate,
 * `false` otherwise.
 *
 * Dispatches to the `any` method of the second argument, if present.
 *
 * Acts as a transducer if a transformer is given in list position.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig (a -> Boolean) -> [a] -> Boolean
 * @param {Function} fn The predicate function.
 * @param {Array} list The array to consider.
 * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`
 *         otherwise.
 * @see R.all, R.none, R.transduce
 * @example
 *
 *      var lessThan0 = R.flip(R.lt)(0);
 *      var lessThan2 = R.flip(R.lt)(2);
 *      R.any(lessThan0)([1, 2]); //=> false
 *      R.any(lessThan2)([1, 2]); //=> true
 */
module.exports = _curry2(_dispatchable(['any'], _xany, function any(fn, list) {
  var idx = 0;
  while (idx < list.length) {
    if (fn(list[idx])) {
      return true;
    }
    idx += 1;
  }
  return false;
}));


/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {

var _curry3 = __webpack_require__(2);
var _has = __webpack_require__(3);
var _isArray = __webpack_require__(12);
var _isInteger = __webpack_require__(76);
var assoc = __webpack_require__(10);


/**
 * Makes a shallow clone of an object, setting or overriding the nodes required
 * to create the given path, and placing the specific value at the tail end of
 * that path. Note that this copies and flattens prototype properties onto the
 * new object as well. All non-primitive properties are copied by reference.
 *
 * @func
 * @memberOf R
 * @since v0.8.0
 * @category Object
 * @typedefn Idx = String | Int
 * @sig [Idx] -> a -> {a} -> {a}
 * @param {Array} path the path to set
 * @param {*} val The new value
 * @param {Object} obj The object to clone
 * @return {Object} A new object equivalent to the original except along the specified path.
 * @see R.dissocPath
 * @example
 *
 *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
 *
 *      // Any missing or non-object keys in path will be overridden
 *      R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}}
 */
module.exports = _curry3(function assocPath(path, val, obj) {
  if (path.length === 0) {
    return val;
  }
  var idx = path[0];
  if (path.length > 1) {
    var nextObj = _has(idx, obj) ? obj[idx] : _isInteger(path[1]) ? [] : {};
    val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj);
  }
  if (_isInteger(idx) && _isArray(obj)) {
    var arr = [].concat(obj);
    arr[idx] = val;
    return arr;
  } else {
    return assoc(idx, val, obj);
  }
});


/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var _identity = __webpack_require__(72);


/**
 * A function that does nothing but return the parameter supplied to it. Good
 * as a default or placeholder function.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Function
 * @sig a -> a
 * @param {*} x The value to return.
 * @return {*} The input value, `x`.
 * @example
 *
 *      R.identity(1); //=> 1
 *
 *      var obj = {};
 *      R.identity(obj) === obj; //=> true
 * @symb R.identity(a) = a
 */
module.exports = _curry1(_identity);


/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {

var _objectAssign = __webpack_require__(80);

module.exports =
  typeof Object.assign === 'function' ? Object.assign : _objectAssign;


/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {

var _isArray = __webpack_require__(12);


/**
 * This checks whether a function has a [methodname] function. If it isn't an
 * array it will execute that function otherwise it will default to the ramda
 * implementation.
 *
 * @private
 * @param {Function} fn ramda implemtation
 * @param {String} methodname property to check for a custom implementation
 * @return {Object} Whatever the return value of the method is.
 */
module.exports = function _checkForMethod(methodname, fn) {
  return function() {
    var length = arguments.length;
    if (length === 0) {
      return fn();
    }
    var obj = arguments[length - 1];
    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?
      fn.apply(this, arguments) :
      obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));
  };
};


/***/ },
/* 32 */
/***/ function(module, exports) {

module.exports = function _complement(f) {
  return function() {
    return !f.apply(this, arguments);
  };
};


/***/ },
/* 33 */
/***/ function(module, exports) {

/**
 * Private `concat` function to merge two array-like objects.
 *
 * @private
 * @param {Array|Arguments} [set1=[]] An array-like object.
 * @param {Array|Arguments} [set2=[]] An array-like object.
 * @return {Array} A new, merged array.
 * @example
 *
 *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
 */
module.exports = function _concat(set1, set2) {
  set1 = set1 || [];
  set2 = set2 || [];
  var idx;
  var len1 = set1.length;
  var len2 = set2.length;
  var result = [];

  idx = 0;
  while (idx < len1) {
    result[result.length] = set1[idx];
    idx += 1;
  }
  idx = 0;
  while (idx < len2) {
    result[result.length] = set2[idx];
    idx += 1;
  }
  return result;
};


/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {

var _indexOf = __webpack_require__(73);


module.exports = function _contains(a, list) {
  return _indexOf(list, a, 0) >= 0;
};


/***/ },
/* 35 */
/***/ function(module, exports) {

module.exports = function _map(fn, functor) {
  var idx = 0;
  var len = functor.length;
  var result = Array(len);
  while (idx < len) {
    result[idx] = fn(functor[idx]);
    idx += 1;
  }
  return result;
};


/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _reduced = __webpack_require__(83);
var _xfBase = __webpack_require__(21);


module.exports = (function() {
  function XAny(f, xf) {
    this.xf = xf;
    this.f = f;
    this.any = false;
  }
  XAny.prototype['@@transducer/init'] = _xfBase.init;
  XAny.prototype['@@transducer/result'] = function(result) {
    if (!this.any) {
      result = this.xf['@@transducer/step'](result, false);
    }
    return this.xf['@@transducer/result'](result);
  };
  XAny.prototype['@@transducer/step'] = function(result, input) {
    if (this.f(input)) {
      this.any = true;
      result = _reduced(this.xf['@@transducer/step'](result, true));
    }
    return result;
  };

  return _curry2(function _xany(f, xf) { return new XAny(f, xf); });
}());


/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var _isArray = __webpack_require__(12);
var _isString = __webpack_require__(19);


/**
 * Tests whether or not an object is similar to an array.
 *
 * @func
 * @memberOf R
 * @since v0.5.0
 * @category Type
 * @category List
 * @sig * -> Boolean
 * @param {*} x The object to test.
 * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.
 * @deprecated since v0.23.0
 * @example
 *
 *      R.isArrayLike([]); //=> true
 *      R.isArrayLike(true); //=> false
 *      R.isArrayLike({}); //=> false
 *      R.isArrayLike({length: 10}); //=> false
 *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true
 */
module.exports = _curry1(function isArrayLike(x) {
  if (_isArray(x)) { return true; }
  if (!x) { return false; }
  if (typeof x !== 'object') { return false; }
  if (_isString(x)) { return false; }
  if (x.nodeType === 1) { return !!x.length; }
  if (x.length === 0) { return true; }
  if (x.length > 0) {
    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
  }
  return false;
});


/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var map = __webpack_require__(14);


/**
 * Returns a lens for the given getter and setter functions. The getter "gets"
 * the value of the focus; the setter "sets" the value of the focus. The setter
 * should not mutate the data structure.
 *
 * @func
 * @memberOf R
 * @since v0.8.0
 * @category Object
 * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
 * @sig (s -> a) -> ((a, s) -> s) -> Lens s a
 * @param {Function} getter
 * @param {Function} setter
 * @return {Lens}
 * @see R.view, R.set, R.over, R.lensIndex, R.lensProp
 * @example
 *
 *      var xLens = R.lens(R.prop('x'), R.assoc('x'));
 *
 *      R.view(xLens, {x: 1, y: 2});            //=> 1
 *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}
 *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}
 */
module.exports = _curry2(function lens(getter, setter) {
  return function(toFunctorFn) {
    return function(target) {
      return map(
        function(focus) {
          return setter(focus, target);
        },
        toFunctorFn(getter(target))
      );
    };
  };
});


/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var assoc = __webpack_require__(10);
var lens = __webpack_require__(38);
var prop = __webpack_require__(16);


/**
 * Returns a lens whose focus is the specified property.
 *
 * @func
 * @memberOf R
 * @since v0.14.0
 * @category Object
 * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
 * @sig String -> Lens s a
 * @param {String} k
 * @return {Lens}
 * @see R.view, R.set, R.over
 * @example
 *
 *      var xLens = R.lensProp('x');
 *
 *      R.view(xLens, {x: 1, y: 2});            //=> 1
 *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}
 *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}
 */
module.exports = _curry1(function lensProp(k) {
  return lens(prop(k), assoc(k));
});


/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {

var _curry3 = __webpack_require__(2);


/**
 * Returns the result of "setting" the portion of the given data structure
 * focused by the given lens to the result of applying the given function to
 * the focused value.
 *
 * @func
 * @memberOf R
 * @since v0.16.0
 * @category Object
 * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
 * @sig Lens s a -> (a -> a) -> s -> s
 * @param {Lens} lens
 * @param {*} v
 * @param {*} x
 * @return {*}
 * @see R.prop, R.lensIndex, R.lensProp
 * @example
 *
 *      var headLens = R.lensIndex(0);
 *
 *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']
 */
module.exports = (function() {
  // `Identity` is a functor that holds a single value, where `map` simply
  // transforms the held value with the provided function.
  var Identity = function(x) {
    return {value: x, map: function(f) { return Identity(f(x)); }};
  };

  return _curry3(function over(lens, f, x) {
    // The value returned by the getter function is first transformed with `f`,
    // then set as the value of an `Identity`. This is then mapped over with the
    // setter function of the lens.
    return lens(function(y) { return Identity(f(y)); })(x).value;
  });
}());


/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {

var _curry3 = __webpack_require__(2);
var _reduce = __webpack_require__(20);


/**
 * Returns a single item by iterating through the list, successively calling
 * the iterator function and passing it an accumulator value and the current
 * value from the array, and then passing the result to the next call.
 *
 * The iterator function receives two values: *(acc, value)*. It may use
 * `R.reduced` to shortcut the iteration.
 *
 * The arguments' order of `reduceRight`'s iterator function is *(value, acc)*.
 *
 * Note: `R.reduce` does not skip deleted or unassigned indices (sparse
 * arrays), unlike the native `Array.prototype.reduce` method. For more details
 * on this behavior, see:
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description
 *
 * Dispatches to the `reduce` method of the third argument, if present.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig ((a, b) -> a) -> a -> [b] -> a
 * @param {Function} fn The iterator function. Receives two values, the accumulator and the
 *        current element from the array.
 * @param {*} acc The accumulator value.
 * @param {Array} list The list to iterate over.
 * @return {*} The final, accumulated value.
 * @see R.reduced, R.addIndex, R.reduceRight
 * @example
 *
 *      R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10
 *                -               -10
 *               / \              / \
 *              -   4           -6   4
 *             / \              / \
 *            -   3   ==>     -3   3
 *           / \              / \
 *          -   2           -1   2
 *         / \              / \
 *        0   1            0   1
 *
 * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)
 */
module.exports = _curry3(_reduce);


/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {

var _curry3 = __webpack_require__(2);
var always = __webpack_require__(56);
var over = __webpack_require__(40);


/**
 * Returns the result of "setting" the portion of the given data structure
 * focused by the given lens to the given value.
 *
 * @func
 * @memberOf R
 * @since v0.16.0
 * @category Object
 * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
 * @sig Lens s a -> a -> s -> s
 * @param {Lens} lens
 * @param {*} v
 * @param {*} x
 * @return {*}
 * @see R.prop, R.lensIndex, R.lensProp
 * @example
 *
 *      var xLens = R.lensProp('x');
 *
 *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}
 *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}
 */
module.exports = _curry3(function set(lens, v, x) {
  return over(lens, always(v), x);
});


/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {

var _checkForMethod = __webpack_require__(31);
var _curry1 = __webpack_require__(1);
var slice = __webpack_require__(100);


/**
 * Returns all but the first element of the given list or string (or object
 * with a `tail` method).
 *
 * Dispatches to the `slice` method of the first argument, if present.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig [a] -> [a]
 * @sig String -> String
 * @param {*} list
 * @return {*}
 * @see R.head, R.init, R.last
 * @example
 *
 *      R.tail([1, 2, 3]);  //=> [2, 3]
 *      R.tail([1, 2]);     //=> [2]
 *      R.tail([1]);        //=> []
 *      R.tail([]);         //=> []
 *
 *      R.tail('abc');  //=> 'bc'
 *      R.tail('ab');   //=> 'b'
 *      R.tail('a');    //=> ''
 *      R.tail('');     //=> ''
 */
module.exports = _curry1(_checkForMethod('tail', slice(1, Infinity)));


/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var _toString = __webpack_require__(85);


/**
 * Returns the string representation of the given value. `eval`'ing the output
 * should result in a value equivalent to the input value. Many of the built-in
 * `toString` methods do not satisfy this requirement.
 *
 * If the given value is an `[object Object]` with a `toString` method other
 * than `Object.prototype.toString`, this method is invoked with no arguments
 * to produce the return value. This means user-defined constructor functions
 * can provide a suitable `toString` method. For example:
 *
 *     function Point(x, y) {
 *       this.x = x;
 *       this.y = y;
 *     }
 *
 *     Point.prototype.toString = function() {
 *       return 'new Point(' + this.x + ', ' + this.y + ')';
 *     };
 *
 *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'
 *
 * @func
 * @memberOf R
 * @since v0.14.0
 * @category String
 * @sig * -> String
 * @param {*} val
 * @return {String}
 * @example
 *
 *      R.toString(42); //=> '42'
 *      R.toString('abc'); //=> '"abc"'
 *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'
 *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}'
 *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")'
 */
module.exports = _curry1(function toString(val) { return _toString(val, []); });


/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _path = __webpack_require__(15);

var _path2 = _interopRequireDefault(_path);

var _identity = __webpack_require__(29);

var _identity2 = _interopRequireDefault(_identity);

var _merge = __webpack_require__(5);

var _merge2 = _interopRequireDefault(_merge);

var _mergeAll = __webpack_require__(92);

var _mergeAll2 = _interopRequireDefault(_mergeAll);

var _lensProp = __webpack_require__(39);

var _lensProp2 = _interopRequireDefault(_lensProp);

var _set = __webpack_require__(42);

var _set2 = _interopRequireDefault(_set);

var _compose = __webpack_require__(7);

var _compose2 = _interopRequireDefault(_compose);

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 = __webpack_require__(17);

var React = _interopRequireWildcard(_react);

var _reactRedux = __webpack_require__(23);

var _connectField = __webpack_require__(24);

var _connectField2 = _interopRequireDefault(_connectField);

var _fieldProps2 = __webpack_require__(52);

var _fieldProps3 = _interopRequireDefault(_fieldProps2);

var _getValue = __webpack_require__(54);

var _getValue2 = _interopRequireDefault(_getValue);

var _actions = __webpack_require__(9);

var actions = _interopRequireWildcard(_actions);

var _containers = __webpack_require__(25);

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

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 __rest = undefined && undefined.__rest || function (s, e) {
    var t = {};
    for (var p in s) {
        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
    }return t;
};

var Field = function (_React$PureComponent) {
    _inherits(Field, _React$PureComponent);

    function Field(props) {
        _classCallCheck(this, Field);

        var _this = _possibleConstructorReturn(this, (Field.__proto__ || Object.getPrototypeOf(Field)).call(this, props));

        _this.handleChange = _this.handleChange.bind(_this);
        _this.handleFocus = _this.handleFocus.bind(_this);
        _this.handleBlur = _this.handleBlur.bind(_this);
        return _this;
    }

    _createClass(Field, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            if (!this.props._field) {
                this.newField(this.props);
            }
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(next) {
            var _props = this.props,
                _fieldChange = _props._fieldChange,
                _form = _props._form,
                name = _props.name,
                normalize = _props.normalize,
                validate = _props.validate,
                defaultValue = _props.defaultValue;

            if (!next._field) {
                this.newField(next);
                return;
            }
            if (defaultValue !== next.defaultValue) {
                var value = next.normalize(next._field.value);
                var error = next.validate(value);
                var dirty = next.defaultValue !== value;
                _fieldChange(_form, name, value, error, dirty);
            }
        }
    }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            var _props2 = this.props,
                _removeField = _props2._removeField,
                _form = _props2._form,
                name = _props2.name;

            _removeField(_form, name);
        }
    }, {
        key: 'newField',
        value: function newField(props) {
            var value = props.normalize(props.defaultValue);
            var newField = (0, _compose2.default)((0, _set2.default)((0, _lensProp2.default)('value'), value), (0, _set2.default)((0, _lensProp2.default)('error'), props.validate(value)))(_containers.field);
            props._addField(props._form, props.name, newField);
        }
    }, {
        key: 'handleChange',
        value: function handleChange(ev) {
            var _props3 = this.props,
                _fieldChange = _props3._fieldChange,
                _form = _props3._form,
                name = _props3.name,
                normalize = _props3.normalize,
                validate = _props3.validate,
                defaultValue = _props3.defaultValue;

            var value = normalize((0, _getValue2.default)(ev));
            var error = validate(value);
            var dirty = value !== defaultValue;
            _fieldChange(_form, name, value, error, dirty);
        }
    }, {
        key: 'handleFocus',
        value: function handleFocus() {
            var _props4 = this.props,
                _fieldFocus = _props4._fieldFocus,
                _form = _props4._form,
                name = _props4.name;

            _fieldFocus(_form, name);
        }
    }, {
        key: 'handleBlur',
        value: function handleBlur(ev) {
            var _props5 = this.props,
                _fieldBlur = _props5._fieldBlur,
                _form = _props5._form,
                name = _props5.name,
                normalize = _props5.normalize,
                validate = _props5.validate,
                defaultValue = _props5.defaultValue;

            var value = normalize((0, _getValue2.default)(ev));
            var error = validate(value);
            var dirty = value !== defaultValue;
            _fieldBlur(_form, name, value, error, dirty);
        }
    }, {
        key: 'render',
        value: function render() {
            var _a = this.props,
                component = _a.component,
                withRef = _a.withRef,
                _field = _a._field,
                rest = __rest(_a, ["component", "withRef", "_field"]);
            // Wait until field is initialized
            if (!_field) {
                return null;
            }

            var _fieldProps = (0, _fieldProps3.default)((0, _mergeAll2.default)([rest, { ref: withRef }, _field, {
                onChange: this.handleChange,
                onFocus: this.handleFocus,
                onBlur: this.handleBlur
            }])),
                input = _fieldProps.input,
                meta = _fieldProps.meta,
                custom = _fieldProps.custom;

            if (typeof component === 'string') {
                return React.createElement(component, (0, _merge2.default)(custom, input));
            }
            // React.SFC vs. React.ClassComponent collision
            return React.createElement(component, (0, _merge2.default)(custom, { input: input, meta: meta }));
        }
    }]);

    return Field;
}(React.PureComponent);
// Must contain all props of 'AllProps'


Field.defaultProps = {
    validate: function validate() {
        return null;
    },
    normalize: _identity2.default,
    defaultValue: '',
    // state
    _field: null,
    // actions
    _addField: _identity2.default,
    _removeField: _identity2.default,
    _fieldChange: _identity2.default,
    _fieldFocus: _identity2.default,
    _fieldBlur: _identity2.default
};
Field.propTypes = {
    name: React.PropTypes.string.isRequired,
    component: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.func]).isRequired,
    validate: React.PropTypes.func,
    normalize: React.PropTypes.func,
    defaultValue: React.PropTypes.string
};
Field.displayName = 'Field';
var bindActions = {
    _addField: actions.addField,
    _removeField: actions.removeField,
    _fieldChange: actions.fieldChange,
    _fieldFocus: actions.fieldFocus,
    _fieldBlur: actions.fieldBlur
};
var Connected = (0, _reactRedux.connect)(function (state, props) {
    return {
        _field: (0, _path2.default)([props._form, 'fields', props.name], state.reduxFormLite)
    };
}, bindActions)(Field);
var Contexted = (0, _connectField2.default)(Connected);
Contexted.displayName = Field.displayName;
exports.default = Contexted;

/***/ },
/* 46 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _path = __webpack_require__(15);

var _path2 = _interopRequireDefault(_path);

var _merge = __webpack_require__(5);

var _merge2 = _interopRequireDefault(_merge);

var _addIndex = __webpack_require__(55);

var _addIndex2 = _interopRequireDefault(_addIndex);

var _map = __webpack_require__(14);

var _map2 = _interopRequireDefault(_map);

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 = __webpack_require__(17);

var React = _interopRequireWildcard(_react);

var _reactRedux = __webpack_require__(23);

var _actions = __webpack_require__(9);

var actions = _interopRequireWildcard(_actions);

var _connectField = __webpack_require__(24);

var _connectField2 = _interopRequireDefault(_connectField);

var _fieldArrayProps = __webpack_require__(51);

var _fieldArrayProps2 = _interopRequireDefault(_fieldArrayProps);

var _helpers = __webpack_require__(6);

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

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 __rest = undefined && undefined.__rest || function (s, e) {
    var t = {};
    for (var p in s) {
        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
    }return t;
};

var FieldArray = function (_React$PureComponent) {
    _inherits(FieldArray, _React$PureComponent);

    function FieldArray(props) {
        _classCallCheck(this, FieldArray);

        var _this = _possibleConstructorReturn(this, (FieldArray.__proto__ || Object.getPrototypeOf(FieldArray)).call(this, props));

        _this.handleMap = _this.handleMap.bind(_this);
        _this.handlePush = _this.handlePush.bind(_this);
        _this.handlePop = _this.handlePop.bind(_this);
        _this.handleUnshift = _this.handleUnshift.bind(_this);
        _this.handleShift = _this.handleShift.bind(_this);
        return _this;
    }

    _createClass(FieldArray, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            var _props = this.props,
                _array = _props._array,
                _addArray = _props._addArray,
                _form = _props._form,
                name = _props.name;

            if (!_array) {
                _addArray(_form, name);
            }
        }
    }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            var _props2 = this.props,
                _removeArray = _props2._removeArray,
                _form = _props2._form,
                name = _props2.name;

            _removeArray(_form, name);
        }
    }, {
        key: 'handleMap',
        value: function handleMap(fn) {
            var _props3 = this.props,
                name = _props3.name,
                _array = _props3._array;

            var array = Array.from(Array(_array));
            return (0, _map2.default)(fn, (0, _addIndex2.default)(_map2.default)(function (_, i) {
                return name + '.' + i;
            }, array));
        }
    }, {
        key: 'handlePush',
        value: function handlePush(ev) {
            var _props4 = this.props,
                name = _props4.name,
                _arrayPush = _props4._arrayPush,
                _form = _props4._form;

            if ((0, _helpers.isEvent)(ev)) {
                ev.preventDefault();
            }
            _arrayPush(_form, name);
        }
    }, {
        key: 'handlePop',
        value: function handlePop(ev) {
            var _props5 = this.props,
                name = _props5.name,
                _array = _props5._array,
                _arrayPop = _props5._arrayPop,
                _form = _props5._form;

            if ((0, _helpers.isEvent)(ev)) {
                ev.preventDefault();
            }
            if (_array > 0) {
                _arrayPop(_form, name);
            }
        }
    }, {
        key: 'handleUnshift',
        value: function handleUnshift(ev) {
            var _props6 = this.props,
                name = _props6.name,
                _arrayUnshift = _props6._arrayUnshift,
                _form = _props6._form;

            if ((0, _helpers.isEvent)(ev)) {
                ev.preventDefault();
            }
            _arrayUnshift(_form, name);
        }
    }, {
        key: 'handleShift',
        value: function handleShift(ev) {
            var _props7 = this.props,
                name = _props7.name,
                _array = _props7._array,
                _arrayShift = _props7._arrayShift,
                _form = _props7._form;

            if ((0, _helpers.isEvent)(ev)) {
                ev.preventDefault();
            }
            if (_array > 0) {
                _arrayShift(_form, name);
            }
        }
    }, {
        key: 'render',
        value: function render() {
            var _a = this.props,
                component = _a.component,
                withRef = _a.withRef,
                _array = _a._array,
                rest = __rest(_a, ["component", "withRef", "_array"]);
            if (!(0, _helpers.isNumber)(_array)) {
                return null;
            }
            // React.SFC vs. React.ClassComponent collision
            return React.createElement(component, (0, _fieldArrayProps2.default)((0, _merge2.default)(rest, { ref: withRef }), {
                length: _array,
                map: this.handleMap,
                push: this.handlePush,
                pop: this.handlePop,
                unshift: this.handleUnshift,
                shift: this.handleShift
            }));
        }
    }]);

    return FieldArray;
}(React.PureComponent);

FieldArray.propTypes = {
    name: React.PropTypes.string.isRequired,
    component: React.PropTypes.func.isRequired
};
FieldArray.displayName = 'FieldArray';
var bindActions = {
    _addArray: actions.addArray,
    _removeArray: actions.removeArray,
    _arrayPush: actions.arrayPush,
    _arrayPop: actions.arrayPop,
    _arrayUnshift: actions.arrayUnshift,
    _arrayShift: actions.arrayShift
};
var Connected = (0, _reactRedux.connect)(function (state, props) {
    return {
        _array: (0, _path2.default)([props._form, 'arrays', props.name], state.reduxFormLite)
    };
}, bindActions)(FieldArray);
var Contexted = (0, _connectField2.default)(Connected);
Contexted.displayName = FieldArray.displayName;
exports.default = Contexted;

/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _prop = __webpack_require__(16);

var _prop2 = _interopRequireDefault(_prop);

var _merge = __webpack_require__(5);

var _merge2 = _interopRequireDefault(_merge);

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 = __webpack_require__(17);

var React = _interopRequireWildcard(_react);

var _reactRedux = __webpack_require__(23);

var _helpers = __webpack_require__(6);

var _formProps = __webpack_require__(53);

var _formProps2 = _interopRequireDefault(_formProps);

var _actions = __webpack_require__(9);

var actions = _interopRequireWildcard(_actions);

var _selectors = __webpack_require__(49);

var selectors = _interopRequireWildcard(_selectors);

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

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 Form = function (_React$PureComponent) {
    _inherits(Form, _React$PureComponent);

    function Form(props) {
        _classCallCheck(this, Form);

        var _this = _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this, props));

        _this.handleSubmit = _this.handleSubmit.bind(_this);
        return _this;
    }

    _createClass(Form, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            var _props = this.props,
                name = _props.name,
                _form = _props._form,
                _addForm = _props._addForm;

            if (!_form) {
                _addForm(name);
            }
        }
    }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            var _props2 = this.props,
                name = _props2.name,
                persistent = _props2.persistent,
                _removeForm = _props2._removeForm;

            if (!persistent) {
                _removeForm(name);
            }
        }
    }, {
        key: 'getChildContext',
        value: function getChildContext() {
            var name = this.props.name;

            return {
                reduxFormLite: name
            };
        }
    }, {
        key: 'handleSubmit',
        value: function handleSubmit(ev) {
            var _props3 = this.props,
                name = _props3.name,
                onSubmit = _props3.onSubmit,
                _valid = _props3._valid,
                _values = _props3._values,
                _touchAll = _props3._touchAll,
                _submitting = _props3._submitting,
                _submitStart = _props3._submitStart,
                _submitStop = _props3._submitStop;

            ev.preventDefault();
            _touchAll(name);
            if (_submitting) {
                return;
            }
            if (!_valid || !(0, _helpers.isFunction)(onSubmit)) {
                return;
            }
            var maybePromise = onSubmit(_values);
            if ((0, _helpers.isPromise)(maybePromise)) {
                _submitStart(name);
                maybePromise.then(function () {
                    return _submitStop(name);
                });
            }
        }
    }, {
        key: 'render',
        value: function render() {
            var _props4 = this.props,
                children = _props4.children,
                withRef = _props4.withRef,
                _form = _props4._form;
            // Wait until form is initialized

            if (!_form) {
                return null;
            }
            return React.createElement('form', (0, _formProps2.default)((0, _merge2.default)(this.props, {
                children: children,
                ref: withRef,
                onSubmit: this.handleSubmit
            })));
        }
    }]);

    return Form;
}(React.PureComponent);

Form.childContextTypes = {
    reduxFormLite: React.PropTypes.string.isRequired
};
Form.propTypes = {
    name: React.PropTypes.string.isRequired,
    persistent: React.PropTypes.bool
};
var bindActions = {
    _addForm: actions.addForm,
    _removeForm: actions.removeForm,
    _touchAll: actions.touchAll,
    _submitStart: actions.submitStart,
    _submitStop: actions.submitStop
};
exports.default = (0, _reactRedux.connect)(function (state, props) {
    return {
        _form: Boolean((0, _prop2.default)(props.name, state.reduxFormLite)),
        _values: selectors.valueSelector(props.name, state),
        _valid: selectors.isValid(props.name, state),
        _submitting: selectors.isSubmitting(props.name, state)
    };
}, bindActions)(Form);

/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _compose = __webpack_require__(7);

var _compose2 = _interopRequireDefault(_compose);

var _dec = __webpack_require__(58);

var _dec2 = _interopRequireDefault(_dec);

var _inc = __webpack_require__(66);

var _inc2 = _interopRequireDefault(_inc);

var _lensProp = __webpack_require__(39);

var _lensProp2 = _interopRequireDefault(_lensProp);

var _set = __webpack_require__(42);

var _set2 = _interopRequireDefault(_set);

var _map = __webpack_require__(14);

var _map2 = _interopRequireDefault(_map);

var _lensPath = __webpack_require__(90);

var _lensPath2 = _interopRequireDefault(_lensPath);

var _over = __webpack_require__(40);

var _over2 = _interopRequireDefault(_over);

var _dissocPath = __webpack_require__(60);

var _dissocPath2 = _interopRequireDefault(_dissocPath);

var _assocPath = __webpack_require__(28);

var _assocPath2 = _interopRequireDefault(_assocPath);

exports.default = formsReducer;

var _containers = __webpack_require__(25);

var _arrayShift = __webpack_require__(50);

var _arrayShift2 = _interopRequireDefault(_arrayShift);

var _actions = __webpack_require__(9);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function formsReducer() {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var a = arguments[1];

    switch (a.type) {
        // Form
        // ---
        case _actions.ADD_FORM:
            return (0, _assocPath2.default)([a.payload.name], _containers.form, state);
        case _actions.REMOVE_FORM:
            return (0, _dissocPath2.default)([a.payload.name], state);
        case _actions.ADD_FIELD:
            return (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.id], a.payload.field, state);
        case _actions.REMOVE_FIELD:
            return (0, _dissocPath2.default)([a.payload.form, 'fields', a.payload.id], state);
        case _actions.TOUCH_ALL:
            return (0, _over2.default)((0, _lensPath2.default)([a.payload.form, 'fields']), (0, _map2.default)((0, _set2.default)((0, _lensProp2.default)('touched'), true)), state);
        case _actions.SUBMIT_START:
            return (0, _set2.default)((0, _lensPath2.default)([a.payload.form, 'submitting']), true, state);
        case _actions.SUBMIT_STOP:
            return (0, _set2.default)((0, _lensPath2.default)([a.payload.form, 'submitting']), false, state);
        // Array
        // ---
        case _actions.ADD_ARRAY:
            return (0, _assocPath2.default)([a.payload.form, 'arrays', a.payload.id], 0, state);
        case _actions.REMOVE_ARRAY:
            return (0, _dissocPath2.default)([a.payload.form, 'arrays', a.payload.id], state);
        case _actions.ARRAY_PUSH:
            return (0, _over2.default)((0, _lensPath2.default)([a.payload.form, 'arrays', a.payload.id]), _inc2.default, state);
        case _actions.ARRAY_POP:
            return (0, _over2.default)((0, _lensPath2.default)([a.payload.form, 'arrays', a.payload.id]), _dec2.default, state);
        case _actions.ARRAY_UNSHIFT:
            return (0, _compose2.default)((0, _over2.default)((0, _lensPath2.default)([a.payload.form, 'fields']), (0, _arrayShift2.default)(a.payload.id, 0)), (0, _over2.default)((0, _lensPath2.default)([a.payload.form, 'arrays', a.payload.id]), _inc2.default))(state);
        case _actions.ARRAY_SHIFT:
            return (0, _compose2.default)((0, _over2.default)((0, _lensPath2.default)([a.payload.form, 'fields']), (0, _arrayShift2.default)(a.payload.id, 0, false)), (0, _over2.default)((0, _lensPath2.default)([a.payload.form, 'arrays', a.payload.id]), _dec2.default))(state);
        // Field
        // ---
        case _actions.FIELD_CHANGE:
            return (0, _compose2.default)((0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'value'], a.payload.value), (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'error'], a.payload.error), (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'dirty'], a.payload.dirty))(state);
        case _actions.FIELD_FOCUS:
            return (0, _compose2.default)((0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'active'], true), (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'visited'], true))(state);
        case _actions.FIELD_BLUR:
            return (0, _compose2.default)((0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'value'], a.payload.value), (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'error'], a.payload.error), (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'dirty'], a.payload.dirty), (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'active'], false), (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'touched'], true))(state);
        case _actions.FIELD_VALUE:
            return (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'value'], a.payload.value, state);
        case _actions.FIELD_ERROR:
            return (0, _assocPath2.default)([a.payload.form, 'fields', a.payload.field, 'error'], a.payload.error, state);
        default:
            return state;
    }
}

/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _identity = __webpack_require__(29);

var _identity2 = _interopRequireDefault(_identity);

var _any = __webpack_require__(27);

var _any2 = _interopRequireDefault(_any);

var _none = __webpack_require__(93);

var _none2 = _interopRequireDefault(_none);

var _values = __webpack_require__(103);

var _values2 = _interopRequireDefault(_values);

var _path = __webpack_require__(15);

var _path2 = _interopRequireDefault(_path);

var _prop = __webpack_require__(16);

var _prop2 = _interopRequireDefault(_prop);

var _map = __webpack_require__(14);

var _map2 = _interopRequireDefault(_map);

var _compose = __webpack_require__(7);

var _compose2 = _interopRequireDefault(_compose);

var _memoize = __webpack_require__(91);

var _memoize2 = _interopRequireDefault(_memoize);

exports.valueSelector = valueSelector;
exports.errorSelector = errorSelector;
exports.isValid = isValid;
exports.isTouched = isTouched;
exports.isDirty = isDirty;
exports.isSubmitting = isSubmitting;

var _helpers = __webpack_require__(6);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var memUnflatten = (0, _memoize2.default)(_helpers.unflatten);
var memValue = (0, _memoize2.default)((0, _compose2.default)(memUnflatten, (0, _map2.default)((0, _prop2.default)('value'))));
function valueSelector(name, state) {
    var form = (0, _path2.default)(['reduxFormLite', name], state);
    if (!form) {
        return {};
    }
    return memValue(form.fields);
}
var memError = (0, _memoize2.default)((0, _compose2.default)(memUnflatten, (0, _map2.default)((0, _prop2.default)('error'))));
function errorSelector(name, state) {
    var form = (0, _path2.default)(['reduxFormLite', name], state);
    if (!form) {
        return {};
    }
    return memError(form.fields);
}
var memValues = (0, _memoize2.default)(_values2.default);
var memValid = (0, _memoize2.default)((0, _compose2.default)((0, _none2.default)(Boolean), memValues, (0, _map2.default)((0, _prop2.default)('error'))));
function isValid(name, state) {
    var form = (0, _path2.default)(['reduxFormLite', name], state);
    if (!form) {
        return false;
    }
    // TS thinks 'form.fields' is not a functor
    return memValid(form.fields);
}
var memTouched = (0, _memoize2.default)((0, _compose2.default)((0, _any2.default)(_identity2.default), memValues, (0, _map2.default)((0, _prop2.default)('touched'))));
function isTouched(name, state) {
    var form = (0, _path2.default)(['reduxFormLite', name], state);
    if (!form) {
        return false;
    }
    // TS thinks 'form.fields' is not a functor
    return memTouched(form.fields);
}
var memDirty = (0, _memoize2.default)((0, _compose2.default)((0, _any2.default)(_identity2.default), memValues, (0, _map2.default)((0, _prop2.default)('dirty'))));
function isDirty(name, state) {
    var form = (0, _path2.default)(['reduxFormLite', name], state);
    if (!form) {
        return false;
    }
    // TS thinks 'form.fields' is not a functor
    return memDirty(form.fields);
}
function isSubmitting(name, state) {
    var form = (0, _path2.default)(['reduxFormLite', name], state);
    if (!form) {
        return false;
    }
    return form.submitting;
}

/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _keys = __webpack_require__(4);

var _keys2 = _interopRequireDefault(_keys);

var _prepend = __webpack_require__(97);

var _prepend2 = _interopRequireDefault(_prepend);

var _head = __webpack_require__(64);

var _head2 = _interopRequireDefault(_head);

var _split = __webpack_require__(101);

var _split2 = _interopRequireDefault(_split);

var _tail = __webpack_require__(43);

var _tail2 = _interopRequireDefault(_tail);

var _compose = __webpack_require__(7);

var _compose2 = _interopRequireDefault(_compose);

var _prop = __webpack_require__(16);

var _prop2 = _interopRequireDefault(_prop);

var _assoc = __webpack_require__(10);

var _assoc2 = _interopRequireDefault(_assoc);

var _reduce = __webpack_require__(41);

var _reduce2 = _interopRequireDefault(_reduce);

exports.default = arrayShift;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function arrayShift(path, start) {
    var plus = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;

    var modifier = plus ? 1 : -1;
    return function (fields) {
        return (0, _reduce2.default)(function (acc, key) {
            if (key.indexOf(path) !== 0) {
                return (0, _assoc2.default)(key, (0, _prop2.default)(key, fields), acc);
            }
            var parts = (0, _compose2.default)(_tail2.default, (0, _split2.default)('.'))(key.replace(path, ''));
            var index = Number((0, _head2.default)(parts));
            if (Number.isNaN(index) || index < start) {
                return (0, _assoc2.default)(key, (0, _prop2.default)(key, fields), acc);
            }
            var newindex = index + modifier;
            if (newindex < 0) {
                return acc;
            }
            var lead = path + '.' + newindex;
            var newkey = (0, _prepend2.default)(lead, (0, _tail2.default)(parts)).join('.');
            return (0, _assoc2.default)(newkey, (0, _prop2.default)(key, fields), acc);
        }, {}, (0, _keys2.default)(fields));
    };
}

/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _omit = __webpack_require__(22);

var _omit2 = _interopRequireDefault(_omit);

var _merge = __webpack_require__(5);

var _merge2 = _interopRequireDefault(_merge);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var FIELD_ARRAY_PROPS = ['component', 'withRef',
// state
'_form', '_array',
// actions
'_addArray', '_removeArray', '_arrayPush', '_arrayPop', '_arrayUnshift', '_arrayShift'];
var fieldArrayProps = function fieldArrayProps(props, fields) {
    return (0, _merge2.default)((0, _omit2.default)(FIELD_ARRAY_PROPS, props), { fields: fields });
};
exports.default = fieldArrayProps;

/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _compose = __webpack_require__(7);

var _compose2 = _interopRequireDefault(_compose);

var _flatten = __webpack_require__(63);

var _flatten2 = _interopRequireDefault(_flatten);

var _omit = __webpack_require__(22);

var _omit2 = _interopRequireDefault(_omit);

var _pick = __webpack_require__(95);

var _pick2 = _interopRequireDefault(_pick);

var _merge = __webpack_require__(5);

var _merge2 = _interopRequireDefault(_merge);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var INPUT_PROPS = ['checked', 'name', 'value', 'onChange', 'onFocus', 'onBlur'];
var META_PROPS = ['active', 'dirty', 'error', 'touched', 'visited'];
var FIELD_PROPS = ['component', 'defaultValue', 'normalize', 'validate', 'withRef',
// state
'_form', '_field',
// actions
'_addField', '_removeField', '_fieldChange', '_fieldFocus', '_fieldBlur'];
var maybeCheckProps = function maybeCheckProps(all) {
    if (typeof all.value === 'boolean') {
        return (0, _merge2.default)(all, { checked: all.value });
    }
    return all;
};
var separateProps = function separateProps(all) {
    return {
        input: (0, _pick2.default)(INPUT_PROPS, all),
        meta: (0, _pick2.default)(META_PROPS, all),
        custom: (0, _omit2.default)((0, _flatten2.default)([INPUT_PROPS, META_PROPS, FIELD_PROPS]), all)
    };
};
exports.default = (0, _compose2.default)(separateProps, maybeCheckProps);

/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _omit = __webpack_require__(22);

var _omit2 = _interopRequireDefault(_omit);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var FORM_PROPS = ['name', 'persistent', 'withRef',
// state
'_form', '_values', '_valid', '_submitting',
// actions
'_addForm', '_removeForm', '_touchAll', '_submitStart', '_submitStop'];
var formProps = function formProps(props) {
    return (0, _omit2.default)(FORM_PROPS, props);
};
exports.default = formProps;

/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

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

var _helpers = __webpack_require__(6);

var getSelectedValues = function getSelectedValues(options) {
    return Array.from(options).filter(function (option) {
        return option.selected;
    }).map(function (option) {
        return option.value;
    });
};
var getValue = function getValue(ev) {
    if (!(0, _helpers.isEvent)(ev)) {
        return ev;
    }
    var target = ev.target;
    switch (target.type) {
        case 'checkbox':
            return target.checked;
        case 'file':
            return target.files;
        case 'select-multiple':
            return getSelectedValues(target.options);
        default:
            return target.value;
    }
};
exports.default = getValue;

/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {

var _concat = __webpack_require__(33);
var _curry1 = __webpack_require__(1);
var curryN = __webpack_require__(18);


/**
 * Creates a new list iteration function from an existing one by adding two new
 * parameters to its callback function: the current index, and the entire list.
 *
 * This would turn, for instance, Ramda's simple `map` function into one that
 * more closely resembles `Array.prototype.map`. Note that this will only work
 * for functions in which the iteration callback function is the first
 * parameter, and where the list is the last parameter. (This latter might be
 * unimportant if the list parameter is not used.)
 *
 * @func
 * @memberOf R
 * @since v0.15.0
 * @category Function
 * @category List
 * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)
 * @param {Function} fn A list iteration function that does not pass index or list to its callback
 * @return {Function} An altered list iteration function that passes (item, index, list) to its callback
 * @example
 *
 *      var mapIndexed = R.addIndex(R.map);
 *      mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);
 *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']
 */
module.exports = _curry1(function addIndex(fn) {
  return curryN(fn.length, function() {
    var idx = 0;
    var origFn = arguments[0];
    var list = arguments[arguments.length - 1];
    var args = Array.prototype.slice.call(arguments, 0);
    args[0] = function() {
      var result = origFn.apply(this, _concat(arguments, [idx, list]));
      idx += 1;
      return result;
    };
    return fn.apply(this, args);
  });
});


/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);


/**
 * Returns a function that always returns the given value. Note that for
 * non-primitives the value returned is a reference to the original value.
 *
 * This function is known as `const`, `constant`, or `K` (for K combinator) in
 * other languages and libraries.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Function
 * @sig a -> (* -> a)
 * @param {*} val The value to wrap in a function
 * @return {Function} A Function :: * -> val.
 * @example
 *
 *      var t = R.always('Tee');
 *      t(); //=> 'Tee'
 */
module.exports = _curry1(function always(val) {
  return function() {
    return val;
  };
});


/***/ },
/* 57 */
/***/ function(module, exports, __webpack_require__) {

var _arity = __webpack_require__(8);
var _curry2 = __webpack_require__(0);


/**
 * Creates a function that is bound to a context.
 * Note: `R.bind` does not provide the additional argument-binding capabilities of
 * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
 *
 * @func
 * @memberOf R
 * @since v0.6.0
 * @category Function
 * @category Object
 * @sig (* -> *) -> {*} -> (* -> *)
 * @param {Function} fn The function to bind to context
 * @param {Object} thisObj The context to bind `fn` to
 * @return {Function} A function that will execute in the context of `thisObj`.
 * @see R.partial
 * @example
 *
 *      var log = R.bind(console.log, console);
 *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}
 *      // logs {a: 2}
 * @symb R.bind(f, o)(a, b) = f.call(o, a, b)
 */
module.exports = _curry2(function bind(fn, thisObj) {
  return _arity(fn.length, function() {
    return fn.apply(thisObj, arguments);
  });
});


/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {

var add = __webpack_require__(26);


/**
 * Decrements its argument.
 *
 * @func
 * @memberOf R
 * @since v0.9.0
 * @category Math
 * @sig Number -> Number
 * @param {Number} n
 * @return {Number} n - 1
 * @see R.inc
 * @example
 *
 *      R.dec(42); //=> 41
 */
module.exports = add(-1);


/***/ },
/* 59 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);


/**
 * Returns a new object that does not contain a `prop` property.
 *
 * @func
 * @memberOf R
 * @since v0.10.0
 * @category Object
 * @sig String -> {k: v} -> {k: v}
 * @param {String} prop The name of the property to dissociate
 * @param {Object} obj The object to clone
 * @return {Object} A new object equivalent to the original but without the specified property
 * @see R.assoc
 * @example
 *
 *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
 */
module.exports = _curry2(function dissoc(prop, obj) {
  var result = {};
  for (var p in obj) {
    result[p] = obj[p];
  }
  delete result[prop];
  return result;
});


/***/ },
/* 60 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var assoc = __webpack_require__(10);
var dissoc = __webpack_require__(59);


/**
 * Makes a shallow clone of an object, omitting the property at the given path.
 * Note that this copies and flattens prototype properties onto the new object
 * as well. All non-primitive properties are copied by reference.
 *
 * @func
 * @memberOf R
 * @since v0.11.0
 * @category Object
 * @sig [String] -> {k: v} -> {k: v}
 * @param {Array} path The path to the value to omit
 * @param {Object} obj The object to clone
 * @return {Object} A new object without the property at path
 * @see R.assocPath
 * @example
 *
 *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}
 */
module.exports = _curry2(function dissocPath(path, obj) {
  switch (path.length) {
    case 0:
      return obj;
    case 1:
      return dissoc(path[0], obj);
    default:
      var head = path[0];
      var tail = Array.prototype.slice.call(path, 1);
      return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);
  }
});


/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _equals = __webpack_require__(69);


/**
 * Returns `true` if its arguments are equivalent, `false` otherwise. Handles
 * cyclical data structures.
 *
 * Dispatches symmetrically to the `equals` methods of both arguments, if
 * present.
 *
 * @func
 * @memberOf R
 * @since v0.15.0
 * @category Relation
 * @sig a -> b -> Boolean
 * @param {*} a
 * @param {*} b
 * @return {Boolean}
 * @example
 *
 *      R.equals(1, 1); //=> true
 *      R.equals(1, '1'); //=> false
 *      R.equals([1, 2, 3], [1, 2, 3]); //=> true
 *
 *      var a = {}; a.v = a;
 *      var b = {}; b.v = b;
 *      R.equals(a, b); //=> true
 */
module.exports = _curry2(function equals(a, b) {
  return _equals(a, b, [], []);
});


/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _dispatchable = __webpack_require__(11);
var _filter = __webpack_require__(70);
var _isObject = __webpack_require__(77);
var _reduce = __webpack_require__(20);
var _xfilter = __webpack_require__(86);
var keys = __webpack_require__(4);


/**
 * Takes a predicate and a "filterable", and returns a new filterable of the
 * same type containing the members of the given filterable which satisfy the
 * given predicate.
 *
 * Dispatches to the `filter` method of the second argument, if present.
 *
 * Acts as a transducer if a transformer is given in list position.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig Filterable f => (a -> Boolean) -> f a -> f a
 * @param {Function} pred
 * @param {Array} filterable
 * @return {Array}
 * @see R.reject, R.transduce, R.addIndex
 * @example
 *
 *      var isEven = n => n % 2 === 0;
 *
 *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]
 *
 *      R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
 */
module.exports = _curry2(_dispatchable(['filter'], _xfilter, function(pred, filterable) {
  return (
    _isObject(filterable) ?
      _reduce(function(acc, key) {
        if (pred(filterable[key])) {
          acc[key] = filterable[key];
        }
        return acc;
      }, {}, keys(filterable)) :
    // else
      _filter(pred, filterable)
  );
}));


/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var _makeFlat = __webpack_require__(79);


/**
 * Returns a new list by pulling every item out of it (and all its sub-arrays)
 * and putting them in a new array, depth-first.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig [a] -> [b]
 * @param {Array} list The array to consider.
 * @return {Array} The flattened list.
 * @see R.unnest
 * @example
 *
 *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);
 *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
 */
module.exports = _curry1(_makeFlat(true));


/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {

var nth = __webpack_require__(94);


/**
 * Returns the first element of the given list or string. In some libraries
 * this function is named `first`.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig [a] -> a | Undefined
 * @sig String -> String
 * @param {Array|String} list
 * @return {*}
 * @see R.tail, R.init, R.last
 * @example
 *
 *      R.head(['fi', 'fo', 'fum']); //=> 'fi'
 *      R.head([]); //=> undefined
 *
 *      R.head('abc'); //=> 'a'
 *      R.head(''); //=> ''
 */
module.exports = nth(0);


/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);


/**
 * Returns true if its arguments are identical, false otherwise. Values are
 * identical if they reference the same memory. `NaN` is identical to `NaN`;
 * `0` and `-0` are not identical.
 *
 * @func
 * @memberOf R
 * @since v0.15.0
 * @category Relation
 * @sig a -> a -> Boolean
 * @param {*} a
 * @param {*} b
 * @return {Boolean}
 * @example
 *
 *      var o = {};
 *      R.identical(o, o); //=> true
 *      R.identical(1, 1); //=> true
 *      R.identical(1, '1'); //=> false
 *      R.identical([], []); //=> false
 *      R.identical(0, -0); //=> false
 *      R.identical(NaN, NaN); //=> true
 */
module.exports = _curry2(function identical(a, b) {
  // SameValue algorithm
  if (a === b) { // Steps 1-5, 7-10
    // Steps 6.b-6.e: +0 != -0
    return a !== 0 || 1 / a === 1 / b;
  } else {
    // Step 6.a: NaN == NaN
    return a !== a && b !== b;
  }
});


/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {

var add = __webpack_require__(26);


/**
 * Increments its argument.
 *
 * @func
 * @memberOf R
 * @since v0.9.0
 * @category Math
 * @sig Number -> Number
 * @param {Number} n
 * @return {Number} n + 1
 * @see R.dec
 * @example
 *
 *      R.inc(42); //=> 43
 */
module.exports = add(1);


/***/ },
/* 67 */
/***/ function(module, exports) {

module.exports = function _arrayFromIterator(iter) {
  var list = [];
  var next;
  while (!(next = iter.next()).done) {
    list.push(next.value);
  }
  return list;
};


/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {

var _arity = __webpack_require__(8);
var _isPlaceholder = __webpack_require__(13);


/**
 * Internal curryN function.
 *
 * @private
 * @category Function
 * @param {Number} length The arity of the curried function.
 * @param {Array} received An array of arguments received thus far.
 * @param {Function} fn The function to curry.
 * @return {Function} The curried function.
 */
module.exports = function _curryN(length, received, fn) {
  return function() {
    var combined = [];
    var argsIdx = 0;
    var left = length;
    var combinedIdx = 0;
    while (combinedIdx < received.length || argsIdx < arguments.length) {
      var result;
      if (combinedIdx < received.length &&
          (!_isPlaceholder(received[combinedIdx]) ||
           argsIdx >= arguments.length)) {
        result = received[combinedIdx];
      } else {
        result = arguments[argsIdx];
        argsIdx += 1;
      }
      combined[combinedIdx] = result;
      if (!_isPlaceholder(result)) {
        left -= 1;
      }
      combinedIdx += 1;
    }
    return left <= 0 ? fn.apply(this, combined)
                     : _arity(left, _curryN(length, combined, fn));
  };
};


/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {

var _arrayFromIterator = __webpack_require__(67);
var _functionName = __webpack_require__(71);
var _has = __webpack_require__(3);
var identical = __webpack_require__(65);
var keys = __webpack_require__(4);
var type = __webpack_require__(102);


module.exports = function _equals(a, b, stackA, stackB) {
  if (identical(a, b)) {
    return true;
  }

  if (type(a) !== type(b)) {
    return false;
  }

  if (a == null || b == null) {
    return false;
  }

  if (typeof a.equals === 'function' || typeof b.equals === 'function') {
    return typeof a.equals === 'function' && a.equals(b) &&
           typeof b.equals === 'function' && b.equals(a);
  }

  switch (type(a)) {
    case 'Arguments':
    case 'Array':
    case 'Object':
      if (typeof a.constructor === 'function' &&
          _functionName(a.constructor) === 'Promise') {
        return a === b;
      }
      break;
    case 'Boolean':
    case 'Number':
    case 'String':
      if (!(typeof a === typeof b && identical(a.valueOf(), b.valueOf()))) {
        return false;
      }
      break;
    case 'Date':
      if (!identical(a.valueOf(), b.valueOf())) {
        return false;
      }
      break;
    case 'Error':
      return a.name === b.name && a.message === b.message;
    case 'RegExp':
      if (!(a.source === b.source &&
            a.global === b.global &&
            a.ignoreCase === b.ignoreCase &&
            a.multiline === b.multiline &&
            a.sticky === b.sticky &&
            a.unicode === b.unicode)) {
        return false;
      }
      break;
    case 'Map':
    case 'Set':
      if (!_equals(_arrayFromIterator(a.entries()), _arrayFromIterator(b.entries()), stackA, stackB)) {
        return false;
      }
      break;
    case 'Int8Array':
    case 'Uint8Array':
    case 'Uint8ClampedArray':
    case 'Int16Array':
    case 'Uint16Array':
    case 'Int32Array':
    case 'Uint32Array':
    case 'Float32Array':
    case 'Float64Array':
      break;
    case 'ArrayBuffer':
      break;
    default:
      // Values of other types are only equal if identical.
      return false;
  }

  var keysA = keys(a);
  if (keysA.length !== keys(b).length) {
    return false;
  }

  var idx = stackA.length - 1;
  while (idx >= 0) {
    if (stackA[idx] === a) {
      return stackB[idx] === b;
    }
    idx -= 1;
  }

  stackA.push(a);
  stackB.push(b);
  idx = keysA.length - 1;
  while (idx >= 0) {
    var key = keysA[idx];
    if (!(_has(key, b) && _equals(b[key], a[key], stackA, stackB))) {
      return false;
    }
    idx -= 1;
  }
  stackA.pop();
  stackB.pop();
  return true;
};


/***/ },
/* 70 */
/***/ function(module, exports) {

module.exports = function _filter(fn, list) {
  var idx = 0;
  var len = list.length;
  var result = [];

  while (idx < len) {
    if (fn(list[idx])) {
      result[result.length] = list[idx];
    }
    idx += 1;
  }
  return result;
};


/***/ },
/* 71 */
/***/ function(module, exports) {

module.exports = function _functionName(f) {
  // String(x => x) evaluates to "x => x", so the pattern may not match.
  var match = String(f).match(/^function (\w*)/);
  return match == null ? '' : match[1];
};


/***/ },
/* 72 */
/***/ function(module, exports) {

module.exports = function _identity(x) { return x; };


/***/ },
/* 73 */
/***/ function(module, exports, __webpack_require__) {

var equals = __webpack_require__(61);


module.exports = function _indexOf(list, a, idx) {
  var inf, item;
  // Array.prototype.indexOf doesn't exist below IE9
  if (typeof list.indexOf === 'function') {
    switch (typeof a) {
      case 'number':
        if (a === 0) {
          // manually crawl the list to distinguish between +0 and -0
          inf = 1 / a;
          while (idx < list.length) {
            item = list[idx];
            if (item === 0 && 1 / item === inf) {
              return idx;
            }
            idx += 1;
          }
          return -1;
        } else if (a !== a) {
          // NaN
          while (idx < list.length) {
            item = list[idx];
            if (typeof item === 'number' && item !== item) {
              return idx;
            }
            idx += 1;
          }
          return -1;
        }
        // non-zero numbers can utilise Set
        return list.indexOf(a, idx);

      // all these types can utilise Set
      case 'string':
      case 'boolean':
      case 'function':
      case 'undefined':
        return list.indexOf(a, idx);

      case 'object':
        if (a === null) {
          // null can utilise Set
          return list.indexOf(a, idx);
        }
    }
  }
  // anything else not covered above, defer to R.equals
  while (idx < list.length) {
    if (equals(list[idx], a)) {
      return idx;
    }
    idx += 1;
  }
  return -1;
};


/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {

var _has = __webpack_require__(3);


module.exports = (function() {
  var toString = Object.prototype.toString;
  return toString.call(arguments) === '[object Arguments]' ?
    function _isArguments(x) { return toString.call(x) === '[object Arguments]'; } :
    function _isArguments(x) { return _has('callee', x); };
}());


/***/ },
/* 75 */
/***/ function(module, exports) {

module.exports = function _isFunction(x) {
  return Object.prototype.toString.call(x) === '[object Function]';
};


/***/ },
/* 76 */
/***/ function(module, exports) {

/**
 * Determine if the passed argument is an integer.
 *
 * @private
 * @param {*} n
 * @category Type
 * @return {Boolean}
 */
module.exports = Number.isInteger || function _isInteger(n) {
  return (n << 0) === n;
};


/***/ },
/* 77 */
/***/ function(module, exports) {

module.exports = function _isObject(x) {
  return Object.prototype.toString.call(x) === '[object Object]';
};


/***/ },
/* 78 */
/***/ function(module, exports) {

module.exports = function _isTransformer(obj) {
  return typeof obj['@@transducer/step'] === 'function';
};


/***/ },
/* 79 */
/***/ function(module, exports, __webpack_require__) {

var isArrayLike = __webpack_require__(37);


/**
 * `_makeFlat` is a helper function that returns a one-level or fully recursive
 * function based on the flag passed in.
 *
 * @private
 */
module.exports = function _makeFlat(recursive) {
  return function flatt(list) {
    var value, jlen, j;
    var result = [];
    var idx = 0;
    var ilen = list.length;

    while (idx < ilen) {
      if (isArrayLike(list[idx])) {
        value = recursive ? flatt(list[idx]) : list[idx];
        j = 0;
        jlen = value.length;
        while (j < jlen) {
          result[result.length] = value[j];
          j += 1;
        }
      } else {
        result[result.length] = list[idx];
      }
      idx += 1;
    }
    return result;
  };
};


/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {

var _has = __webpack_require__(3);

// Based on https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
module.exports = function _objectAssign(target) {
  if (target == null) {
    throw new TypeError('Cannot convert undefined or null to object');
  }

  var output = Object(target);
  var idx = 1;
  var length = arguments.length;
  while (idx < length) {
    var source = arguments[idx];
    if (source != null) {
      for (var nextKey in source) {
        if (_has(nextKey, source)) {
          output[nextKey] = source[nextKey];
        }
      }
    }
    idx += 1;
  }
  return output;
};


/***/ },
/* 81 */
/***/ function(module, exports) {

module.exports = function _pipe(f, g) {
  return function() {
    return g.call(this, f.apply(this, arguments));
  };
};


/***/ },
/* 82 */
/***/ function(module, exports) {

module.exports = function _quote(s) {
  var escaped = s
    .replace(/\\/g, '\\\\')
    .replace(/[\b]/g, '\\b')  // \b matches word boundary; [\b] matches backspace
    .replace(/\f/g, '\\f')
    .replace(/\n/g, '\\n')
    .replace(/\r/g, '\\r')
    .replace(/\t/g, '\\t')
    .replace(/\v/g, '\\v')
    .replace(/\0/g, '\\0');

  return '"' + escaped.replace(/"/g, '\\"') + '"';
};


/***/ },
/* 83 */
/***/ function(module, exports) {

module.exports = function _reduced(x) {
  return x && x['@@transducer/reduced'] ? x :
    {
      '@@transducer/value': x,
      '@@transducer/reduced': true
    };
};


/***/ },
/* 84 */
/***/ function(module, exports) {

/**
 * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.
 */
module.exports = (function() {
  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };

  return typeof Date.prototype.toISOString === 'function' ?
    function _toISOString(d) {
      return d.toISOString();
    } :
    function _toISOString(d) {
      return (
        d.getUTCFullYear() + '-' +
        pad(d.getUTCMonth() + 1) + '-' +
        pad(d.getUTCDate()) + 'T' +
        pad(d.getUTCHours()) + ':' +
        pad(d.getUTCMinutes()) + ':' +
        pad(d.getUTCSeconds()) + '.' +
        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'
      );
    };
}());


/***/ },
/* 85 */
/***/ function(module, exports, __webpack_require__) {

var _contains = __webpack_require__(34);
var _map = __webpack_require__(35);
var _quote = __webpack_require__(82);
var _toISOString = __webpack_require__(84);
var keys = __webpack_require__(4);
var reject = __webpack_require__(98);


module.exports = function _toString(x, seen) {
  var recur = function recur(y) {
    var xs = seen.concat([x]);
    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);
  };

  //  mapPairs :: (Object, [String]) -> [String]
  var mapPairs = function(obj, keys) {
    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());
  };

  switch (Object.prototype.toString.call(x)) {
    case '[object Arguments]':
      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';
    case '[object Array]':
      return '[' + _map(recur, x).concat(mapPairs(x, reject(function(k) { return /^\d+$/.test(k); }, keys(x)))).join(', ') + ']';
    case '[object Boolean]':
      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();
    case '[object Date]':
      return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';
    case '[object Null]':
      return 'null';
    case '[object Number]':
      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);
    case '[object String]':
      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);
    case '[object Undefined]':
      return 'undefined';
    default:
      if (typeof x.toString === 'function') {
        var repr = x.toString();
        if (repr !== '[object Object]') {
          return repr;
        }
      }
      return '{' + mapPairs(x, keys(x)).join(', ') + '}';
  }
};


/***/ },
/* 86 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _xfBase = __webpack_require__(21);


module.exports = (function() {
  function XFilter(f, xf) {
    this.xf = xf;
    this.f = f;
  }
  XFilter.prototype['@@transducer/init'] = _xfBase.init;
  XFilter.prototype['@@transducer/result'] = _xfBase.result;
  XFilter.prototype['@@transducer/step'] = function(result, input) {
    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;
  };

  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });
}());


/***/ },
/* 87 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _xfBase = __webpack_require__(21);


module.exports = (function() {
  function XMap(f, xf) {
    this.xf = xf;
    this.f = f;
  }
  XMap.prototype['@@transducer/init'] = _xfBase.init;
  XMap.prototype['@@transducer/result'] = _xfBase.result;
  XMap.prototype['@@transducer/step'] = function(result, input) {
    return this.xf['@@transducer/step'](result, this.f(input));
  };

  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });
}());


/***/ },
/* 88 */
/***/ function(module, exports) {

module.exports = (function() {
  function XWrap(fn) {
    this.f = fn;
  }
  XWrap.prototype['@@transducer/init'] = function() {
    throw new Error('init not implemented on XWrap');
  };
  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };
  XWrap.prototype['@@transducer/step'] = function(acc, x) {
    return this.f(acc, x);
  };

  return function _xwrap(fn) { return new XWrap(fn); };
}());


/***/ },
/* 89 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _isFunction = __webpack_require__(75);
var curryN = __webpack_require__(18);
var toString = __webpack_require__(44);


/**
 * Turns a named method with a specified arity into a function that can be
 * called directly supplied with arguments and a target object.
 *
 * The returned function is curried and accepts `arity + 1` parameters where
 * the final parameter is the target object.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Function
 * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)
 * @param {Number} arity Number of arguments the returned function should take
 *        before the target object.
 * @param {String} method Name of the method to call.
 * @return {Function} A new curried function.
 * @example
 *
 *      var sliceFrom = R.invoker(1, 'slice');
 *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'
 *      var sliceFrom6 = R.invoker(2, 'slice')(6);
 *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'
 * @symb R.invoker(0, 'method')(o) = o['method']()
 * @symb R.invoker(1, 'method')(a, o) = o['method'](a)
 * @symb R.invoker(2, 'method')(a, b, o) = o['method'](a, b)
 */
module.exports = _curry2(function invoker(arity, method) {
  return curryN(arity + 1, function() {
    var target = arguments[arity];
    if (target != null && _isFunction(target[method])) {
      return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));
    }
    throw new TypeError(toString(target) + ' does not have a method named "' + method + '"');
  });
});


/***/ },
/* 90 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var assocPath = __webpack_require__(28);
var lens = __webpack_require__(38);
var path = __webpack_require__(15);


/**
 * Returns a lens whose focus is the specified path.
 *
 * @func
 * @memberOf R
 * @since v0.19.0
 * @category Object
 * @typedefn Idx = String | Int
 * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
 * @sig [Idx] -> Lens s a
 * @param {Array} path The path to use.
 * @return {Lens}
 * @see R.view, R.set, R.over
 * @example
 *
 *      var xHeadYLens = R.lensPath(['x', 0, 'y']);
 *
 *      R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
 *      //=> 2
 *      R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
 *      //=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}
 *      R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
 *      //=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}
 */
module.exports = _curry1(function lensPath(p) {
  return lens(path(p), assocPath(p));
});


/***/ },
/* 91 */
/***/ function(module, exports, __webpack_require__) {

var _arity = __webpack_require__(8);
var _curry1 = __webpack_require__(1);
var _has = __webpack_require__(3);
var toString = __webpack_require__(44);


/**
 * Creates a new function that, when invoked, caches the result of calling `fn`
 * for a given argument set and returns the result. Subsequent calls to the
 * memoized `fn` with the same argument set will not result in an additional
 * call to `fn`; instead, the cached result for that set of arguments will be
 * returned.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Function
 * @sig (*... -> a) -> (*... -> a)
 * @param {Function} fn The function to memoize.
 * @return {Function} Memoized version of `fn`.
 * @example
 *
 *      var count = 0;
 *      var factorial = R.memoize(n => {
 *        count += 1;
 *        return R.product(R.range(1, n + 1));
 *      });
 *      factorial(5); //=> 120
 *      factorial(5); //=> 120
 *      factorial(5); //=> 120
 *      count; //=> 1
 */
module.exports = _curry1(function memoize(fn) {
  var cache = {};
  return _arity(fn.length, function() {
    var key = toString(arguments);
    if (!_has(key, cache)) {
      cache[key] = fn.apply(this, arguments);
    }
    return cache[key];
  });
});


/***/ },
/* 92 */
/***/ function(module, exports, __webpack_require__) {

var _assign = __webpack_require__(30);
var _curry1 = __webpack_require__(1);


/**
 * Merges a list of objects together into one object.
 *
 * @func
 * @memberOf R
 * @since v0.10.0
 * @category List
 * @sig [{k: v}] -> {k: v}
 * @param {Array} list An array of objects
 * @return {Object} A merged object.
 * @see R.reduce
 * @example
 *
 *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}
 *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}
 * @symb R.mergeAll([{ x: 1 }, { y: 2 }, { z: 3 }]) = { x: 1, y: 2, z: 3 }
 */
module.exports = _curry1(function mergeAll(list) {
  return _assign.apply(null, [{}].concat(list));
});


/***/ },
/* 93 */
/***/ function(module, exports, __webpack_require__) {

var _complement = __webpack_require__(32);
var _curry2 = __webpack_require__(0);
var _dispatchable = __webpack_require__(11);
var _xany = __webpack_require__(36);
var any = __webpack_require__(27);


/**
 * Returns `true` if no elements of the list match the predicate, `false`
 * otherwise.
 *
 * Dispatches to the `any` method of the second argument, if present.
 *
 * @func
 * @memberOf R
 * @since v0.12.0
 * @category List
 * @sig (a -> Boolean) -> [a] -> Boolean
 * @param {Function} fn The predicate function.
 * @param {Array} list The array to consider.
 * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.
 * @see R.all, R.any
 * @example
 *
 *      var isEven = n => n % 2 === 0;
 *
 *      R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true
 *      R.none(isEven, [1, 3, 5, 7, 8, 11]); //=> false
 */
module.exports = _curry2(_complement(_dispatchable(['any'], _xany, any)));


/***/ },
/* 94 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);
var _isString = __webpack_require__(19);


/**
 * Returns the nth element of the given list or string. If n is negative the
 * element at index length + n is returned.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig Number -> [a] -> a | Undefined
 * @sig Number -> String -> String
 * @param {Number} offset
 * @param {*} list
 * @return {*}
 * @example
 *
 *      var list = ['foo', 'bar', 'baz', 'quux'];
 *      R.nth(1, list); //=> 'bar'
 *      R.nth(-1, list); //=> 'quux'
 *      R.nth(-99, list); //=> undefined
 *
 *      R.nth(2, 'abc'); //=> 'c'
 *      R.nth(3, 'abc'); //=> ''
 * @symb R.nth(-1, [a, b, c]) = c
 * @symb R.nth(0, [a, b, c]) = a
 * @symb R.nth(1, [a, b, c]) = b
 */
module.exports = _curry2(function nth(offset, list) {
  var idx = offset < 0 ? list.length + offset : offset;
  return _isString(list) ? list.charAt(idx) : list[idx];
});


/***/ },
/* 95 */
/***/ function(module, exports, __webpack_require__) {

var _curry2 = __webpack_require__(0);


/**
 * Returns a partial copy of an object containing only the keys specified. If
 * the key does not exist, the property is ignored.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Object
 * @sig [k] -> {k: v} -> {k: v}
 * @param {Array} names an array of String property names to copy onto a new object
 * @param {Object} obj The object to copy from
 * @return {Object} A new object with only properties from `names` on it.
 * @see R.omit, R.props
 * @example
 *
 *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
 *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}
 */
module.exports = _curry2(function pick(names, obj) {
  var result = {};
  var idx = 0;
  while (idx < names.length) {
    if (names[idx] in obj) {
      result[names[idx]] = obj[names[idx]];
    }
    idx += 1;
  }
  return result;
});


/***/ },
/* 96 */
/***/ function(module, exports, __webpack_require__) {

var _arity = __webpack_require__(8);
var _pipe = __webpack_require__(81);
var reduce = __webpack_require__(41);
var tail = __webpack_require__(43);


/**
 * Performs left-to-right function composition. The leftmost function may have
 * any arity; the remaining functions must be unary.
 *
 * In some libraries this function is named `sequence`.
 *
 * **Note:** The result of pipe is not automatically curried.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Function
 * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)
 * @param {...Function} functions
 * @return {Function}
 * @see R.compose
 * @example
 *
 *      var f = R.pipe(Math.pow, R.negate, R.inc);
 *
 *      f(3, 4); // -(3^4) + 1
 * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))
 */
module.exports = function pipe() {
  if (arguments.length === 0) {
    throw new Error('pipe requires at least one argument');
  }
  return _arity(arguments[0].length,
                reduce(_pipe, arguments[0], tail(arguments)));
};


/***/ },
/* 97 */
/***/ function(module, exports, __webpack_require__) {

var _concat = __webpack_require__(33);
var _curry2 = __webpack_require__(0);


/**
 * Returns a new list with the given element at the front, followed by the
 * contents of the list.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig a -> [a] -> [a]
 * @param {*} el The item to add to the head of the output list.
 * @param {Array} list The array to add to the tail of the output list.
 * @return {Array} A new array.
 * @see R.append
 * @example
 *
 *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']
 */
module.exports = _curry2(function prepend(el, list) {
  return _concat([el], list);
});


/***/ },
/* 98 */
/***/ function(module, exports, __webpack_require__) {

var _complement = __webpack_require__(32);
var _curry2 = __webpack_require__(0);
var filter = __webpack_require__(62);


/**
 * The complement of `filter`.
 *
 * Acts as a transducer if a transformer is given in list position.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig Filterable f => (a -> Boolean) -> f a -> f a
 * @param {Function} pred
 * @param {Array} filterable
 * @return {Array}
 * @see R.filter, R.transduce, R.addIndex
 * @example
 *
 *      var isOdd = (n) => n % 2 === 1;
 *
 *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]
 *
 *      R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
 */
module.exports = _curry2(function reject(pred, filterable) {
  return filter(_complement(pred), filterable);
});


/***/ },
/* 99 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var _isString = __webpack_require__(19);


/**
 * Returns a new list or string with the elements or characters in reverse
 * order.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category List
 * @sig [a] -> [a]
 * @sig String -> String
 * @param {Array|String} list
 * @return {Array|String}
 * @example
 *
 *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]
 *      R.reverse([1, 2]);     //=> [2, 1]
 *      R.reverse([1]);        //=> [1]
 *      R.reverse([]);         //=> []
 *
 *      R.reverse('abc');      //=> 'cba'
 *      R.reverse('ab');       //=> 'ba'
 *      R.reverse('a');        //=> 'a'
 *      R.reverse('');         //=> ''
 */
module.exports = _curry1(function reverse(list) {
  return _isString(list) ? list.split('').reverse().join('') :
                           Array.prototype.slice.call(list, 0).reverse();
});


/***/ },
/* 100 */
/***/ function(module, exports, __webpack_require__) {

var _checkForMethod = __webpack_require__(31);
var _curry3 = __webpack_require__(2);


/**
 * Returns the elements of the given list or string (or object with a `slice`
 * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).
 *
 * Dispatches to the `slice` method of the third argument, if present.
 *
 * @func
 * @memberOf R
 * @since v0.1.4
 * @category List
 * @sig Number -> Number -> [a] -> [a]
 * @sig Number -> Number -> String -> String
 * @param {Number} fromIndex The start index (inclusive).
 * @param {Number} toIndex The end index (exclusive).
 * @param {*} list
 * @return {*}
 * @example
 *
 *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']
 *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']
 *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']
 *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']
 *      R.slice(0, 3, 'ramda');                     //=> 'ram'
 */
module.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {
  return Array.prototype.slice.call(list, fromIndex, toIndex);
}));


/***/ },
/* 101 */
/***/ function(module, exports, __webpack_require__) {

var invoker = __webpack_require__(89);


/**
 * Splits a string into an array of strings based on the given
 * separator.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category String
 * @sig (String | RegExp) -> String -> [String]
 * @param {String|RegExp} sep The pattern.
 * @param {String} str The string to separate into an array.
 * @return {Array} The array of strings from `str` separated by `str`.
 * @see R.join
 * @example
 *
 *      var pathComponents = R.split('/');
 *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']
 *
 *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']
 */
module.exports = invoker(1, 'split');


/***/ },
/* 102 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);


/**
 * Gives a single-word string description of the (native) type of a value,
 * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not
 * attempt to distinguish user Object types any further, reporting them all as
 * 'Object'.
 *
 * @func
 * @memberOf R
 * @since v0.8.0
 * @category Type
 * @sig (* -> {*}) -> String
 * @param {*} val The value to test
 * @return {String}
 * @example
 *
 *      R.type({}); //=> "Object"
 *      R.type(1); //=> "Number"
 *      R.type(false); //=> "Boolean"
 *      R.type('s'); //=> "String"
 *      R.type(null); //=> "Null"
 *      R.type([]); //=> "Array"
 *      R.type(/[A-z]/); //=> "RegExp"
 */
module.exports = _curry1(function type(val) {
  return val === null      ? 'Null'      :
         val === undefined ? 'Undefined' :
         Object.prototype.toString.call(val).slice(8, -1);
});


/***/ },
/* 103 */
/***/ function(module, exports, __webpack_require__) {

var _curry1 = __webpack_require__(1);
var keys = __webpack_require__(4);


/**
 * Returns a list of all the enumerable own properties of the supplied object.
 * Note that the order of the output array is not guaranteed across different
 * JS platforms.
 *
 * @func
 * @memberOf R
 * @since v0.1.0
 * @category Object
 * @sig {k: v} -> [v]
 * @param {Object} obj The object to extract values from
 * @return {Array} An array of the values of the object's own properties.
 * @example
 *
 *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]
 */
module.exports = _curry1(function values(obj) {
  var props = keys(obj);
  var len = props.length;
  var vals = [];
  var idx = 0;
  while (idx < len) {
    vals[idx] = obj[props[idx]];
    idx += 1;
  }
  return vals;
});


/***/ },
/* 104 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.reducer = exports.FieldArray = exports.Field = exports.Form = undefined;

var _Form = __webpack_require__(47);

var _Form2 = _interopRequireDefault(_Form);

var _Field = __webpack_require__(45);

var _Field2 = _interopRequireDefault(_Field);

var _FieldArray = __webpack_require__(46);

var _FieldArray2 = _interopRequireDefault(_FieldArray);

var _formsReducer = __webpack_require__(48);

var _formsReducer2 = _interopRequireDefault(_formsReducer);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.Form = _Form2.default;
exports.Field = _Field2.default;
exports.FieldArray = _FieldArray2.default;
exports.reducer = _formsReducer2.default;

/***/ }
/******/ ]);
});