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           '__': 'placeholder',
  60           'all': 'some',
  61           'allPass': 'overEvery',
  62           'apply': 'spread',
  63           'assoc': 'set',
  64           'assocPath': 'set',
  65           'compose': 'flowRight',
  66           'contains': 'includes',
  67           'dissoc': 'unset',
  68           'dissocPath': 'unset',
  69           'each': 'forEach',
  70           'eachRight': 'forEachRight',
  71           'equals': 'isEqual',
  72           'extend': 'assignIn',
  73           'extendWith': 'assignInWith',
  74           'first': 'head',
  75           'init': 'initial',
  76           'mapObj': 'mapValues',
  77           'omitAll': 'omit',
  78           'nAry': 'ary',
  79           'path': 'get',
  80           'pathEq': 'matchesProperty',
  81           'pathOr': 'getOr',
  82           'pickAll': 'pick',
  83           'pipe': 'flow',
  84           'prop': 'get',
  85           'propOf': 'propertyOf',
  86           'propOr': 'getOr',
  87           'somePass': 'overSome',
  88           'unapply': 'rest',
  89           'unnest': 'flatten',
  90           'useWith': 'overArgs',
  91           'whereEq': 'filter',
  92           'zipObj': 'zipObject'
  93         };
  94
  95         /** Used to map ary to method names. */
  96         exports.aryMethod = {
  97           '1': [
  98             'attempt', 'castArray', 'ceil', 'create', 'curry', 'curryRight', 'floor',
  99             'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'methodOf', 'mixin',
 100             'over', 'overEvery', 'overSome', 'rest', 'reverse', 'round', 'runInContext',
 101             'spread', 'template', 'trim', 'trimEnd', 'trimStart', 'uniqueId', 'words'
 102           ],
 103           '2': [
 104             'add', 'after', 'ary', 'assign', 'assignIn', 'at', 'before', 'bind', 'bindKey',
 105             'chunk', 'cloneDeepWith', 'cloneWith', 'concat', 'countBy', 'curryN',
 106             'curryRightN', 'debounce', 'defaults', 'defaultsDeep', 'delay', 'difference',
 107             'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq', 'every',
 108             'filter', 'find', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',
 109             'findLastKey', 'flatMap', 'flattenDepth', 'forEach', 'forEachRight', 'forIn',
 110             'forInRight', 'forOwn', 'forOwnRight', 'get', 'groupBy', 'gt', 'gte', 'has',
 111             'hasIn', 'includes', 'indexOf', 'intersection', 'invertBy', 'invoke', 'invokeMap',
 112             'isEqual', 'isMatch', 'join', 'keyBy', 'lastIndexOf', 'lt', 'lte', 'map',
 113             'mapKeys', 'mapValues', 'matchesProperty', 'maxBy', 'merge', 'minBy', 'omit',
 114             'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt',
 115             'partial', 'partialRight', 'partition', 'pick', 'pickBy', 'pull', 'pullAll',
 116             'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
 117             'repeat', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
 118             'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
 119             'split', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight', 'takeRightWhile',
 120             'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars', 'trimCharsEnd',
 121             'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith', 'unset',
 122             'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject', 'zipObjectDeep'
 123           ],
 124           '3': [
 125             'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
 126             'getOr', 'inRange', 'intersectionBy', 'intersectionWith', 'isEqualWith',
 127             'isMatchWith', 'mergeWith', 'orderBy', 'pullAllBy', 'reduce', 'reduceRight',
 128             'replace', 'set', 'slice', 'sortedIndexBy', 'sortedLastIndexBy', 'transform',
 129             'unionBy', 'unionWith', 'xorBy', 'xorWith', 'zipWith'
 130           ],
 131           '4': [
 132             'fill', 'setWith'
 133           ]
 134         };
 135
 136         /** Used to map ary to rearg configs. */
 137         exports.aryRearg = {
 138           '2': [1, 0],
 139           '3': [2, 0, 1],
 140           '4': [3, 2, 0, 1]
 141         };
 142
 143         /** Used to map method names to their iteratee ary. */
 144         exports.iterateeAry = {
 145           'assignWith': 2,
 146           'assignInWith': 2,
 147           'cloneDeepWith': 1,
 148           'cloneWith': 1,
 149           'dropRightWhile': 1,
 150           'dropWhile': 1,
 151           'every': 1,
 152           'filter': 1,
 153           'find': 1,
 154           'findIndex': 1,
 155           'findKey': 1,
 156           'findLast': 1,
 157           'findLastIndex': 1,
 158           'findLastKey': 1,
 159           'flatMap': 1,
 160           'forEach': 1,
 161           'forEachRight': 1,
 162           'forIn': 1,
 163           'forInRight': 1,
 164           'forOwn': 1,
 165           'forOwnRight': 1,
 166           'isEqualWith': 2,
 167           'isMatchWith': 2,
 168           'map': 1,
 169           'mapKeys': 1,
 170           'mapValues': 1,
 171           'partition': 1,
 172           'reduce': 2,
 173           'reduceRight': 2,
 174           'reject': 1,
 175           'remove': 1,
 176           'some': 1,
 177           'takeRightWhile': 1,
 178           'takeWhile': 1,
 179           'times': 1,
 180           'transform': 2
 181         };
 182
 183         /** Used to map method names to iteratee rearg configs. */
 184         exports.iterateeRearg = {
 185           'mapKeys': [1]
 186         };
 187
 188         /** Used to map method names to rearg configs. */
 189         exports.methodRearg = {
 190           'assignInWith': [1, 2, 0],
 191           'assignWith': [1, 2, 0],
 192           'getOr': [2, 1, 0],
 193           'isMatchWith': [2, 1, 0],
 194           'mergeWith': [1, 2, 0],
 195           'pullAllBy': [2, 1, 0],
 196           'setWith': [3, 1, 2, 0],
 197           'sortedIndexBy': [2, 1, 0],
 198           'sortedLastIndexBy': [2, 1, 0],
 199           'zipWith': [1, 2, 0]
 200         };
 201
 202         /** Used to map method names to spread configs. */
 203         exports.methodSpread = {
 204           'partial': 1,
 205           'partialRight': 1
 206         };
 207
 208         /** Used to identify methods which mutate arrays or objects. */
 209         exports.mutate = {
 210           'array': {
 211             'fill': true,
 212             'pull': true,
 213             'pullAll': true,
 214             'pullAllBy': true,
 215             'pullAt': true,
 216             'remove': true,
 217             'reverse': true
 218           },
 219           'object': {
 220             'assign': true,
 221             'assignIn': true,
 222             'assignInWith': true,
 223             'assignWith': true,
 224             'defaults': true,
 225             'defaultsDeep': true,
 226             'merge': true,
 227             'mergeWith': true
 228           },
 229           'set': {
 230             'set': true,
 231             'setWith': true,
 232             'unset': true
 233           }
 234         };
 235
 236         /** Used to track methods with placeholder support */
 237         exports.placeholder = {
 238           'bind': true,
 239           'bindKey': true,
 240           'curry': true,
 241           'curryRight': true,
 242           'partial': true,
 243           'partialRight': true
 244         };
 245
 246         /** Used to map real names to their aliases. */
 247         exports.realToAlias = (function() {
 248           var hasOwnProperty = Object.prototype.hasOwnProperty,
 249               object = exports.aliasToReal,
 250               result = {};
 251
 252           for (var key in object) {
 253             var value = object[key];
 254             if (hasOwnProperty.call(result, value)) {
 255               result[value].push(key);
 256             } else {
 257               result[value] = [key];
 258             }
 259           }
 260           return result;
 261         }());
 262
 263         /** Used to map method names to other names. */
 264         exports.remap = {
 265           'curryN': 'curry',
 266           'curryRightN': 'curryRight',
 267           'getOr': 'get',
 268           'trimChars': 'trim',
 269           'trimCharsEnd': 'trimEnd',
 270           'trimCharsStart': 'trimStart'
 271         };
 272
 273         /** Used to track methods that skip `_.rearg`. */
 274         exports.skipRearg = {
 275           'add': true,
 276           'assign': true,
 277           'assignIn': true,
 278           'concat': true,
 279           'difference': true,
 280           'gt': true,
 281           'gte': true,
 282           'lt': true,
 283           'lte': true,
 284           'matchesProperty': true,
 285           'merge': true,
 286           'partial': true,
 287           'partialRight': true,
 288           'random': true,
 289           'range': true,
 290           'rangeRight': true,
 291           'subtract': true,
 292           'zip': true,
 293           'zipObject': true
 294         };
 295
 296
 297 /***/ }
 298 /******/ ])
 299 });
 300 ;