1(function webpackUniversalModuleDefinition(root, factory) {
2	if(typeof exports === 'object' && typeof module === 'object')
3		module.exports = factory();
4	else if(typeof define === 'function' && define.amd)
5		define([], factory);
6	else if(typeof exports === 'object')
7		exports["fp"] = factory();
8	else
9		root["fp"] = factory();
10})(this, function() {
11return /******/ (function(modules) { // webpackBootstrap
12/******/ 	// The module cache
13/******/ 	var installedModules = {};
14
15/******/ 	// The require function
16/******/ 	function __webpack_require__(moduleId) {
17
18/******/ 		// Check if module is in cache
19/******/ 		if(installedModules[moduleId])
20/******/ 			return installedModules[moduleId].exports;
21
22/******/ 		// Create a new module (and put it into the cache)
23/******/ 		var module = installedModules[moduleId] = {
24/******/ 			exports: {},
25/******/ 			id: moduleId,
26/******/ 			loaded: false
27/******/ 		};
28
29/******/ 		// Execute the module function
30/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
31
32/******/ 		// Flag the module as loaded
33/******/ 		module.loaded = true;
34
35/******/ 		// Return the exports of the module
36/******/ 		return module.exports;
37/******/ 	}
38
39
40/******/ 	// expose the modules object (__webpack_modules__)
41/******/ 	__webpack_require__.m = modules;
42
43/******/ 	// expose the module cache
44/******/ 	__webpack_require__.c = installedModules;
45
46/******/ 	// __webpack_public_path__
47/******/ 	__webpack_require__.p = "";
48
49/******/ 	// Load entry module and return exports
50/******/ 	return __webpack_require__(0);
51/******/ })
52/************************************************************************/
53/******/ ([
54/* 0 */
55/***/ (function(module, exports, __webpack_require__) {
56
57	var baseConvert = __webpack_require__(1);
58
59	/**
60	 * Converts `lodash` to an immutable auto-curried iteratee-first data-last
61	 * version with conversion `options` applied.
62	 *
63	 * @param {Function} lodash The lodash function to convert.
64	 * @param {Object} [options] The options object. See `baseConvert` for more details.
65	 * @returns {Function} Returns the converted `lodash`.
66	 */
67	function browserConvert(lodash, options) {
68	  return baseConvert(lodash, lodash, options);
69	}
70
71	if (typeof _ == 'function' && typeof _.runInContext == 'function') {
72	  _ = browserConvert(_.runInContext());
73	}
74	module.exports = browserConvert;
75
76
77/***/ }),
78/* 1 */
79/***/ (function(module, exports, __webpack_require__) {
80
81	var mapping = __webpack_require__(2),
82	    fallbackHolder = __webpack_require__(3);
83
84	/** Built-in value reference. */
85	var push = Array.prototype.push;
86
87	/**
88	 * Creates a function, with an arity of `n`, that invokes `func` with the
89	 * arguments it receives.
90	 *
91	 * @private
92	 * @param {Function} func The function to wrap.
93	 * @param {number} n The arity of the new function.
94	 * @returns {Function} Returns the new function.
95	 */
96	function baseArity(func, n) {
97	  return n == 2
98	    ? function(a, b) { return func.apply(undefined, arguments); }
99	    : function(a) { return func.apply(undefined, arguments); };
100	}
101
102	/**
103	 * Creates a function that invokes `func`, with up to `n` arguments, ignoring
104	 * any additional arguments.
105	 *
106	 * @private
107	 * @param {Function} func The function to cap arguments for.
108	 * @param {number} n The arity cap.
109	 * @returns {Function} Returns the new function.
110	 */
111	function baseAry(func, n) {
112	  return n == 2
113	    ? function(a, b) { return func(a, b); }
114	    : function(a) { return func(a); };
115	}
116
117	/**
118	 * Creates a clone of `array`.
119	 *
120	 * @private
121	 * @param {Array} array The array to clone.
122	 * @returns {Array} Returns the cloned array.
123	 */
124	function cloneArray(array) {
125	  var length = array ? array.length : 0,
126	      result = Array(length);
127
128	  while (length--) {
129	    result[length] = array[length];
130	  }
131	  return result;
132	}
133
134	/**
135	 * Creates a function that clones a given object using the assignment `func`.
136	 *
137	 * @private
138	 * @param {Function} func The assignment function.
139	 * @returns {Function} Returns the new cloner function.
140	 */
141	function createCloner(func) {
142	  return function(object) {
143	    return func({}, object);
144	  };
145	}
146
147	/**
148	 * A specialized version of `_.spread` which flattens the spread array into
149	 * the arguments of the invoked `func`.
150	 *
151	 * @private
152	 * @param {Function} func The function to spread arguments over.
153	 * @param {number} start The start position of the spread.
154	 * @returns {Function} Returns the new function.
155	 */
156	function flatSpread(func, start) {
157	  return function() {
158	    var length = arguments.length,
159	        lastIndex = length - 1,
160	        args = Array(length);
161
162	    while (length--) {
163	      args[length] = arguments[length];
164	    }
165	    var array = args[start],
166	        otherArgs = args.slice(0, start);
167
168	    if (array) {
169	      push.apply(otherArgs, array);
170	    }
171	    if (start != lastIndex) {
172	      push.apply(otherArgs, args.slice(start + 1));
173	    }
174	    return func.apply(this, otherArgs);
175	  };
176	}
177
178	/**
179	 * Creates a function that wraps `func` and uses `cloner` to clone the first
180	 * argument it receives.
181	 *
182	 * @private
183	 * @param {Function} func The function to wrap.
184	 * @param {Function} cloner The function to clone arguments.
185	 * @returns {Function} Returns the new immutable function.
186	 */
187	function wrapImmutable(func, cloner) {
188	  return function() {
189	    var length = arguments.length;
190	    if (!length) {
191	      return;
192	    }
193	    var args = Array(length);
194	    while (length--) {
195	      args[length] = arguments[length];
196	    }
197	    var result = args[0] = cloner.apply(undefined, args);
198	    func.apply(undefined, args);
199	    return result;
200	  };
201	}
202
203	/**
204	 * The base implementation of `convert` which accepts a `util` object of methods
205	 * required to perform conversions.
206	 *
207	 * @param {Object} util The util object.
208	 * @param {string} name The name of the function to convert.
209	 * @param {Function} func The function to convert.
210	 * @param {Object} [options] The options object.
211	 * @param {boolean} [options.cap=true] Specify capping iteratee arguments.
212	 * @param {boolean} [options.curry=true] Specify currying.
213	 * @param {boolean} [options.fixed=true] Specify fixed arity.
214	 * @param {boolean} [options.immutable=true] Specify immutable operations.
215	 * @param {boolean} [options.rearg=true] Specify rearranging arguments.
216	 * @returns {Function|Object} Returns the converted function or object.
217	 */
218	function baseConvert(util, name, func, options) {
219	  var isLib = typeof name == 'function',
220	      isObj = name === Object(name);
221
222	  if (isObj) {
223	    options = func;
224	    func = name;
225	    name = undefined;
226	  }
227	  if (func == null) {
228	    throw new TypeError;
229	  }
230	  options || (options = {});
231
232	  var config = {
233	    'cap': 'cap' in options ? options.cap : true,
234	    'curry': 'curry' in options ? options.curry : true,
235	    'fixed': 'fixed' in options ? options.fixed : true,
236	    'immutable': 'immutable' in options ? options.immutable : true,
237	    'rearg': 'rearg' in options ? options.rearg : true
238	  };
239
240	  var defaultHolder = isLib ? func : fallbackHolder,
241	      forceCurry = ('curry' in options) && options.curry,
242	      forceFixed = ('fixed' in options) && options.fixed,
243	      forceRearg = ('rearg' in options) && options.rearg,
244	      pristine = isLib ? func.runInContext() : undefined;
245
246	  var helpers = isLib ? func : {
247	    'ary': util.ary,
248	    'assign': util.assign,
249	    'clone': util.clone,
250	    'curry': util.curry,
251	    'forEach': util.forEach,
252	    'isArray': util.isArray,
253	    'isError': util.isError,
254	    'isFunction': util.isFunction,
255	    'isWeakMap': util.isWeakMap,
256	    'iteratee': util.iteratee,
257	    'keys': util.keys,
258	    'rearg': util.rearg,
259	    'toInteger': util.toInteger,
260	    'toPath': util.toPath
261	  };
262
263	  var ary = helpers.ary,
264	      assign = helpers.assign,
265	      clone = helpers.clone,
266	      curry = helpers.curry,
267	      each = helpers.forEach,
268	      isArray = helpers.isArray,
269	      isError = helpers.isError,
270	      isFunction = helpers.isFunction,
271	      isWeakMap = helpers.isWeakMap,
272	      keys = helpers.keys,
273	      rearg = helpers.rearg,
274	      toInteger = helpers.toInteger,
275	      toPath = helpers.toPath;
276
277	  var aryMethodKeys = keys(mapping.aryMethod);
278
279	  var wrappers = {
280	    'castArray': function(castArray) {
281	      return function() {
282	        var value = arguments[0];
283	        return isArray(value)
284	          ? castArray(cloneArray(value))
285	          : castArray.apply(undefined, arguments);
286	      };
287	    },
288	    'iteratee': function(iteratee) {
289	      return function() {
290	        var func = arguments[0],
291	            arity = arguments[1],
292	            result = iteratee(func, arity),
293	            length = result.length;
294
295	        if (config.cap && typeof arity == 'number') {
296	          arity = arity > 2 ? (arity - 2) : 1;
297	          return (length && length <= arity) ? result : baseAry(result, arity);
298	        }
299	        return result;
300	      };
301	    },
302	    'mixin': function(mixin) {
303	      return function(source) {
304	        var func = this;
305	        if (!isFunction(func)) {
306	          return mixin(func, Object(source));
307	        }
308	        var pairs = [];
309	        each(keys(source), function(key) {
310	          if (isFunction(source[key])) {
311	            pairs.push([key, func.prototype[key]]);
312	          }
313	        });
314
315	        mixin(func, Object(source));
316
317	        each(pairs, function(pair) {
318	          var value = pair[1];
319	          if (isFunction(value)) {
320	            func.prototype[pair[0]] = value;
321	          } else {
322	            delete func.prototype[pair[0]];
323	          }
324	        });
325	        return func;
326	      };
327	    },
328	    'nthArg': function(nthArg) {
329	      return function(n) {
330	        var arity = n < 0 ? 1 : (toInteger(n) + 1);
331	        return curry(nthArg(n), arity);
332	      };
333	    },
334	    'rearg': function(rearg) {
335	      return function(func, indexes) {
336	        var arity = indexes ? indexes.length : 0;
337	        return curry(rearg(func, indexes), arity);
338	      };
339	    },
340	    'runInContext': function(runInContext) {
341	      return function(context) {
342	        return baseConvert(util, runInContext(context), options);
343	      };
344	    }
345	  };
346
347	  /*--------------------------------------------------------------------------*/
348
349	  /**
350	   * Casts `func` to a function with an arity capped iteratee if needed.
351	   *
352	   * @private
353	   * @param {string} name The name of the function to inspect.
354	   * @param {Function} func The function to inspect.
355	   * @returns {Function} Returns the cast function.
356	   */
357	  function castCap(name, func) {
358	    if (config.cap) {
359	      var indexes = mapping.iterateeRearg[name];
360	      if (indexes) {
361	        return iterateeRearg(func, indexes);
362	      }
363	      var n = !isLib && mapping.iterateeAry[name];
364	      if (n) {
365	        return iterateeAry(func, n);
366	      }
367	    }
368	    return func;
369	  }
370
371	  /**
372	   * Casts `func` to a curried function if needed.
373	   *
374	   * @private
375	   * @param {string} name The name of the function to inspect.
376	   * @param {Function} func The function to inspect.
377	   * @param {number} n The arity of `func`.
378	   * @returns {Function} Returns the cast function.
379	   */
380	  function castCurry(name, func, n) {
381	    return (forceCurry || (config.curry && n > 1))
382	      ? curry(func, n)
383	      : func;
384	  }
385
386	  /**
387	   * Casts `func` to a fixed arity function if needed.
388	   *
389	   * @private
390	   * @param {string} name The name of the function to inspect.
391	   * @param {Function} func The function to inspect.
392	   * @param {number} n The arity cap.
393	   * @returns {Function} Returns the cast function.
394	   */
395	  function castFixed(name, func, n) {
396	    if (config.fixed && (forceFixed || !mapping.skipFixed[name])) {
397	      var data = mapping.methodSpread[name],
398	          start = data && data.start;
399
400	      return start  === undefined ? ary(func, n) : flatSpread(func, start);
401	    }
402	    return func;
403	  }
404
405	  /**
406	   * Casts `func` to an rearged function if needed.
407	   *
408	   * @private
409	   * @param {string} name The name of the function to inspect.
410	   * @param {Function} func The function to inspect.
411	   * @param {number} n The arity of `func`.
412	   * @returns {Function} Returns the cast function.
413	   */
414	  function castRearg(name, func, n) {
415	    return (config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name]))
416	      ? rearg(func, mapping.methodRearg[name] || mapping.aryRearg[n])
417	      : func;
418	  }
419
420	  /**
421	   * Creates a clone of `object` by `path`.
422	   *
423	   * @private
424	   * @param {Object} object The object to clone.
425	   * @param {Array|string} path The path to clone by.
426	   * @returns {Object} Returns the cloned object.
427	   */
428	  function cloneByPath(object, path) {
429	    path = toPath(path);
430
431	    var index = -1,
432	        length = path.length,
433	        lastIndex = length - 1,
434	        result = clone(Object(object)),
435	        nested = result;
436
437	    while (nested != null && ++index < length) {
438	      var key = path[index],
439	          value = nested[key];
440
441	      if (value != null &&
442	          !(isFunction(value) || isError(value) || isWeakMap(value))) {
443	        nested[key] = clone(index == lastIndex ? value : Object(value));
444	      }
445	      nested = nested[key];
446	    }
447	    return result;
448	  }
449
450	  /**
451	   * Converts `lodash` to an immutable auto-curried iteratee-first data-last
452	   * version with conversion `options` applied.
453	   *
454	   * @param {Object} [options] The options object. See `baseConvert` for more details.
455	   * @returns {Function} Returns the converted `lodash`.
456	   */
457	  function convertLib(options) {
458	    return _.runInContext.convert(options)(undefined);
459	  }
460
461	  /**
462	   * Create a converter function for `func` of `name`.
463	   *
464	   * @param {string} name The name of the function to convert.
465	   * @param {Function} func The function to convert.
466	   * @returns {Function} Returns the new converter function.
467	   */
468	  function createConverter(name, func) {
469	    var realName = mapping.aliasToReal[name] || name,
470	        methodName = mapping.remap[realName] || realName,
471	        oldOptions = options;
472
473	    return function(options) {
474	      var newUtil = isLib ? pristine : helpers,
475	          newFunc = isLib ? pristine[methodName] : func,
476	          newOptions = assign(assign({}, oldOptions), options);
477
478	      return baseConvert(newUtil, realName, newFunc, newOptions);
479	    };
480	  }
481
482	  /**
483	   * Creates a function that wraps `func` to invoke its iteratee, with up to `n`
484	   * arguments, ignoring any additional arguments.
485	   *
486	   * @private
487	   * @param {Function} func The function to cap iteratee arguments for.
488	   * @param {number} n The arity cap.
489	   * @returns {Function} Returns the new function.
490	   */
491	  function iterateeAry(func, n) {
492	    return overArg(func, function(func) {
493	      return typeof func == 'function' ? baseAry(func, n) : func;
494	    });
495	  }
496
497	  /**
498	   * Creates a function that wraps `func` to invoke its iteratee with arguments
499	   * arranged according to the specified `indexes` where the argument value at
500	   * the first index is provided as the first argument, the argument value at
501	   * the second index is provided as the second argument, and so on.
502	   *
503	   * @private
504	   * @param {Function} func The function to rearrange iteratee arguments for.
505	   * @param {number[]} indexes The arranged argument indexes.
506	   * @returns {Function} Returns the new function.
507	   */
508	  function iterateeRearg(func, indexes) {
509	    return overArg(func, function(func) {
510	      var n = indexes.length;
511	      return baseArity(rearg(baseAry(func, n), indexes), n);
512	    });
513	  }
514
515	  /**
516	   * Creates a function that invokes `func` with its first argument transformed.
517	   *
518	   * @private
519	   * @param {Function} func The function to wrap.
520	   * @param {Function} transform The argument transform.
521	   * @returns {Function} Returns the new function.
522	   */
523	  function overArg(func, transform) {
524	    return function() {
525	      var length = arguments.length;
526	      if (!length) {
527	        return func();
528	      }
529	      var args = Array(length);
530	      while (length--) {
531	        args[length] = arguments[length];
532	      }
533	      var index = config.rearg ? 0 : (length - 1);
534	      args[index] = transform(args[index]);
535	      return func.apply(undefined, args);
536	    };
537	  }
538
539	  /**
540	   * Creates a function that wraps `func` and applys the conversions
541	   * rules by `name`.
542	   *
543	   * @private
544	   * @param {string} name The name of the function to wrap.
545	   * @param {Function} func The function to wrap.
546	   * @returns {Function} Returns the converted function.
547	   */
548	  function wrap(name, func, placeholder) {
549	    var result,
550	        realName = mapping.aliasToReal[name] || name,
551	        wrapped = func,
552	        wrapper = wrappers[realName];
553
554	    if (wrapper) {
555	      wrapped = wrapper(func);
556	    }
557	    else if (config.immutable) {
558	      if (mapping.mutate.array[realName]) {
559	        wrapped = wrapImmutable(func, cloneArray);
560	      }
561	      else if (mapping.mutate.object[realName]) {
562	        wrapped = wrapImmutable(func, createCloner(func));
563	      }
564	      else if (mapping.mutate.set[realName]) {
565	        wrapped = wrapImmutable(func, cloneByPath);
566	      }
567	    }
568	    each(aryMethodKeys, function(aryKey) {
569	      each(mapping.aryMethod[aryKey], function(otherName) {
570	        if (realName == otherName) {
571	          var data = mapping.methodSpread[realName],
572	              afterRearg = data && data.afterRearg;
573
574	          result = afterRearg
575	            ? castFixed(realName, castRearg(realName, wrapped, aryKey), aryKey)
576	            : castRearg(realName, castFixed(realName, wrapped, aryKey), aryKey);
577
578	          result = castCap(realName, result);
579	          result = castCurry(realName, result, aryKey);
580	          return false;
581	        }
582	      });
583	      return !result;
584	    });
585
586	    result || (result = wrapped);
587	    if (result == func) {
588	      result = forceCurry ? curry(result, 1) : function() {
589	        return func.apply(this, arguments);
590	      };
591	    }
592	    result.convert = createConverter(realName, func);
593	    result.placeholder = func.placeholder = placeholder;
594
595	    return result;
596	  }
597
598	  /*--------------------------------------------------------------------------*/
599
600	  if (!isObj) {
601	    return wrap(name, func, defaultHolder);
602	  }
603	  var _ = func;
604
605	  // Convert methods by ary cap.
606	  var pairs = [];
607	  each(aryMethodKeys, function(aryKey) {
608	    each(mapping.aryMethod[aryKey], function(key) {
609	      var func = _[mapping.remap[key] || key];
610	      if (func) {
611	        pairs.push([key, wrap(key, func, _)]);
612	      }
613	    });
614	  });
615
616	  // Convert remaining methods.
617	  each(keys(_), function(key) {
618	    var func = _[key];
619	    if (typeof func == 'function') {
620	      var length = pairs.length;
621	      while (length--) {
622	        if (pairs[length][0] == key) {
623	          return;
624	        }
625	      }
626	      func.convert = createConverter(key, func);
627	      pairs.push([key, func]);
628	    }
629	  });
630
631	  // Assign to `_` leaving `_.prototype` unchanged to allow chaining.
632	  each(pairs, function(pair) {
633	    _[pair[0]] = pair[1];
634	  });
635
636	  _.convert = convertLib;
637	  _.placeholder = _;
638
639	  // Assign aliases.
640	  each(keys(_), function(key) {
641	    each(mapping.realToAlias[key] || [], function(alias) {
642	      _[alias] = _[key];
643	    });
644	  });
645
646	  return _;
647	}
648
649	module.exports = baseConvert;
650
651
652/***/ }),
653/* 2 */
654/***/ (function(module, exports) {
655
656	/** Used to map aliases to their real names. */
657	exports.aliasToReal = {
658
659	  // Lodash aliases.
660	  'each': 'forEach',
661	  'eachRight': 'forEachRight',
662	  'entries': 'toPairs',
663	  'entriesIn': 'toPairsIn',
664	  'extend': 'assignIn',
665	  'extendAll': 'assignInAll',
666	  'extendAllWith': 'assignInAllWith',
667	  'extendWith': 'assignInWith',
668	  'first': 'head',
669
670	  // Methods that are curried variants of others.
671	  'conforms': 'conformsTo',
672	  'matches': 'isMatch',
673	  'property': 'get',
674
675	  // Ramda aliases.
676	  '__': 'placeholder',
677	  'F': 'stubFalse',
678	  'T': 'stubTrue',
679	  'all': 'every',
680	  'allPass': 'overEvery',
681	  'always': 'constant',
682	  'any': 'some',
683	  'anyPass': 'overSome',
684	  'apply': 'spread',
685	  'assoc': 'set',
686	  'assocPath': 'set',
687	  'complement': 'negate',
688	  'compose': 'flowRight',
689	  'contains': 'includes',
690	  'dissoc': 'unset',
691	  'dissocPath': 'unset',
692	  'dropLast': 'dropRight',
693	  'dropLastWhile': 'dropRightWhile',
694	  'equals': 'isEqual',
695	  'identical': 'eq',
696	  'indexBy': 'keyBy',
697	  'init': 'initial',
698	  'invertObj': 'invert',
699	  'juxt': 'over',
700	  'omitAll': 'omit',
701	  'nAry': 'ary',
702	  'path': 'get',
703	  'pathEq': 'matchesProperty',
704	  'pathOr': 'getOr',
705	  'paths': 'at',
706	  'pickAll': 'pick',
707	  'pipe': 'flow',
708	  'pluck': 'map',
709	  'prop': 'get',
710	  'propEq': 'matchesProperty',
711	  'propOr': 'getOr',
712	  'props': 'at',
713	  'symmetricDifference': 'xor',
714	  'symmetricDifferenceBy': 'xorBy',
715	  'symmetricDifferenceWith': 'xorWith',
716	  'takeLast': 'takeRight',
717	  'takeLastWhile': 'takeRightWhile',
718	  'unapply': 'rest',
719	  'unnest': 'flatten',
720	  'useWith': 'overArgs',
721	  'where': 'conformsTo',
722	  'whereEq': 'isMatch',
723	  'zipObj': 'zipObject'
724	};
725
726	/** Used to map ary to method names. */
727	exports.aryMethod = {
728	  '1': [
729	    'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create',
730	    'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'flow',
731	    'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'mergeAll',
732	    'methodOf', 'mixin', 'nthArg', 'over', 'overEvery', 'overSome','rest', 'reverse',
733	    'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',
734	    'uniqueId', 'words', 'zipAll'
735	  ],
736	  '2': [
737	    'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assignInAllWith',
738	    'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith',
739	    'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRightN',
740	    'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'difference',
741	    'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq',
742	    'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',
743	    'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach',
744	    'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get',
745	    'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'intersection',
746	    'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'keyBy',
747	    'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesProperty',
748	    'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth', 'omit',
749	    'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'partial',
750	    'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull', 'pullAll',
751	    'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
752	    'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
753	    'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
754	    'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',
755	    'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',
756	    'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',
757	    'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
758	    'zipObjectDeep'
759	  ],
760	  '3': [
761	    'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
762	    'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr',
763	    'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith',
764	    'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth',
765	    'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',
766	    'padCharsStart', 'pullAllBy', 'pullAllWith', 'rangeStep', 'rangeStepRight',
767	    'reduce', 'reduceRight', 'replace', 'set', 'slice', 'sortedIndexBy',
768	    'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith', 'update', 'xorBy',
769	    'xorWith', 'zipWith'
770	  ],
771	  '4': [
772	    'fill', 'setWith', 'updateWith'
773	  ]
774	};
775
776	/** Used to map ary to rearg configs. */
777	exports.aryRearg = {
778	  '2': [1, 0],
779	  '3': [2, 0, 1],
780	  '4': [3, 2, 0, 1]
781	};
782
783	/** Used to map method names to their iteratee ary. */
784	exports.iterateeAry = {
785	  'dropRightWhile': 1,
786	  'dropWhile': 1,
787	  'every': 1,
788	  'filter': 1,
789	  'find': 1,
790	  'findFrom': 1,
791	  'findIndex': 1,
792	  'findIndexFrom': 1,
793	  'findKey': 1,
794	  'findLast': 1,
795	  'findLastFrom': 1,
796	  'findLastIndex': 1,
797	  'findLastIndexFrom': 1,
798	  'findLastKey': 1,
799	  'flatMap': 1,
800	  'flatMapDeep': 1,
801	  'flatMapDepth': 1,
802	  'forEach': 1,
803	  'forEachRight': 1,
804	  'forIn': 1,
805	  'forInRight': 1,
806	  'forOwn': 1,
807	  'forOwnRight': 1,
808	  'map': 1,
809	  'mapKeys': 1,
810	  'mapValues': 1,
811	  'partition': 1,
812	  'reduce': 2,
813	  'reduceRight': 2,
814	  'reject': 1,
815	  'remove': 1,
816	  'some': 1,
817	  'takeRightWhile': 1,
818	  'takeWhile': 1,
819	  'times': 1,
820	  'transform': 2
821	};
822
823	/** Used to map method names to iteratee rearg configs. */
824	exports.iterateeRearg = {
825	  'mapKeys': [1],
826	  'reduceRight': [1, 0]
827	};
828
829	/** Used to map method names to rearg configs. */
830	exports.methodRearg = {
831	  'assignInAllWith': [1, 0],
832	  'assignInWith': [1, 2, 0],
833	  'assignAllWith': [1, 0],
834	  'assignWith': [1, 2, 0],
835	  'differenceBy': [1, 2, 0],
836	  'differenceWith': [1, 2, 0],
837	  'getOr': [2, 1, 0],
838	  'intersectionBy': [1, 2, 0],
839	  'intersectionWith': [1, 2, 0],
840	  'isEqualWith': [1, 2, 0],
841	  'isMatchWith': [2, 1, 0],
842	  'mergeAllWith': [1, 0],
843	  'mergeWith': [1, 2, 0],
844	  'padChars': [2, 1, 0],
845	  'padCharsEnd': [2, 1, 0],
846	  'padCharsStart': [2, 1, 0],
847	  'pullAllBy': [2, 1, 0],
848	  'pullAllWith': [2, 1, 0],
849	  'rangeStep': [1, 2, 0],
850	  'rangeStepRight': [1, 2, 0],
851	  'setWith': [3, 1, 2, 0],
852	  'sortedIndexBy': [2, 1, 0],
853	  'sortedLastIndexBy': [2, 1, 0],
854	  'unionBy': [1, 2, 0],
855	  'unionWith': [1, 2, 0],
856	  'updateWith': [3, 1, 2, 0],
857	  'xorBy': [1, 2, 0],
858	  'xorWith': [1, 2, 0],
859	  'zipWith': [1, 2, 0]
860	};
861
862	/** Used to map method names to spread configs. */
863	exports.methodSpread = {
864	  'assignAll': { 'start': 0 },
865	  'assignAllWith': { 'start': 0 },
866	  'assignInAll': { 'start': 0 },
867	  'assignInAllWith': { 'start': 0 },
868	  'defaultsAll': { 'start': 0 },
869	  'defaultsDeepAll': { 'start': 0 },
870	  'invokeArgs': { 'start': 2 },
871	  'invokeArgsMap': { 'start': 2 },
872	  'mergeAll': { 'start': 0 },
873	  'mergeAllWith': { 'start': 0 },
874	  'partial': { 'start': 1 },
875	  'partialRight': { 'start': 1 },
876	  'without': { 'start': 1 },
877	  'zipAll': { 'start': 0 }
878	};
879
880	/** Used to identify methods which mutate arrays or objects. */
881	exports.mutate = {
882	  'array': {
883	    'fill': true,
884	    'pull': true,
885	    'pullAll': true,
886	    'pullAllBy': true,
887	    'pullAllWith': true,
888	    'pullAt': true,
889	    'remove': true,
890	    'reverse': true
891	  },
892	  'object': {
893	    'assign': true,
894	    'assignAll': true,
895	    'assignAllWith': true,
896	    'assignIn': true,
897	    'assignInAll': true,
898	    'assignInAllWith': true,
899	    'assignInWith': true,
900	    'assignWith': true,
901	    'defaults': true,
902	    'defaultsAll': true,
903	    'defaultsDeep': true,
904	    'defaultsDeepAll': true,
905	    'merge': true,
906	    'mergeAll': true,
907	    'mergeAllWith': true,
908	    'mergeWith': true,
909	  },
910	  'set': {
911	    'set': true,
912	    'setWith': true,
913	    'unset': true,
914	    'update': true,
915	    'updateWith': true
916	  }
917	};
918
919	/** Used to map real names to their aliases. */
920	exports.realToAlias = (function() {
921	  var hasOwnProperty = Object.prototype.hasOwnProperty,
922	      object = exports.aliasToReal,
923	      result = {};
924
925	  for (var key in object) {
926	    var value = object[key];
927	    if (hasOwnProperty.call(result, value)) {
928	      result[value].push(key);
929	    } else {
930	      result[value] = [key];
931	    }
932	  }
933	  return result;
934	}());
935
936	/** Used to map method names to other names. */
937	exports.remap = {
938	  'assignAll': 'assign',
939	  'assignAllWith': 'assignWith',
940	  'assignInAll': 'assignIn',
941	  'assignInAllWith': 'assignInWith',
942	  'curryN': 'curry',
943	  'curryRightN': 'curryRight',
944	  'defaultsAll': 'defaults',
945	  'defaultsDeepAll': 'defaultsDeep',
946	  'findFrom': 'find',
947	  'findIndexFrom': 'findIndex',
948	  'findLastFrom': 'findLast',
949	  'findLastIndexFrom': 'findLastIndex',
950	  'getOr': 'get',
951	  'includesFrom': 'includes',
952	  'indexOfFrom': 'indexOf',
953	  'invokeArgs': 'invoke',
954	  'invokeArgsMap': 'invokeMap',
955	  'lastIndexOfFrom': 'lastIndexOf',
956	  'mergeAll': 'merge',
957	  'mergeAllWith': 'mergeWith',
958	  'padChars': 'pad',
959	  'padCharsEnd': 'padEnd',
960	  'padCharsStart': 'padStart',
961	  'propertyOf': 'get',
962	  'rangeStep': 'range',
963	  'rangeStepRight': 'rangeRight',
964	  'restFrom': 'rest',
965	  'spreadFrom': 'spread',
966	  'trimChars': 'trim',
967	  'trimCharsEnd': 'trimEnd',
968	  'trimCharsStart': 'trimStart',
969	  'zipAll': 'zip'
970	};
971
972	/** Used to track methods that skip fixing their arity. */
973	exports.skipFixed = {
974	  'castArray': true,
975	  'flow': true,
976	  'flowRight': true,
977	  'iteratee': true,
978	  'mixin': true,
979	  'rearg': true,
980	  'runInContext': true
981	};
982
983	/** Used to track methods that skip rearranging arguments. */
984	exports.skipRearg = {
985	  'add': true,
986	  'assign': true,
987	  'assignIn': true,
988	  'bind': true,
989	  'bindKey': true,
990	  'concat': true,
991	  'difference': true,
992	  'divide': true,
993	  'eq': true,
994	  'gt': true,
995	  'gte': true,
996	  'isEqual': true,
997	  'lt': true,
998	  'lte': true,
999	  'matchesProperty': true,
1000	  'merge': true,
1001	  'multiply': true,
1002	  'overArgs': true,
1003	  'partial': true,
1004	  'partialRight': true,
1005	  'propertyOf': true,
1006	  'random': true,
1007	  'range': true,
1008	  'rangeRight': true,
1009	  'subtract': true,
1010	  'zip': true,
1011	  'zipObject': true,
1012	  'zipObjectDeep': true
1013	};
1014
1015
1016/***/ }),
1017/* 3 */
1018/***/ (function(module, exports) {
1019
1020	/**
1021	 * The default argument placeholder value for methods.
1022	 *
1023	 * @type {Object}
1024	 */
1025	module.exports = {};
1026
1027
1028/***/ })
1029/******/ ])
1030});
1031;