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