ecomp-portal-FE/client/bower_components/lodash/dist/mapping.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["mapping"] = factory();
   8         else
   9                 root["mapping"] = 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) {
  56
  57         /** Used to map aliases to their real names. */
  58         exports.aliasToReal = {
  59
  60           // Lodash aliases.
  61           'each': 'forEach',
  62           'eachRight': 'forEachRight',
  63           'entries': 'toPairs',
  64           'entriesIn': 'toPairsIn',
  65           'extend': 'assignIn',
  66           'extendWith': 'assignInWith',
  67           'first': 'head',
  68
  69           // Ramda aliases.
  70           '__': 'placeholder',
  71           'all': 'every',
  72           'allPass': 'overEvery',
  73           'always': 'constant',
  74           'any': 'some',
  75           'anyPass': 'overSome',
  76           'apply': 'spread',
  77           'assoc': 'set',
  78           'assocPath': 'set',
  79           'complement': 'negate',
  80           'compose': 'flowRight',
  81           'contains': 'includes',
  82           'dissoc': 'unset',
  83           'dissocPath': 'unset',
  84           'equals': 'isEqual',
  85           'identical': 'eq',
  86           'init': 'initial',
  87           'invertObj': 'invert',
  88           'juxt': 'over',
  89           'omitAll': 'omit',
  90           'nAry': 'ary',
  91           'path': 'get',
  92           'pathEq': 'matchesProperty',
  93           'pathOr': 'getOr',
  94           'paths': 'at',
  95           'pickAll': 'pick',
  96           'pipe': 'flow',
  97           'pluck': 'map',
  98           'prop': 'get',
  99           'propEq': 'matchesProperty',
 100           'propOr': 'getOr',
 101           'props': 'at',
 102           'unapply': 'rest',
 103           'unnest': 'flatten',
 104           'useWith': 'overArgs',
 105           'whereEq': 'filter',
 106           'zipObj': 'zipObject'
 107         };
 108
 109         /** Used to map ary to method names. */
 110         exports.aryMethod = {
 111           '1': [
 112             'attempt', 'castArray', 'ceil', 'create', 'curry', 'curryRight', 'floor',
 113             'flow', 'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method',
 114             'methodOf', 'mixin', 'over', 'overEvery', 'overSome', 'rest', 'reverse',
 115             'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',
 116             'uniqueId', 'words'
 117           ],
 118           '2': [
 119             'add', 'after', 'ary', 'assign', 'assignIn', 'at', 'before', 'bind', 'bindAll',
 120             'bindKey', 'chunk', 'cloneDeepWith', 'cloneWith', 'concat', 'countBy', 'curryN',
 121             'curryRightN', 'debounce', 'defaults', 'defaultsDeep', 'delay', 'difference',
 122             'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith',
 123             'eq', 'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast',
 124             'findLastIndex', 'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth',
 125             'forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight',
 126             'get', 'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf',
 127             'intersection', 'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch',
 128             'join', 'keyBy', 'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues',
 129             'matchesProperty', 'maxBy', 'meanBy', 'merge', 'minBy', 'multiply', 'nth',
 130             'omit', 'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt',
 131             'partial', 'partialRight', 'partition', 'pick', 'pickBy', 'pull', 'pullAll',
 132             'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
 133             'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
 134             'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
 135             'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',
 136             'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',
 137             'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',
 138             'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
 139             'zipObjectDeep'
 140           ],
 141           '3': [
 142             'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
 143             'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr',
 144             'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith',
 145             'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth',
 146             'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',
 147             'padCharsStart', 'pullAllBy', 'pullAllWith', 'reduce', 'reduceRight', 'replace',
 148             'set', 'slice', 'sortedIndexBy', 'sortedLastIndexBy', 'transform', 'unionBy',
 149             'unionWith', 'update', 'xorBy', 'xorWith', 'zipWith'
 150           ],
 151           '4': [
 152             'fill', 'setWith', 'updateWith'
 153           ]
 154         };
 155
 156         /** Used to map ary to rearg configs. */
 157         exports.aryRearg = {
 158           '2': [1, 0],
 159           '3': [2, 0, 1],
 160           '4': [3, 2, 0, 1]
 161         };
 162
 163         /** Used to map method names to their iteratee ary. */
 164         exports.iterateeAry = {
 165           'dropRightWhile': 1,
 166           'dropWhile': 1,
 167           'every': 1,
 168           'filter': 1,
 169           'find': 1,
 170           'findFrom': 1,
 171           'findIndex': 1,
 172           'findIndexFrom': 1,
 173           'findKey': 1,
 174           'findLast': 1,
 175           'findLastFrom': 1,
 176           'findLastIndex': 1,
 177           'findLastIndexFrom': 1,
 178           'findLastKey': 1,
 179           'flatMap': 1,
 180           'flatMapDeep': 1,
 181           'flatMapDepth': 1,
 182           'forEach': 1,
 183           'forEachRight': 1,
 184           'forIn': 1,
 185           'forInRight': 1,
 186           'forOwn': 1,
 187           'forOwnRight': 1,
 188           'map': 1,
 189           'mapKeys': 1,
 190           'mapValues': 1,
 191           'partition': 1,
 192           'reduce': 2,
 193           'reduceRight': 2,
 194           'reject': 1,
 195           'remove': 1,
 196           'some': 1,
 197           'takeRightWhile': 1,
 198           'takeWhile': 1,
 199           'times': 1,
 200           'transform': 2
 201         };
 202
 203         /** Used to map method names to iteratee rearg configs. */
 204         exports.iterateeRearg = {
 205           'mapKeys': [1]
 206         };
 207
 208         /** Used to map method names to rearg configs. */
 209         exports.methodRearg = {
 210           'assignInWith': [1, 2, 0],
 211           'assignWith': [1, 2, 0],
 212           'differenceBy': [1, 2, 0],
 213           'differenceWith': [1, 2, 0],
 214           'getOr': [2, 1, 0],
 215           'intersectionBy': [1, 2, 0],
 216           'intersectionWith': [1, 2, 0],
 217           'isEqualWith': [1, 2, 0],
 218           'isMatchWith': [2, 1, 0],
 219           'mergeWith': [1, 2, 0],
 220           'padChars': [2, 1, 0],
 221           'padCharsEnd': [2, 1, 0],
 222           'padCharsStart': [2, 1, 0],
 223           'pullAllBy': [2, 1, 0],
 224           'pullAllWith': [2, 1, 0],
 225           'setWith': [3, 1, 2, 0],
 226           'sortedIndexBy': [2, 1, 0],
 227           'sortedLastIndexBy': [2, 1, 0],
 228           'unionBy': [1, 2, 0],
 229           'unionWith': [1, 2, 0],
 230           'updateWith': [3, 1, 2, 0],
 231           'xorBy': [1, 2, 0],
 232           'xorWith': [1, 2, 0],
 233           'zipWith': [1, 2, 0]
 234         };
 235
 236         /** Used to map method names to spread configs. */
 237         exports.methodSpread = {
 238           'invokeArgs': 2,
 239           'invokeArgsMap': 2,
 240           'partial': 1,
 241           'partialRight': 1,
 242           'without': 1
 243         };
 244
 245         /** Used to identify methods which mutate arrays or objects. */
 246         exports.mutate = {
 247           'array': {
 248             'fill': true,
 249             'pull': true,
 250             'pullAll': true,
 251             'pullAllBy': true,
 252             'pullAllWith': true,
 253             'pullAt': true,
 254             'remove': true,
 255             'reverse': true
 256           },
 257           'object': {
 258             'assign': true,
 259             'assignIn': true,
 260             'assignInWith': true,
 261             'assignWith': true,
 262             'defaults': true,
 263             'defaultsDeep': true,
 264             'merge': true,
 265             'mergeWith': true
 266           },
 267           'set': {
 268             'set': true,
 269             'setWith': true,
 270             'unset': true,
 271             'update': true,
 272             'updateWith': true
 273           }
 274         };
 275
 276         /** Used to track methods with placeholder support */
 277         exports.placeholder = {
 278           'bind': true,
 279           'bindKey': true,
 280           'curry': true,
 281           'curryRight': true,
 282           'partial': true,
 283           'partialRight': true
 284         };
 285
 286         /** Used to map real names to their aliases. */
 287         exports.realToAlias = (function() {
 288           var hasOwnProperty = Object.prototype.hasOwnProperty,
 289               object = exports.aliasToReal,
 290               result = {};
 291
 292           for (var key in object) {
 293             var value = object[key];
 294             if (hasOwnProperty.call(result, value)) {
 295               result[value].push(key);
 296             } else {
 297               result[value] = [key];
 298             }
 299           }
 300           return result;
 301         }());
 302
 303         /** Used to map method names to other names. */
 304         exports.remap = {
 305           'curryN': 'curry',
 306           'curryRightN': 'curryRight',
 307           'findFrom': 'find',
 308           'findIndexFrom': 'findIndex',
 309           'findLastFrom': 'findLast',
 310           'findLastIndexFrom': 'findLastIndex',
 311           'getOr': 'get',
 312           'includesFrom': 'includes',
 313           'indexOfFrom': 'indexOf',
 314           'invokeArgs': 'invoke',
 315           'invokeArgsMap': 'invokeMap',
 316           'lastIndexOfFrom': 'lastIndexOf',
 317           'padChars': 'pad',
 318           'padCharsEnd': 'padEnd',
 319           'padCharsStart': 'padStart',
 320           'restFrom': 'rest',
 321           'spreadFrom': 'spread',
 322           'trimChars': 'trim',
 323           'trimCharsEnd': 'trimEnd',
 324           'trimCharsStart': 'trimStart'
 325         };
 326
 327         /** Used to track methods that skip fixing their arity. */
 328         exports.skipFixed = {
 329           'castArray': true,
 330           'flow': true,
 331           'flowRight': true,
 332           'iteratee': true,
 333           'mixin': true,
 334           'runInContext': true
 335         };
 336
 337         /** Used to track methods that skip rearranging arguments. */
 338         exports.skipRearg = {
 339           'add': true,
 340           'assign': true,
 341           'assignIn': true,
 342           'bind': true,
 343           'bindKey': true,
 344           'concat': true,
 345           'difference': true,
 346           'divide': true,
 347           'eq': true,
 348           'gt': true,
 349           'gte': true,
 350           'isEqual': true,
 351           'lt': true,
 352           'lte': true,
 353           'matchesProperty': true,
 354           'merge': true,
 355           'multiply': true,
 356           'overArgs': true,
 357           'partial': true,
 358           'partialRight': true,
 359           'random': true,
 360           'range': true,
 361           'rangeRight': true,
 362           'subtract': true,
 363           'zip': true,
 364           'zipObject': true
 365         };
 366
 367
 368 /***/ }
 369 /******/ ])
 370 });
 371 ;