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