public/bower_components/lodash/dist/lodash.fp.js

   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() {
  11 return /******/ (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') {
  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             mutateMap = mapping.mutate,
  83             fallbackHolder = __webpack_require__(3);
  84
  85         /**
  86          * Creates a function, with an arity of `n`, that invokes `func` with the
  87          * arguments it receives.
  88          *
  89          * @private
  90          * @param {Function} func The function to wrap.
  91          * @param {number} n The arity of the new function.
  92          * @returns {Function} Returns the new function.
  93          */
  94         function baseArity(func, n) {
  95           return n == 2
  96             ? function(a, b) { return func.apply(undefined, arguments); }
  97             : function(a) { return func.apply(undefined, arguments); };
  98         }
  99
 100         /**
 101          * Creates a function that invokes `func`, with up to `n` arguments, ignoring
 102          * any additional arguments.
 103          *
 104          * @private
 105          * @param {Function} func The function to cap arguments for.
 106          * @param {number} n The arity cap.
 107          * @returns {Function} Returns the new function.
 108          */
 109         function baseAry(func, n) {
 110           return n == 2
 111             ? function(a, b) { return func(a, b); }
 112             : function(a) { return func(a); };
 113         }
 114
 115         /**
 116          * Creates a clone of `array`.
 117          *
 118          * @private
 119          * @param {Array} array The array to clone.
 120          * @returns {Array} Returns the cloned array.
 121          */
 122         function cloneArray(array) {
 123           var length = array ? array.length : 0,
 124               result = Array(length);
 125
 126           while (length--) {
 127             result[length] = array[length];
 128           }
 129           return result;
 130         }
 131
 132         /**
 133          * Creates a function that clones a given object using the assignment `func`.
 134          *
 135          * @private
 136          * @param {Function} func The assignment function.
 137          * @returns {Function} Returns the new cloner function.
 138          */
 139         function createCloner(func) {
 140           return function(object) {
 141             return func({}, object);
 142           };
 143         }
 144
 145         /**
 146          * Creates a function that wraps `func` and uses `cloner` to clone the first
 147          * argument it receives.
 148          *
 149          * @private
 150          * @param {Function} func The function to wrap.
 151          * @param {Function} cloner The function to clone arguments.
 152          * @returns {Function} Returns the new immutable function.
 153          */
 154         function immutWrap(func, cloner) {
 155           return function() {
 156             var length = arguments.length;
 157             if (!length) {
 158               return result;
 159             }
 160             var args = Array(length);
 161             while (length--) {
 162               args[length] = arguments[length];
 163             }
 164             var result = args[0] = cloner.apply(undefined, args);
 165             func.apply(undefined, args);
 166             return result;
 167           };
 168         }
 169
 170         /**
 171          * The base implementation of `convert` which accepts a `util` object of methods
 172          * required to perform conversions.
 173          *
 174          * @param {Object} util The util object.
 175          * @param {string} name The name of the function to convert.
 176          * @param {Function} func The function to convert.
 177          * @param {Object} [options] The options object.
 178          * @param {boolean} [options.cap=true] Specify capping iteratee arguments.
 179          * @param {boolean} [options.curry=true] Specify currying.
 180          * @param {boolean} [options.fixed=true] Specify fixed arity.
 181          * @param {boolean} [options.immutable=true] Specify immutable operations.
 182          * @param {boolean} [options.rearg=true] Specify rearranging arguments.
 183          * @returns {Function|Object} Returns the converted function or object.
 184          */
 185         function baseConvert(util, name, func, options) {
 186           var setPlaceholder,
 187               isLib = typeof name == 'function',
 188               isObj = name === Object(name);
 189
 190           if (isObj) {
 191             options = func;
 192             func = name;
 193             name = undefined;
 194           }
 195           if (func == null) {
 196             throw new TypeError;
 197           }
 198           options || (options = {});
 199
 200           var config = {
 201             'cap': 'cap' in options ? options.cap : true,
 202             'curry': 'curry' in options ? options.curry : true,
 203             'fixed': 'fixed' in options ? options.fixed : true,
 204             'immutable': 'immutable' in options ? options.immutable : true,
 205             'rearg': 'rearg' in options ? options.rearg : true
 206           };
 207
 208           var forceCurry = ('curry' in options) && options.curry,
 209               forceFixed = ('fixed' in options) && options.fixed,
 210               forceRearg = ('rearg' in options) && options.rearg,
 211               placeholder = isLib ? func : fallbackHolder,
 212               pristine = isLib ? func.runInContext() : undefined;
 213
 214           var helpers = isLib ? func : {
 215             'ary': util.ary,
 216             'assign': util.assign,
 217             'clone': util.clone,
 218             'curry': util.curry,
 219             'forEach': util.forEach,
 220             'isArray': util.isArray,
 221             'isFunction': util.isFunction,
 222             'iteratee': util.iteratee,
 223             'keys': util.keys,
 224             'rearg': util.rearg,
 225             'spread': util.spread,
 226             'toPath': util.toPath
 227           };
 228
 229           var ary = helpers.ary,
 230               assign = helpers.assign,
 231               clone = helpers.clone,
 232               curry = helpers.curry,
 233               each = helpers.forEach,
 234               isArray = helpers.isArray,
 235               isFunction = helpers.isFunction,
 236               keys = helpers.keys,
 237               rearg = helpers.rearg,
 238               spread = helpers.spread,
 239               toPath = helpers.toPath;
 240
 241           var aryMethodKeys = keys(mapping.aryMethod);
 242
 243           var wrappers = {
 244             'castArray': function(castArray) {
 245               return function() {
 246                 var value = arguments[0];
 247                 return isArray(value)
 248                   ? castArray(cloneArray(value))
 249                   : castArray.apply(undefined, arguments);
 250               };
 251             },
 252             'iteratee': function(iteratee) {
 253               return function() {
 254                 var func = arguments[0],
 255                     arity = arguments[1],
 256                     result = iteratee(func, arity),
 257                     length = result.length;
 258
 259                 if (config.cap && typeof arity == 'number') {
 260                   arity = arity > 2 ? (arity - 2) : 1;
 261                   return (length && length <= arity) ? result : baseAry(result, arity);
 262                 }
 263                 return result;
 264               };
 265             },
 266             'mixin': function(mixin) {
 267               return function(source) {
 268                 var func = this;
 269                 if (!isFunction(func)) {
 270                   return mixin(func, Object(source));
 271                 }
 272                 var methods = [],
 273                     methodNames = [];
 274
 275                 each(keys(source), function(key) {
 276                   var value = source[key];
 277                   if (isFunction(value)) {
 278                     methodNames.push(key);
 279                     methods.push(func.prototype[key]);
 280                   }
 281                 });
 282
 283                 mixin(func, Object(source));
 284
 285                 each(methodNames, function(methodName, index) {
 286                   var method = methods[index];
 287                   if (isFunction(method)) {
 288                     func.prototype[methodName] = method;
 289                   } else {
 290                     delete func.prototype[methodName];
 291                   }
 292                 });
 293                 return func;
 294               };
 295             },
 296             'runInContext': function(runInContext) {
 297               return function(context) {
 298                 return baseConvert(util, runInContext(context), options);
 299               };
 300             }
 301           };
 302
 303           /*--------------------------------------------------------------------------*/
 304
 305           /**
 306            * Creates a clone of `object` by `path`.
 307            *
 308            * @private
 309            * @param {Object} object The object to clone.
 310            * @param {Array|string} path The path to clone by.
 311            * @returns {Object} Returns the cloned object.
 312            */
 313           function cloneByPath(object, path) {
 314             path = toPath(path);
 315
 316             var index = -1,
 317                 length = path.length,
 318                 result = clone(Object(object)),
 319                 nested = result;
 320
 321             while (nested != null && ++index < length) {
 322               var key = path[index],
 323                   value = nested[key];
 324
 325               if (value != null) {
 326                 nested[key] = clone(Object(value));
 327               }
 328               nested = nested[key];
 329             }
 330             return result;
 331           }
 332
 333           /**
 334            * Converts `lodash` to an immutable auto-curried iteratee-first data-last
 335            * version with conversion `options` applied.
 336            *
 337            * @param {Object} [options] The options object. See `baseConvert` for more details.
 338            * @returns {Function} Returns the converted `lodash`.
 339            */
 340           function convertLib(options) {
 341             return _.runInContext.convert(options)(undefined);
 342           }
 343
 344           /**
 345            * Create a converter function for `func` of `name`.
 346            *
 347            * @param {string} name The name of the function to convert.
 348            * @param {Function} func The function to convert.
 349            * @returns {Function} Returns the new converter function.
 350            */
 351           function createConverter(name, func) {
 352             var oldOptions = options;
 353             return function(options) {
 354               var newUtil = isLib ? pristine : helpers,
 355                   newFunc = isLib ? pristine[name] : func,
 356                   newOptions = assign(assign({}, oldOptions), options);
 357
 358               return baseConvert(newUtil, name, newFunc, newOptions);
 359             };
 360           }
 361
 362           /**
 363            * Creates a function that wraps `func` to invoke its iteratee, with up to `n`
 364            * arguments, ignoring any additional arguments.
 365            *
 366            * @private
 367            * @param {Function} func The function to cap iteratee arguments for.
 368            * @param {number} n The arity cap.
 369            * @returns {Function} Returns the new function.
 370            */
 371           function iterateeAry(func, n) {
 372             return overArg(func, function(func) {
 373               return typeof func == 'function' ? baseAry(func, n) : func;
 374             });
 375           }
 376
 377           /**
 378            * Creates a function that wraps `func` to invoke its iteratee with arguments
 379            * arranged according to the specified `indexes` where the argument value at
 380            * the first index is provided as the first argument, the argument value at
 381            * the second index is provided as the second argument, and so on.
 382            *
 383            * @private
 384            * @param {Function} func The function to rearrange iteratee arguments for.
 385            * @param {number[]} indexes The arranged argument indexes.
 386            * @returns {Function} Returns the new function.
 387            */
 388           function iterateeRearg(func, indexes) {
 389             return overArg(func, function(func) {
 390               var n = indexes.length;
 391               return baseArity(rearg(baseAry(func, n), indexes), n);
 392             });
 393           }
 394
 395           /**
 396            * Creates a function that invokes `func` with its first argument passed
 397            * thru `transform`.
 398            *
 399            * @private
 400            * @param {Function} func The function to wrap.
 401            * @param {...Function} transform The functions to transform the first argument.
 402            * @returns {Function} Returns the new function.
 403            */
 404           function overArg(func, transform) {
 405             return function() {
 406               var length = arguments.length;
 407               if (!length) {
 408                 return func();
 409               }
 410               var args = Array(length);
 411               while (length--) {
 412                 args[length] = arguments[length];
 413               }
 414               var index = config.rearg ? 0 : (length - 1);
 415               args[index] = transform(args[index]);
 416               return func.apply(undefined, args);
 417             };
 418           }
 419
 420           /**
 421            * Creates a function that wraps `func` and applys the conversions
 422            * rules by `name`.
 423            *
 424            * @private
 425            * @param {string} name The name of the function to wrap.
 426            * @param {Function} func The function to wrap.
 427            * @returns {Function} Returns the converted function.
 428            */
 429           function wrap(name, func) {
 430             name = mapping.aliasToReal[name] || name;
 431
 432             var result,
 433                 wrapped = func,
 434                 wrapper = wrappers[name];
 435
 436             if (wrapper) {
 437               wrapped = wrapper(func);
 438             }
 439             else if (config.immutable) {
 440               if (mutateMap.array[name]) {
 441                 wrapped = immutWrap(func, cloneArray);
 442               }
 443               else if (mutateMap.object[name]) {
 444                 wrapped = immutWrap(func, createCloner(func));
 445               }
 446               else if (mutateMap.set[name]) {
 447                 wrapped = immutWrap(func, cloneByPath);
 448               }
 449             }
 450             each(aryMethodKeys, function(aryKey) {
 451               each(mapping.aryMethod[aryKey], function(otherName) {
 452                 if (name == otherName) {
 453                   var aryN = !isLib && mapping.iterateeAry[name],
 454                       reargIndexes = mapping.iterateeRearg[name],
 455                       spreadStart = mapping.methodSpread[name];
 456
 457                   result = wrapped;
 458                   if (config.fixed && (forceFixed || !mapping.skipFixed[name])) {
 459                     result = spreadStart === undefined
 460                       ? ary(result, aryKey)
 461                       : spread(result, spreadStart);
 462                   }
 463                   if (config.rearg && aryKey > 1 && (forceRearg || !mapping.skipRearg[name])) {
 464                     result = rearg(result, mapping.methodRearg[name] || mapping.aryRearg[aryKey]);
 465                   }
 466                   if (config.cap) {
 467                     if (reargIndexes) {
 468                       result = iterateeRearg(result, reargIndexes);
 469                     } else if (aryN) {
 470                       result = iterateeAry(result, aryN);
 471                     }
 472                   }
 473                   if (forceCurry || (config.curry && aryKey > 1)) {
 474                     forceCurry  && console.log(forceCurry, name);
 475                     result = curry(result, aryKey);
 476                   }
 477                   return false;
 478                 }
 479               });
 480               return !result;
 481             });
 482
 483             result || (result = wrapped);
 484             if (result == func) {
 485               result = forceCurry ? curry(result, 1) : function() {
 486                 return func.apply(this, arguments);
 487               };
 488             }
 489             result.convert = createConverter(name, func);
 490             if (mapping.placeholder[name]) {
 491               setPlaceholder = true;
 492               result.placeholder = func.placeholder = placeholder;
 493             }
 494             return result;
 495           }
 496
 497           /*--------------------------------------------------------------------------*/
 498
 499           if (!isObj) {
 500             return wrap(name, func);
 501           }
 502           var _ = func;
 503
 504           // Convert methods by ary cap.
 505           var pairs = [];
 506           each(aryMethodKeys, function(aryKey) {
 507             each(mapping.aryMethod[aryKey], function(key) {
 508               var func = _[mapping.remap[key] || key];
 509               if (func) {
 510                 pairs.push([key, wrap(key, func)]);
 511               }
 512             });
 513           });
 514
 515           // Convert remaining methods.
 516           each(keys(_), function(key) {
 517             var func = _[key];
 518             if (typeof func == 'function') {
 519               var length = pairs.length;
 520               while (length--) {
 521                 if (pairs[length][0] == key) {
 522                   return;
 523                 }
 524               }
 525               func.convert = createConverter(key, func);
 526               pairs.push([key, func]);
 527             }
 528           });
 529
 530           // Assign to `_` leaving `_.prototype` unchanged to allow chaining.
 531           each(pairs, function(pair) {
 532             _[pair[0]] = pair[1];
 533           });
 534
 535           _.convert = convertLib;
 536           if (setPlaceholder) {
 537             _.placeholder = placeholder;
 538           }
 539           // Assign aliases.
 540           each(keys(_), function(key) {
 541             each(mapping.realToAlias[key] || [], function(alias) {
 542               _[alias] = _[key];
 543             });
 544           });
 545
 546           return _;
 547         }
 548
 549         module.exports = baseConvert;
 550
 551
 552 /***/ },
 553 /* 2 */
 554 /***/ function(module, exports) {
 555
 556         /** Used to map aliases to their real names. */
 557         exports.aliasToReal = {
 558
 559           // Lodash aliases.
 560           'each': 'forEach',
 561           'eachRight': 'forEachRight',
 562           'entries': 'toPairs',
 563           'entriesIn': 'toPairsIn',
 564           'extend': 'assignIn',
 565           'extendWith': 'assignInWith',
 566           'first': 'head',
 567
 568           // Ramda aliases.
 569           '__': 'placeholder',
 570           'all': 'every',
 571           'allPass': 'overEvery',
 572           'always': 'constant',
 573           'any': 'some',
 574           'anyPass': 'overSome',
 575           'apply': 'spread',
 576           'assoc': 'set',
 577           'assocPath': 'set',
 578           'complement': 'negate',
 579           'compose': 'flowRight',
 580           'contains': 'includes',
 581           'dissoc': 'unset',
 582           'dissocPath': 'unset',
 583           'equals': 'isEqual',
 584           'identical': 'eq',
 585           'init': 'initial',
 586           'invertObj': 'invert',
 587           'juxt': 'over',
 588           'omitAll': 'omit',
 589           'nAry': 'ary',
 590           'path': 'get',
 591           'pathEq': 'matchesProperty',
 592           'pathOr': 'getOr',
 593           'paths': 'at',
 594           'pickAll': 'pick',
 595           'pipe': 'flow',
 596           'pluck': 'map',
 597           'prop': 'get',
 598           'propEq': 'matchesProperty',
 599           'propOr': 'getOr',
 600           'props': 'at',
 601           'unapply': 'rest',
 602           'unnest': 'flatten',
 603           'useWith': 'overArgs',
 604           'whereEq': 'filter',
 605           'zipObj': 'zipObject'
 606         };
 607
 608         /** Used to map ary to method names. */
 609         exports.aryMethod = {
 610           '1': [
 611             'attempt', 'castArray', 'ceil', 'create', 'curry', 'curryRight', 'floor',
 612             'flow', 'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method',
 613             'methodOf', 'mixin', 'over', 'overEvery', 'overSome', 'rest', 'reverse',
 614             'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',
 615             'uniqueId', 'words'
 616           ],
 617           '2': [
 618             'add', 'after', 'ary', 'assign', 'assignIn', 'at', 'before', 'bind', 'bindAll',
 619             'bindKey', 'chunk', 'cloneDeepWith', 'cloneWith', 'concat', 'countBy', 'curryN',
 620             'curryRightN', 'debounce', 'defaults', 'defaultsDeep', 'delay', 'difference',
 621             'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith',
 622             'eq', 'every', 'filter', 'find', 'find', 'findIndex', 'findKey', 'findLast',
 623             'findLastIndex', 'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth',
 624             'forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight',
 625             'get', 'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf',
 626             'intersection', 'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch',
 627             'join', 'keyBy', 'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues',
 628             'matchesProperty', 'maxBy', 'meanBy', 'merge', 'minBy', 'multiply', 'nth',
 629             'omit', 'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt',
 630             'partial', 'partialRight', 'partition', 'pick', 'pickBy', 'pull', 'pullAll',
 631             'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
 632             'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
 633             'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
 634             'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',
 635             'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',
 636             'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',
 637             'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
 638             'zipObjectDeep'
 639           ],
 640           '3': [
 641             'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
 642             'getOr', 'inRange', 'intersectionBy', 'intersectionWith', 'invokeArgs',
 643             'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth', 'mergeWith',
 644             'orderBy', 'padChars', 'padCharsEnd', 'padCharsStart', 'pullAllBy',
 645             'pullAllWith', 'reduce', 'reduceRight', 'replace', 'set', 'slice',
 646             'sortedIndexBy', 'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith',
 647             'update', 'xorBy', 'xorWith', 'zipWith'
 648           ],
 649           '4': [
 650             'fill', 'setWith', 'updateWith'
 651           ]
 652         };
 653
 654         /** Used to map ary to rearg configs. */
 655         exports.aryRearg = {
 656           '2': [1, 0],
 657           '3': [2, 0, 1],
 658           '4': [3, 2, 0, 1]
 659         };
 660
 661         /** Used to map method names to their iteratee ary. */
 662         exports.iterateeAry = {
 663           'dropRightWhile': 1,
 664           'dropWhile': 1,
 665           'every': 1,
 666           'filter': 1,
 667           'find': 1,
 668           'findIndex': 1,
 669           'findKey': 1,
 670           'findLast': 1,
 671           'findLastIndex': 1,
 672           'findLastKey': 1,
 673           'flatMap': 1,
 674           'flatMapDeep': 1,
 675           'flatMapDepth': 1,
 676           'forEach': 1,
 677           'forEachRight': 1,
 678           'forIn': 1,
 679           'forInRight': 1,
 680           'forOwn': 1,
 681           'forOwnRight': 1,
 682           'map': 1,
 683           'mapKeys': 1,
 684           'mapValues': 1,
 685           'partition': 1,
 686           'reduce': 2,
 687           'reduceRight': 2,
 688           'reject': 1,
 689           'remove': 1,
 690           'some': 1,
 691           'takeRightWhile': 1,
 692           'takeWhile': 1,
 693           'times': 1,
 694           'transform': 2
 695         };
 696
 697         /** Used to map method names to iteratee rearg configs. */
 698         exports.iterateeRearg = {
 699           'mapKeys': [1]
 700         };
 701
 702         /** Used to map method names to rearg configs. */
 703         exports.methodRearg = {
 704           'assignInWith': [1, 2, 0],
 705           'assignWith': [1, 2, 0],
 706           'getOr': [2, 1, 0],
 707           'isEqualWith': [1, 2, 0],
 708           'isMatchWith': [2, 1, 0],
 709           'mergeWith': [1, 2, 0],
 710           'padChars': [2, 1, 0],
 711           'padCharsEnd': [2, 1, 0],
 712           'padCharsStart': [2, 1, 0],
 713           'pullAllBy': [2, 1, 0],
 714           'pullAllWith': [2, 1, 0],
 715           'setWith': [3, 1, 2, 0],
 716           'sortedIndexBy': [2, 1, 0],
 717           'sortedLastIndexBy': [2, 1, 0],
 718           'updateWith': [3, 1, 2, 0],
 719           'zipWith': [1, 2, 0]
 720         };
 721
 722         /** Used to map method names to spread configs. */
 723         exports.methodSpread = {
 724           'invokeArgs': 2,
 725           'invokeArgsMap': 2,
 726           'partial': 1,
 727           'partialRight': 1,
 728           'without': 1
 729         };
 730
 731         /** Used to identify methods which mutate arrays or objects. */
 732         exports.mutate = {
 733           'array': {
 734             'fill': true,
 735             'pull': true,
 736             'pullAll': true,
 737             'pullAllBy': true,
 738             'pullAllWith': true,
 739             'pullAt': true,
 740             'remove': true,
 741             'reverse': true
 742           },
 743           'object': {
 744             'assign': true,
 745             'assignIn': true,
 746             'assignInWith': true,
 747             'assignWith': true,
 748             'defaults': true,
 749             'defaultsDeep': true,
 750             'merge': true,
 751             'mergeWith': true
 752           },
 753           'set': {
 754             'set': true,
 755             'setWith': true,
 756             'unset': true,
 757             'update': true,
 758             'updateWith': true
 759           }
 760         };
 761
 762         /** Used to track methods with placeholder support */
 763         exports.placeholder = {
 764           'bind': true,
 765           'bindKey': true,
 766           'curry': true,
 767           'curryRight': true,
 768           'partial': true,
 769           'partialRight': true
 770         };
 771
 772         /** Used to map real names to their aliases. */
 773         exports.realToAlias = (function() {
 774           var hasOwnProperty = Object.prototype.hasOwnProperty,
 775               object = exports.aliasToReal,
 776               result = {};
 777
 778           for (var key in object) {
 779             var value = object[key];
 780             if (hasOwnProperty.call(result, value)) {
 781               result[value].push(key);
 782             } else {
 783               result[value] = [key];
 784             }
 785           }
 786           return result;
 787         }());
 788
 789         /** Used to map method names to other names. */
 790         exports.remap = {
 791           'curryN': 'curry',
 792           'curryRightN': 'curryRight',
 793           'getOr': 'get',
 794           'invokeArgs': 'invoke',
 795           'invokeArgsMap': 'invokeMap',
 796           'padChars': 'pad',
 797           'padCharsEnd': 'padEnd',
 798           'padCharsStart': 'padStart',
 799           'restFrom': 'rest',
 800           'spreadFrom': 'spread',
 801           'trimChars': 'trim',
 802           'trimCharsEnd': 'trimEnd',
 803           'trimCharsStart': 'trimStart'
 804         };
 805
 806         /** Used to track methods that skip fixing their arity. */
 807         exports.skipFixed = {
 808           'castArray': true,
 809           'flow': true,
 810           'flowRight': true,
 811           'iteratee': true,
 812           'mixin': true,
 813           'runInContext': true
 814         };
 815
 816         /** Used to track methods that skip rearranging arguments. */
 817         exports.skipRearg = {
 818           'add': true,
 819           'assign': true,
 820           'assignIn': true,
 821           'bind': true,
 822           'bindKey': true,
 823           'concat': true,
 824           'difference': true,
 825           'divide': true,
 826           'eq': true,
 827           'gt': true,
 828           'gte': true,
 829           'isEqual': true,
 830           'lt': true,
 831           'lte': true,
 832           'matchesProperty': true,
 833           'merge': true,
 834           'multiply': true,
 835           'overArgs': true,
 836           'partial': true,
 837           'partialRight': true,
 838           'random': true,
 839           'range': true,
 840           'rangeRight': true,
 841           'subtract': true,
 842           'without': true,
 843           'zip': true,
 844           'zipObject': true
 845         };
 846
 847
 848 /***/ },
 849 /* 3 */
 850 /***/ function(module, exports) {
 851
 852         /**
 853          * The default argument placeholder value for methods.
 854          *
 855          * @type {Object}
 856          */
 857         module.exports = {};
 858
 859
 860 /***/ }
 861 /******/ ])
 862 });
 863 ;