public/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', '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             'getOr', 'inRange', 'intersectionBy', 'intersectionWith', 'invokeArgs',
 144             'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth', 'mergeWith',
 145             'orderBy', 'padChars', 'padCharsEnd', 'padCharsStart', 'pullAllBy',
 146             'pullAllWith', 'reduce', 'reduceRight', 'replace', 'set', 'slice',
 147             'sortedIndexBy', 'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith',
 148             'update', 'xorBy', 'xorWith', 'zipWith'
 149           ],
 150           '4': [
 151             'fill', 'setWith', 'updateWith'
 152           ]
 153         };
 154
 155         /** Used to map ary to rearg configs. */
 156         exports.aryRearg = {
 157           '2': [1, 0],
 158           '3': [2, 0, 1],
 159           '4': [3, 2, 0, 1]
 160         };
 161
 162         /** Used to map method names to their iteratee ary. */
 163         exports.iterateeAry = {
 164           'dropRightWhile': 1,
 165           'dropWhile': 1,
 166           'every': 1,
 167           'filter': 1,
 168           'find': 1,
 169           'findIndex': 1,
 170           'findKey': 1,
 171           'findLast': 1,
 172           'findLastIndex': 1,
 173           'findLastKey': 1,
 174           'flatMap': 1,
 175           'flatMapDeep': 1,
 176           'flatMapDepth': 1,
 177           'forEach': 1,
 178           'forEachRight': 1,
 179           'forIn': 1,
 180           'forInRight': 1,
 181           'forOwn': 1,
 182           'forOwnRight': 1,
 183           'map': 1,
 184           'mapKeys': 1,
 185           'mapValues': 1,
 186           'partition': 1,
 187           'reduce': 2,
 188           'reduceRight': 2,
 189           'reject': 1,
 190           'remove': 1,
 191           'some': 1,
 192           'takeRightWhile': 1,
 193           'takeWhile': 1,
 194           'times': 1,
 195           'transform': 2
 196         };
 197
 198         /** Used to map method names to iteratee rearg configs. */
 199         exports.iterateeRearg = {
 200           'mapKeys': [1]
 201         };
 202
 203         /** Used to map method names to rearg configs. */
 204         exports.methodRearg = {
 205           'assignInWith': [1, 2, 0],
 206           'assignWith': [1, 2, 0],
 207           'getOr': [2, 1, 0],
 208           'isEqualWith': [1, 2, 0],
 209           'isMatchWith': [2, 1, 0],
 210           'mergeWith': [1, 2, 0],
 211           'padChars': [2, 1, 0],
 212           'padCharsEnd': [2, 1, 0],
 213           'padCharsStart': [2, 1, 0],
 214           'pullAllBy': [2, 1, 0],
 215           'pullAllWith': [2, 1, 0],
 216           'setWith': [3, 1, 2, 0],
 217           'sortedIndexBy': [2, 1, 0],
 218           'sortedLastIndexBy': [2, 1, 0],
 219           'updateWith': [3, 1, 2, 0],
 220           'zipWith': [1, 2, 0]
 221         };
 222
 223         /** Used to map method names to spread configs. */
 224         exports.methodSpread = {
 225           'invokeArgs': 2,
 226           'invokeArgsMap': 2,
 227           'partial': 1,
 228           'partialRight': 1,
 229           'without': 1
 230         };
 231
 232         /** Used to identify methods which mutate arrays or objects. */
 233         exports.mutate = {
 234           'array': {
 235             'fill': true,
 236             'pull': true,
 237             'pullAll': true,
 238             'pullAllBy': true,
 239             'pullAllWith': true,
 240             'pullAt': true,
 241             'remove': true,
 242             'reverse': true
 243           },
 244           'object': {
 245             'assign': true,
 246             'assignIn': true,
 247             'assignInWith': true,
 248             'assignWith': true,
 249             'defaults': true,
 250             'defaultsDeep': true,
 251             'merge': true,
 252             'mergeWith': true
 253           },
 254           'set': {
 255             'set': true,
 256             'setWith': true,
 257             'unset': true,
 258             'update': true,
 259             'updateWith': true
 260           }
 261         };
 262
 263         /** Used to track methods with placeholder support */
 264         exports.placeholder = {
 265           'bind': true,
 266           'bindKey': true,
 267           'curry': true,
 268           'curryRight': true,
 269           'partial': true,
 270           'partialRight': true
 271         };
 272
 273         /** Used to map real names to their aliases. */
 274         exports.realToAlias = (function() {
 275           var hasOwnProperty = Object.prototype.hasOwnProperty,
 276               object = exports.aliasToReal,
 277               result = {};
 278
 279           for (var key in object) {
 280             var value = object[key];
 281             if (hasOwnProperty.call(result, value)) {
 282               result[value].push(key);
 283             } else {
 284               result[value] = [key];
 285             }
 286           }
 287           return result;
 288         }());
 289
 290         /** Used to map method names to other names. */
 291         exports.remap = {
 292           'curryN': 'curry',
 293           'curryRightN': 'curryRight',
 294           'getOr': 'get',
 295           'invokeArgs': 'invoke',
 296           'invokeArgsMap': 'invokeMap',
 297           'padChars': 'pad',
 298           'padCharsEnd': 'padEnd',
 299           'padCharsStart': 'padStart',
 300           'restFrom': 'rest',
 301           'spreadFrom': 'spread',
 302           'trimChars': 'trim',
 303           'trimCharsEnd': 'trimEnd',
 304           'trimCharsStart': 'trimStart'
 305         };
 306
 307         /** Used to track methods that skip fixing their arity. */
 308         exports.skipFixed = {
 309           'castArray': true,
 310           'flow': true,
 311           'flowRight': true,
 312           'iteratee': true,
 313           'mixin': true,
 314           'runInContext': true
 315         };
 316
 317         /** Used to track methods that skip rearranging arguments. */
 318         exports.skipRearg = {
 319           'add': true,
 320           'assign': true,
 321           'assignIn': true,
 322           'bind': true,
 323           'bindKey': true,
 324           'concat': true,
 325           'difference': true,
 326           'divide': true,
 327           'eq': true,
 328           'gt': true,
 329           'gte': true,
 330           'isEqual': true,
 331           'lt': true,
 332           'lte': true,
 333           'matchesProperty': true,
 334           'merge': true,
 335           'multiply': true,
 336           'overArgs': true,
 337           'partial': true,
 338           'partialRight': true,
 339           'random': true,
 340           'range': true,
 341           'rangeRight': true,
 342           'subtract': true,
 343           'without': true,
 344           'zip': true,
 345           'zipObject': true
 346         };
 347
 348
 349 /***/ }
 350 /******/ ])
 351 });
 352 ;