/*global module, exports, _ */

(function webpackUniversalModuleDefinition(root, factory) {
    if(typeof exports === 'object' && typeof module === 'object')
        module.exports = factory();
    else if(typeof define === 'function' && define.amd)
        define([], factory);
    else if(typeof exports === 'object')
        exports["fp"] = factory();
    else
        root["fp"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/     // The module cache
/******/     var installedModules = {};

/******/     // The require function
/******/     function __webpack_require__(moduleId) {

/******/         // Check if module is in cache
/******/         if(installedModules[moduleId])
/******/             return installedModules[moduleId].exports;

/******/         // Create a new module (and put it into the cache)
/******/         var module = installedModules[moduleId] = {
/******/             exports: {},
/******/             id: moduleId,
/******/             loaded: false
/******/         };

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

/******/         // Flag the module as loaded
/******/         module.loaded = true;

/******/         // Return the exports of the module
/******/         return module.exports;
/******/     }


/******/     // expose the modules object (__webpack_modules__)
/******/     __webpack_require__.m = modules;

/******/     // expose the module cache
/******/     __webpack_require__.c = installedModules;

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

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

    var baseConvert = __webpack_require__(1);

    /**
     * Converts `lodash` to an immutable auto-curried iteratee-first data-last
     * version with conversion `options` applied.
     *
     * @param {Function} lodash The lodash function to convert.
     * @param {Object} [options] The options object. See `baseConvert` for more details.
     * @returns {Function} Returns the converted `lodash`.
     */
    function browserConvert(lodash, options) {
      return baseConvert(lodash, lodash, options);
    }

    if (typeof _ == 'function' && typeof _.runInContext == 'function') {
      // XXX: Customization in order to be able to run both _ and fp in the
      // non-AMD usecase.
      window.fp = browserConvert(_.runInContext());
    }
    module.exports = browserConvert;


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

    var mapping = __webpack_require__(2),
        fallbackHolder = __webpack_require__(3);

    /** Built-in value reference. */
    var push = Array.prototype.push;

    /**
     * Creates a function, with an arity of `n`, that invokes `func` with the
     * arguments it receives.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {number} n The arity of the new function.
     * @returns {Function} Returns the new function.
     */
    function baseArity(func, n) {
      return n == 2
        ? function(a, b) { return func.apply(undefined, arguments); }
        : function(a) { return func.apply(undefined, arguments); };
    }

    /**
     * Creates a function that invokes `func`, with up to `n` arguments, ignoring
     * any additional arguments.
     *
     * @private
     * @param {Function} func The function to cap arguments for.
     * @param {number} n The arity cap.
     * @returns {Function} Returns the new function.
     */
    function baseAry(func, n) {
      return n == 2
        ? function(a, b) { return func(a, b); }
        : function(a) { return func(a); };
    }

    /**
     * Creates a clone of `array`.
     *
     * @private
     * @param {Array} array The array to clone.
     * @returns {Array} Returns the cloned array.
     */
    function cloneArray(array) {
      var length = array ? array.length : 0,
          result = Array(length);

      while (length--) {
        result[length] = array[length];
      }
      return result;
    }

    /**
     * Creates a function that clones a given object using the assignment `func`.
     *
     * @private
     * @param {Function} func The assignment function.
     * @returns {Function} Returns the new cloner function.
     */
    function createCloner(func) {
      return function(object) {
        return func({}, object);
      };
    }

    /**
     * A specialized version of `_.spread` which flattens the spread array into
     * the arguments of the invoked `func`.
     *
     * @private
     * @param {Function} func The function to spread arguments over.
     * @param {number} start The start position of the spread.
     * @returns {Function} Returns the new function.
     */
    function flatSpread(func, start) {
      return function() {
        var length = arguments.length,
            lastIndex = length - 1,
            args = Array(length);

        while (length--) {
          args[length] = arguments[length];
        }
        var array = args[start],
            otherArgs = args.slice(0, start);

        if (array) {
          push.apply(otherArgs, array);
        }
        if (start != lastIndex) {
          push.apply(otherArgs, args.slice(start + 1));
        }
        return func.apply(this, otherArgs);
      };
    }

    /**
     * Creates a function that wraps `func` and uses `cloner` to clone the first
     * argument it receives.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {Function} cloner The function to clone arguments.
     * @returns {Function} Returns the new immutable function.
     */
    function wrapImmutable(func, cloner) {
      return function() {
        var length = arguments.length;
        if (!length) {
          return;
        }
        var args = Array(length);
        while (length--) {
          args[length] = arguments[length];
        }
        var result = args[0] = cloner.apply(undefined, args);
        func.apply(undefined, args);
        return result;
      };
    }

    /**
     * The base implementation of `convert` which accepts a `util` object of methods
     * required to perform conversions.
     *
     * @param {Object} util The util object.
     * @param {string} name The name of the function to convert.
     * @param {Function} func The function to convert.
     * @param {Object} [options] The options object.
     * @param {boolean} [options.cap=true] Specify capping iteratee arguments.
     * @param {boolean} [options.curry=true] Specify currying.
     * @param {boolean} [options.fixed=true] Specify fixed arity.
     * @param {boolean} [options.immutable=true] Specify immutable operations.
     * @param {boolean} [options.rearg=true] Specify rearranging arguments.
     * @returns {Function|Object} Returns the converted function or object.
     */
    function baseConvert(util, name, func, options) {
      var setPlaceholder,
          isLib = typeof name == 'function',
          isObj = name === Object(name);

      if (isObj) {
        options = func;
        func = name;
        name = undefined;
      }
      if (func === null) {
        throw new TypeError();
      }
      options || (options = {});

      var config = {
        'cap': 'cap' in options ? options.cap : true,
        'curry': 'curry' in options ? options.curry : true,
        'fixed': 'fixed' in options ? options.fixed : true,
        'immutable': 'immutable' in options ? options.immutable : true,
        'rearg': 'rearg' in options ? options.rearg : true
      };

      var forceCurry = ('curry' in options) && options.curry,
          forceFixed = ('fixed' in options) && options.fixed,
          forceRearg = ('rearg' in options) && options.rearg,
          placeholder = isLib ? func : fallbackHolder,
          pristine = isLib ? func.runInContext() : undefined;

      var helpers = isLib ? func : {
        'ary': util.ary,
        'assign': util.assign,
        'clone': util.clone,
        'curry': util.curry,
        'forEach': util.forEach,
        'isArray': util.isArray,
        'isFunction': util.isFunction,
        'iteratee': util.iteratee,
        'keys': util.keys,
        'rearg': util.rearg,
        'toInteger': util.toInteger,
        'toPath': util.toPath
      };

      var ary = helpers.ary,
          assign = helpers.assign,
          clone = helpers.clone,
          curry = helpers.curry,
          each = helpers.forEach,
          isArray = helpers.isArray,
          isFunction = helpers.isFunction,
          keys = helpers.keys,
          rearg = helpers.rearg,
          toInteger = helpers.toInteger,
          toPath = helpers.toPath;

      var aryMethodKeys = keys(mapping.aryMethod);

      var wrappers = {
        'castArray': function(castArray) {
          return function() {
            var value = arguments[0];
            return isArray(value)
              ? castArray(cloneArray(value))
              : castArray.apply(undefined, arguments);
          };
        },
        'iteratee': function(iteratee) {
          return function() {
            var func = arguments[0],
                arity = arguments[1],
                result = iteratee(func, arity),
                length = result.length;

            if (config.cap && typeof arity == 'number') {
              arity = arity > 2 ? (arity - 2) : 1;
              return (length && length <= arity) ? result : baseAry(result, arity);
            }
            return result;
          };
        },
        'mixin': function(mixin) {
          return function(source) {
            var func = this;
            if (!isFunction(func)) {
              return mixin(func, Object(source));
            }
            var pairs = [];
            each(keys(source), function(key) {
              if (isFunction(source[key])) {
                pairs.push([key, func.prototype[key]]);
              }
            });

            mixin(func, Object(source));

            each(pairs, function(pair) {
              var value = pair[1];
              if (isFunction(value)) {
                func.prototype[pair[0]] = value;
              } else {
                delete func.prototype[pair[0]];
              }
            });
            return func;
          };
        },
        'nthArg': function(nthArg) {
          return function(n) {
            var arity = n < 0 ? 1 : (toInteger(n) + 1);
            return curry(nthArg(n), arity);
          };
        },
        'rearg': function(rearg) {
          return function(func, indexes) {
            var arity = indexes ? indexes.length : 0;
            return curry(rearg(func, indexes), arity);
          };
        },
        'runInContext': function(runInContext) {
          return function(context) {
            return baseConvert(util, runInContext(context), options);
          };
        }
      };

      /*--------------------------------------------------------------------------*/

      /**
       * Casts `func` to a function with an arity capped iteratee if needed.
       *
       * @private
       * @param {string} name The name of the function to inspect.
       * @param {Function} func The function to inspect.
       * @returns {Function} Returns the cast function.
       */
      function castCap(name, func) {
        if (config.cap) {
          var indexes = mapping.iterateeRearg[name];
          if (indexes) {
            return iterateeRearg(func, indexes);
          }
          var n = !isLib && mapping.iterateeAry[name];
          if (n) {
            return iterateeAry(func, n);
          }
        }
        return func;
      }

      /**
       * Casts `func` to a curried function if needed.
       *
       * @private
       * @param {string} name The name of the function to inspect.
       * @param {Function} func The function to inspect.
       * @param {number} n The arity of `func`.
       * @returns {Function} Returns the cast function.
       */
      function castCurry(name, func, n) {
        return (forceCurry || (config.curry && n > 1))
          ? curry(func, n)
          : func;
      }

      /**
       * Casts `func` to a fixed arity function if needed.
       *
       * @private
       * @param {string} name The name of the function to inspect.
       * @param {Function} func The function to inspect.
       * @param {number} n The arity cap.
       * @returns {Function} Returns the cast function.
       */
      function castFixed(name, func, n) {
        if (config.fixed && (forceFixed || !mapping.skipFixed[name])) {
          var data = mapping.methodSpread[name],
              start = data && data.start;

          return start  === undefined ? ary(func, n) : flatSpread(func, start);
        }
        return func;
      }

      /**
       * Casts `func` to an rearged function if needed.
       *
       * @private
       * @param {string} name The name of the function to inspect.
       * @param {Function} func The function to inspect.
       * @param {number} n The arity of `func`.
       * @returns {Function} Returns the cast function.
       */
      function castRearg(name, func, n) {
        return (config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name]))
          ? rearg(func, mapping.methodRearg[name] || mapping.aryRearg[n])
          : func;
      }

      /**
       * Creates a clone of `object` by `path`.
       *
       * @private
       * @param {Object} object The object to clone.
       * @param {Array|string} path The path to clone by.
       * @returns {Object} Returns the cloned object.
       */
      function cloneByPath(object, path) {
        path = toPath(path);

        var index = -1,
            length = path.length,
            lastIndex = length - 1,
            result = clone(Object(object)),
            nested = result;

        while (nested !== null && ++index < length) {
          var key = path[index],
              value = nested[key];

          if (value !== null) {
            nested[path[index]] = clone(index == lastIndex ? value : Object(value));
          }
          nested = nested[key];
        }
        return result;
      }

      /**
       * Converts `lodash` to an immutable auto-curried iteratee-first data-last
       * version with conversion `options` applied.
       *
       * @param {Object} [options] The options object. See `baseConvert` for more details.
       * @returns {Function} Returns the converted `lodash`.
       */
      function convertLib(options) {
        return _.runInContext.convert(options)(undefined);
      }

      /**
       * Create a converter function for `func` of `name`.
       *
       * @param {string} name The name of the function to convert.
       * @param {Function} func The function to convert.
       * @returns {Function} Returns the new converter function.
       */
      function createConverter(name, func) {
        var realName = mapping.aliasToReal[name] || name,
            methodName = mapping.remap[realName] || realName,
            oldOptions = options;

        return function(options) {
          var newUtil = isLib ? pristine : helpers,
              newFunc = isLib ? pristine[methodName] : func,
              newOptions = assign(assign({}, oldOptions), options);

          return baseConvert(newUtil, realName, newFunc, newOptions);
        };
      }

      /**
       * Creates a function that wraps `func` to invoke its iteratee, with up to `n`
       * arguments, ignoring any additional arguments.
       *
       * @private
       * @param {Function} func The function to cap iteratee arguments for.
       * @param {number} n The arity cap.
       * @returns {Function} Returns the new function.
       */
      function iterateeAry(func, n) {
        return overArg(func, function(func) {
          return typeof func == 'function' ? baseAry(func, n) : func;
        });
      }

      /**
       * Creates a function that wraps `func` to invoke its iteratee with arguments
       * arranged according to the specified `indexes` where the argument value at
       * the first index is provided as the first argument, the argument value at
       * the second index is provided as the second argument, and so on.
       *
       * @private
       * @param {Function} func The function to rearrange iteratee arguments for.
       * @param {number[]} indexes The arranged argument indexes.
       * @returns {Function} Returns the new function.
       */
      function iterateeRearg(func, indexes) {
        return overArg(func, function(func) {
          var n = indexes.length;
          return baseArity(rearg(baseAry(func, n), indexes), n);
        });
      }

      /**
       * Creates a function that invokes `func` with its first argument transformed.
       *
       * @private
       * @param {Function} func The function to wrap.
       * @param {Function} transform The argument transform.
       * @returns {Function} Returns the new function.
       */
      function overArg(func, transform) {
        return function() {
          var length = arguments.length;
          if (!length) {
            return func();
          }
          var args = Array(length);
          while (length--) {
            args[length] = arguments[length];
          }
          var index = config.rearg ? 0 : (length - 1);
          args[index] = transform(args[index]);
          return func.apply(undefined, args);
        };
      }

      /**
       * Creates a function that wraps `func` and applys the conversions
       * rules by `name`.
       *
       * @private
       * @param {string} name The name of the function to wrap.
       * @param {Function} func The function to wrap.
       * @returns {Function} Returns the converted function.
       */
      function wrap(name, func) {
        var result,
            realName = mapping.aliasToReal[name] || name,
            wrapped = func,
            wrapper = wrappers[realName];

        if (wrapper) {
          wrapped = wrapper(func);
        }
        else if (config.immutable) {
          if (mapping.mutate.array[realName]) {
            wrapped = wrapImmutable(func, cloneArray);
          }
          else if (mapping.mutate.object[realName]) {
            wrapped = wrapImmutable(func, createCloner(func));
          }
          else if (mapping.mutate.set[realName]) {
            wrapped = wrapImmutable(func, cloneByPath);
          }
        }
        each(aryMethodKeys, function(aryKey) {
          each(mapping.aryMethod[aryKey], function(otherName) {
            if (realName == otherName) {
              var data = mapping.methodSpread[realName],
                  afterRearg = data && data.afterRearg;

              result = afterRearg
                ? castFixed(realName, castRearg(realName, wrapped, aryKey), aryKey)
                : castRearg(realName, castFixed(realName, wrapped, aryKey), aryKey);

              result = castCap(realName, result);
              result = castCurry(realName, result, aryKey);
              return false;
            }
          });
          return !result;
        });

        result || (result = wrapped);
        if (result == func) {
          result = forceCurry ? curry(result, 1) : function() {
            return func.apply(this, arguments);
          };
        }
        result.convert = createConverter(realName, func);
        if (mapping.placeholder[realName]) {
          setPlaceholder = true;
          result.placeholder = func.placeholder = placeholder;
        }
        return result;
      }

      /*--------------------------------------------------------------------------*/

      if (!isObj) {
        return wrap(name, func);
      }
      var _ = func;

      // Convert methods by ary cap.
      var pairs = [];
      each(aryMethodKeys, function(aryKey) {
        each(mapping.aryMethod[aryKey], function(key) {
          var func = _[mapping.remap[key] || key];
          if (func) {
            pairs.push([key, wrap(key, func)]);
          }
        });
      });

      // Convert remaining methods.
      each(keys(_), function(key) {
        var func = _[key];
        if (typeof func == 'function') {
          var length = pairs.length;
          while (length--) {
            if (pairs[length][0] == key) {
              return;
            }
          }
          func.convert = createConverter(key, func);
          pairs.push([key, func]);
        }
      });

      // Assign to `_` leaving `_.prototype` unchanged to allow chaining.
      each(pairs, function(pair) {
        _[pair[0]] = pair[1];
      });

      _.convert = convertLib;
      if (setPlaceholder) {
        _.placeholder = placeholder;
      }
      // Assign aliases.
      each(keys(_), function(key) {
        each(mapping.realToAlias[key] || [], function(alias) {
          _[alias] = _[key];
        });
      });

      return _;
    }

    module.exports = baseConvert;


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

    /** Used to map aliases to their real names. */
    exports.aliasToReal = {

      // Lodash aliases.
      'each': 'forEach',
      'eachRight': 'forEachRight',
      'entries': 'toPairs',
      'entriesIn': 'toPairsIn',
      'extend': 'assignIn',
      'extendAll': 'assignInAll',
      'extendAllWith': 'assignInAllWith',
      'extendWith': 'assignInWith',
      'first': 'head',

      // Methods that are curried variants of others.
      'conforms': 'conformsTo',
      'matches': 'isMatch',
      'property': 'get',

      // Ramda aliases.
      '__': 'placeholder',
      'F': 'stubFalse',
      'T': 'stubTrue',
      'all': 'every',
      'allPass': 'overEvery',
      'always': 'constant',
      'any': 'some',
      'anyPass': 'overSome',
      'apply': 'spread',
      'assoc': 'set',
      'assocPath': 'set',
      'complement': 'negate',
      'compose': 'flowRight',
      'contains': 'includes',
      'dissoc': 'unset',
      'dissocPath': 'unset',
      'dropLast': 'dropRight',
      'dropLastWhile': 'dropRightWhile',
      'equals': 'isEqual',
      'identical': 'eq',
      'indexBy': 'keyBy',
      'init': 'initial',
      'invertObj': 'invert',
      'juxt': 'over',
      'omitAll': 'omit',
      'nAry': 'ary',
      'path': 'get',
      'pathEq': 'matchesProperty',
      'pathOr': 'getOr',
      'paths': 'at',
      'pickAll': 'pick',
      'pipe': 'flow',
      'pluck': 'map',
      'prop': 'get',
      'propEq': 'matchesProperty',
      'propOr': 'getOr',
      'props': 'at',
      'symmetricDifference': 'xor',
      'symmetricDifferenceBy': 'xorBy',
      'symmetricDifferenceWith': 'xorWith',
      'takeLast': 'takeRight',
      'takeLastWhile': 'takeRightWhile',
      'unapply': 'rest',
      'unnest': 'flatten',
      'useWith': 'overArgs',
      'where': 'conformsTo',
      'whereEq': 'isMatch',
      'zipObj': 'zipObject'
    };

    /** Used to map ary to method names. */
    exports.aryMethod = {
      '1': [
        'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create',
        'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'flow',
        'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'mergeAll',
        'methodOf', 'mixin', 'nthArg', 'over', 'overEvery', 'overSome','rest', 'reverse',
        'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',
        'uniqueId', 'words', 'zipAll'
      ],
      '2': [
        'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assignInAllWith',
        'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith',
        'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRightN',
        'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'difference',
        'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq',
        'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',
        'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach',
        'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get',
        'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'intersection',
        'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'keyBy',
        'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesProperty',
        'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth', 'omit',
        'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'partial',
        'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull', 'pullAll',
        'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
        'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
        'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
        'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',
        'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',
        'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',
        'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
        'zipObjectDeep'
      ],
      '3': [
        'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
        'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr',
        'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith',
        'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth',
        'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',
        'padCharsStart', 'pullAllBy', 'pullAllWith', 'rangeStep', 'rangeStepRight',
        'reduce', 'reduceRight', 'replace', 'set', 'slice', 'sortedIndexBy',
        'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith', 'update', 'xorBy',
        'xorWith', 'zipWith'
      ],
      '4': [
        'fill', 'setWith', 'updateWith'
      ]
    };

    /** Used to map ary to rearg configs. */
    exports.aryRearg = {
      '2': [1, 0],
      '3': [2, 0, 1],
      '4': [3, 2, 0, 1]
    };

    /** Used to map method names to their iteratee ary. */
    exports.iterateeAry = {
      'dropRightWhile': 1,
      'dropWhile': 1,
      'every': 1,
      'filter': 1,
      'find': 1,
      'findFrom': 1,
      'findIndex': 1,
      'findIndexFrom': 1,
      'findKey': 1,
      'findLast': 1,
      'findLastFrom': 1,
      'findLastIndex': 1,
      'findLastIndexFrom': 1,
      'findLastKey': 1,
      'flatMap': 1,
      'flatMapDeep': 1,
      'flatMapDepth': 1,
      'forEach': 1,
      'forEachRight': 1,
      'forIn': 1,
      'forInRight': 1,
      'forOwn': 1,
      'forOwnRight': 1,
      'map': 1,
      'mapKeys': 1,
      'mapValues': 1,
      'partition': 1,
      'reduce': 2,
      'reduceRight': 2,
      'reject': 1,
      'remove': 1,
      'some': 1,
      'takeRightWhile': 1,
      'takeWhile': 1,
      'times': 1,
      'transform': 2
    };

    /** Used to map method names to iteratee rearg configs. */
    exports.iterateeRearg = {
      'mapKeys': [1],
      'reduceRight': [1, 0]
    };

    /** Used to map method names to rearg configs. */
    exports.methodRearg = {
      'assignInAllWith': [1, 0],
      'assignInWith': [1, 2, 0],
      'assignAllWith': [1, 0],
      'assignWith': [1, 2, 0],
      'differenceBy': [1, 2, 0],
      'differenceWith': [1, 2, 0],
      'getOr': [2, 1, 0],
      'intersectionBy': [1, 2, 0],
      'intersectionWith': [1, 2, 0],
      'isEqualWith': [1, 2, 0],
      'isMatchWith': [2, 1, 0],
      'mergeAllWith': [1, 0],
      'mergeWith': [1, 2, 0],
      'padChars': [2, 1, 0],
      'padCharsEnd': [2, 1, 0],
      'padCharsStart': [2, 1, 0],
      'pullAllBy': [2, 1, 0],
      'pullAllWith': [2, 1, 0],
      'rangeStep': [1, 2, 0],
      'rangeStepRight': [1, 2, 0],
      'setWith': [3, 1, 2, 0],
      'sortedIndexBy': [2, 1, 0],
      'sortedLastIndexBy': [2, 1, 0],
      'unionBy': [1, 2, 0],
      'unionWith': [1, 2, 0],
      'updateWith': [3, 1, 2, 0],
      'xorBy': [1, 2, 0],
      'xorWith': [1, 2, 0],
      'zipWith': [1, 2, 0]
    };

    /** Used to map method names to spread configs. */
    exports.methodSpread = {
      'assignAll': { 'start': 0 },
      'assignAllWith': { 'start': 0 },
      'assignInAll': { 'start': 0 },
      'assignInAllWith': { 'start': 0 },
      'defaultsAll': { 'start': 0 },
      'defaultsDeepAll': { 'start': 0 },
      'invokeArgs': { 'start': 2 },
      'invokeArgsMap': { 'start': 2 },
      'mergeAll': { 'start': 0 },
      'mergeAllWith': { 'start': 0 },
      'partial': { 'start': 1 },
      'partialRight': { 'start': 1 },
      'without': { 'start': 1 },
      'zipAll': { 'start': 0 }
    };

    /** Used to identify methods which mutate arrays or objects. */
    exports.mutate = {
      'array': {
        'fill': true,
        'pull': true,
        'pullAll': true,
        'pullAllBy': true,
        'pullAllWith': true,
        'pullAt': true,
        'remove': true,
        'reverse': true
      },
      'object': {
        'assign': true,
        'assignAll': true,
        'assignAllWith': true,
        'assignIn': true,
        'assignInAll': true,
        'assignInAllWith': true,
        'assignInWith': true,
        'assignWith': true,
        'defaults': true,
        'defaultsAll': true,
        'defaultsDeep': true,
        'defaultsDeepAll': true,
        'merge': true,
        'mergeAll': true,
        'mergeAllWith': true,
        'mergeWith': true,
      },
      'set': {
        'set': true,
        'setWith': true,
        'unset': true,
        'update': true,
        'updateWith': true
      }
    };

    /** Used to track methods with placeholder support */
    exports.placeholder = {
      'bind': true,
      'bindKey': true,
      'curry': true,
      'curryRight': true,
      'partial': true,
      'partialRight': true
    };

    /** Used to map real names to their aliases. */
    exports.realToAlias = (function() {
      var hasOwnProperty = Object.prototype.hasOwnProperty,
          object = exports.aliasToReal,
          result = {};

      for (var key in object) {
       if (Object.prototype.hasOwnProperty.call(object, key)) {
        var value = object[key];
        if (hasOwnProperty.call(result, value)) {
          result[value].push(key);
        } else {
          result[value] = [key];
        }
       }
      }
      return result;
    }());

    /** Used to map method names to other names. */
    exports.remap = {
      'assignAll': 'assign',
      'assignAllWith': 'assignWith',
      'assignInAll': 'assignIn',
      'assignInAllWith': 'assignInWith',
      'curryN': 'curry',
      'curryRightN': 'curryRight',
      'defaultsAll': 'defaults',
      'defaultsDeepAll': 'defaultsDeep',
      'findFrom': 'find',
      'findIndexFrom': 'findIndex',
      'findLastFrom': 'findLast',
      'findLastIndexFrom': 'findLastIndex',
      'getOr': 'get',
      'includesFrom': 'includes',
      'indexOfFrom': 'indexOf',
      'invokeArgs': 'invoke',
      'invokeArgsMap': 'invokeMap',
      'lastIndexOfFrom': 'lastIndexOf',
      'mergeAll': 'merge',
      'mergeAllWith': 'mergeWith',
      'padChars': 'pad',
      'padCharsEnd': 'padEnd',
      'padCharsStart': 'padStart',
      'propertyOf': 'get',
      'rangeStep': 'range',
      'rangeStepRight': 'rangeRight',
      'restFrom': 'rest',
      'spreadFrom': 'spread',
      'trimChars': 'trim',
      'trimCharsEnd': 'trimEnd',
      'trimCharsStart': 'trimStart',
      'zipAll': 'zip'
    };

    /** Used to track methods that skip fixing their arity. */
    exports.skipFixed = {
      'castArray': true,
      'flow': true,
      'flowRight': true,
      'iteratee': true,
      'mixin': true,
      'rearg': true,
      'runInContext': true
    };

    /** Used to track methods that skip rearranging arguments. */
    exports.skipRearg = {
      'add': true,
      'assign': true,
      'assignIn': true,
      'bind': true,
      'bindKey': true,
      'concat': true,
      'difference': true,
      'divide': true,
      'eq': true,
      'gt': true,
      'gte': true,
      'isEqual': true,
      'lt': true,
      'lte': true,
      'matchesProperty': true,
      'merge': true,
      'multiply': true,
      'overArgs': true,
      'partial': true,
      'partialRight': true,
      'propertyOf': true,
      'random': true,
      'range': true,
      'rangeRight': true,
      'subtract': true,
      'zip': true,
      'zipObject': true,
      'zipObjectDeep': true
    };


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

    /**
     * The default argument placeholder value for methods.
     *
     * @type {Object}
     */
    module.exports = {};
/***/ }
/******/ ])
});
