Fix linting errors

dist/converse.js

@@ -70089,6 +70089,7 @@ if (true) {
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
+/*global module, exports, _ */
 (function webpackUniversalModuleDefinition(root, factory) {
   if (true) module.exports = factory();else {}
 })(this, function () {
@@ -70178,11 +70179,7 @@ if (true) {
 
       return __webpack_require__(0);
       /******/
-    }(
-    /************************************************************************/
-
-    /******/
-    [
+    }([
     /* 0 */
 
     /***/
@@ -70205,7 +70202,7 @@ if (true) {
       if (typeof _ == 'function' && typeof _.runInContext == 'function') {
         // XXX: Customization in order to be able to run both _ and fp in the
         // non-AMD usecase.
-        fp = browserConvert(_.runInContext());
+        window.fp = browserConvert(_.runInContext());
       }
 
       module.exports = browserConvert;
@@ -70382,7 +70379,7 @@ if (true) {
           name = undefined;
         }
 
-        if (func == null) {
+        if (func === null) {
           throw new TypeError();
         }
 
@@ -70588,11 +70585,11 @@ if (true) {
               result = clone(Object(object)),
               nested = result;
 
-          while (nested != null && ++index < length) {
+          while (nested !== null && ++index < length) {
             var key = path[index],
                 value = nested[key];
 
-            if (value != null) {
+            if (value !== null) {
               nested[path[index]] = clone(index == lastIndex ? value : Object(value));
             }
 
@@ -71081,12 +71078,14 @@ if (true) {
             result = {};
 
         for (var key in object) {
-          var value = object[key];
+          if (Object.prototype.hasOwnProperty.call(object, key)) {
+            var value = object[key];
 
-          if (hasOwnProperty.call(result, value)) {
-            result[value].push(key);
-          } else {
-            result[value] = [key];
+            if (hasOwnProperty.call(result, value)) {
+              result[value].push(key);
+            } else {
+              result[value] = [key];
+            }
           }
         }
 
@@ -71191,8 +71190,6 @@ if (true) {
   );
 });
 
-;
-
 /***/ }),
 
 /***/ "./src/headless/backbone.noconflict.js":

src/headless/3rdparty/lodash.fp.js

@@ -1,1042 +1,1041 @@
+/*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();
+    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 module cache
+/******/     var installedModules = {};
 
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
+/******/     // The require function
+/******/     function __webpack_require__(moduleId) {
 
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId])
-/******/ 			return installedModules[moduleId].exports;
+/******/         // 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
-/******/ 		};
+/******/         // 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__);
+/******/         // Execute the module function
+/******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
 
-/******/ 		// Flag the module as loaded
-/******/ 		module.loaded = true;
+/******/         // Flag the module as loaded
+/******/         module.loaded = true;
 
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
+/******/         // Return the exports of the module
+/******/         return module.exports;
+/******/     }
 
 
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
+/******/     // expose the modules object (__webpack_modules__)
+/******/     __webpack_require__.m = modules;
 
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
+/******/     // expose the module cache
+/******/     __webpack_require__.c = installedModules;
 
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
+/******/     // __webpack_public_path__
+/******/     __webpack_require__.p = "";
 
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(0);
-/******/ })
-/************************************************************************/
-/******/ ([
+/******/     // 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') {
+    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.
-	  fp = browserConvert(_.runInContext());
-	}
-	module.exports = browserConvert;
+      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;
+    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) {
-	    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
-	};
+    /** 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 = {};
-
-
+    /**
+     * The default argument placeholder value for methods.
+     *
+     * @type {Object}
+     */
+    module.exports = {};
 /***/ }
 /******/ ])
 });
-;