"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "dist/lodash.fp.js" between
lodash-4.0.0.tar.gz and lodash-4.17.21.tar.gz

About: lodash is a modern JavaScript utility library delivering modularity, performance, & extras. Tagged version.

lodash.fp.js  (lodash-4.0.0):lodash.fp.js  (lodash-4.17.21)
skipping to change at line 54 skipping to change at line 54
/******/ // __webpack_public_path__ /******/ // __webpack_public_path__
/******/ __webpack_require__.p = ""; /******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports /******/ // Load entry module and return exports
/******/ return __webpack_require__(0); /******/ return __webpack_require__(0);
/******/ }) /******/ })
/************************************************************************/ /************************************************************************/
/******/ ([ /******/ ([
/* 0 */ /* 0 */
/***/ function(module, exports, __webpack_require__) { /***/ (function(module, exports, __webpack_require__) {
var baseConvert = __webpack_require__(1); var baseConvert = __webpack_require__(1);
/** /**
* Converts `lodash` to an auto-curried iteratee-first data-last version. * Converts `lodash` to an immutable auto-curried iteratee-first data-las
t
* version with conversion `options` applied.
* *
* @param {Function} lodash The lodash function. * @param {Function} lodash The lodash function to convert.
* @returns {Function} Returns the converted lodash function. * @param {Object} [options] The options object. See `baseConvert` for mo
re details.
* @returns {Function} Returns the converted `lodash`.
*/ */
function browserConvert(lodash) { function browserConvert(lodash, options) {
return baseConvert(lodash, lodash); return baseConvert(lodash, lodash, options);
} }
if (typeof _ == 'function' && typeof _.runInContext == 'function') {
_ = browserConvert(_.runInContext());
}
module.exports = browserConvert; module.exports = browserConvert;
/***/ }, /***/ }),
/* 1 */ /* 1 */
/***/ function(module, exports, __webpack_require__) { /***/ (function(module, exports, __webpack_require__) {
var mapping = __webpack_require__(2), var mapping = __webpack_require__(2),
mutateMap = mapping.mutateMap; fallbackHolder = __webpack_require__(3);
/** Built-in value reference. */
var push = Array.prototype.push;
/** /**
* The base implementation of `convert` which accepts a `util` object of * Creates a function, with an arity of `n`, that invokes `func` with the
methods * arguments it receives.
* required to perform conversions.
* *
* @param {Object} util The util object. * @private
* @param {string} name The name of the function to wrap.
* @param {Function} func The function to wrap. * @param {Function} func The function to wrap.
* @returns {Function|Object} Returns the converted function or object. * @param {number} n The arity of the new function.
* @returns {Function} Returns the new function.
*/ */
function baseConvert(util, name, func) { function baseArity(func, n) {
if (typeof func != 'function') { return n == 2
func = name; ? function(a, b) { return func.apply(undefined, arguments); }
name = undefined; : function(a) { return func.apply(undefined, arguments); };
} }
if (func == null) {
throw new TypeError; /**
* Creates a function that invokes `func`, with up to `n` arguments, igno
ring
* any additional arguments.
*
* @private
* @param {Function} func The function to cap arguments for.
* @param {number} n The arity cap.
* @returns {Function} Returns the new function.
*/
function baseAry(func, n) {
return n == 2
? function(a, b) { return func(a, b); }
: function(a) { return func(a); };
}
/**
* Creates a clone of `array`.
*
* @private
* @param {Array} array The array to clone.
* @returns {Array} Returns the cloned array.
*/
function cloneArray(array) {
var length = array ? array.length : 0,
result = Array(length);
while (length--) {
result[length] = array[length];
} }
var isLib = name === undefined && typeof func.VERSION == 'string'; return result;
}
var _ = isLib ? func : { /**
'ary': util.ary, * Creates a function that clones a given object using the assignment `fu
'cloneDeep': util.cloneDeep, nc`.
'curry': util.curry, *
'forEach': util.forEach, * @private
'isFunction': util.isFunction, * @param {Function} func The assignment function.
'iteratee': util.iteratee, * @returns {Function} Returns the new cloner function.
'keys': util.keys, */
'rearg': util.rearg function createCloner(func) {
return function(object) {
return func({}, object);
}; };
}
var ary = _.ary, /**
cloneDeep = _.cloneDeep, * A specialized version of `_.spread` which flattens the spread array in
curry = _.curry, to
each = _.forEach, * the arguments of the invoked `func`.
isFunction = _.isFunction, *
keys = _.keys, * @private
rearg = _.rearg; * @param {Function} func The function to spread arguments over.
* @param {number} start The start position of the spread.
* @returns {Function} Returns the new function.
*/
function flatSpread(func, start) {
return function() {
var length = arguments.length,
lastIndex = length - 1,
args = Array(length);
var baseAry = function(func, n) { while (length--) {
return function() { args[length] = arguments[length];
var args = arguments, }
length = Math.min(args.length, n); var array = args[start],
otherArgs = args.slice(0, start);
switch (length) { if (array) {
case 1: return func(args[0]); push.apply(otherArgs, array);
case 2: return func(args[0], args[1]); }
} if (start != lastIndex) {
args = Array(length); push.apply(otherArgs, args.slice(start + 1));
while (length--) { }
args[length] = arguments[length]; return func.apply(this, otherArgs);
}
return func.apply(undefined, args);
};
}; };
}
var cloneArray = function(array) { /**
var length = array ? array.length : 0, * Creates a function that wraps `func` and uses `cloner` to clone the fi
result = Array(length); rst
* argument it receives.
*
* @private
* @param {Function} func The function to wrap.
* @param {Function} cloner The function to clone arguments.
* @returns {Function} Returns the new immutable function.
*/
function wrapImmutable(func, cloner) {
return function() {
var length = arguments.length;
if (!length) {
return;
}
var args = Array(length);
while (length--) { while (length--) {
result[length] = array[length]; args[length] = arguments[length];
} }
var result = args[0] = cloner.apply(undefined, args);
func.apply(undefined, args);
return result; return result;
}; };
}
var createCloner = function(func) { /**
return function(object) { * The base implementation of `convert` which accepts a `util` object of
return func({}, object); methods
}; * required to perform conversions.
}; *
* @param {Object} util The util object.
* @param {string} name The name of the function to convert.
* @param {Function} func The function to convert.
* @param {Object} [options] The options object.
* @param {boolean} [options.cap=true] Specify capping iteratee arguments
.
* @param {boolean} [options.curry=true] Specify currying.
* @param {boolean} [options.fixed=true] Specify fixed arity.
* @param {boolean} [options.immutable=true] Specify immutable operations
.
* @param {boolean} [options.rearg=true] Specify rearranging arguments.
* @returns {Function|Object} Returns the converted function or object.
*/
function baseConvert(util, name, func, options) {
var isLib = typeof name == 'function',
isObj = name === Object(name);
var immutWrap = function(func, cloner) { if (isObj) {
return overArg(func, cloner, true); options = func;
}; func = name;
name = undefined;
}
if (func == null) {
throw new TypeError;
}
options || (options = {});
var iterateeAry = function(func, n) { var config = {
return overArg(func, function(func) { 'cap': 'cap' in options ? options.cap : true,
return baseAry(func, n); 'curry': 'curry' in options ? options.curry : true,
}); 'fixed': 'fixed' in options ? options.fixed : true,
'immutable': 'immutable' in options ? options.immutable : true,
'rearg': 'rearg' in options ? options.rearg : true
}; };
var overArg = function(func, iteratee, retArg) { var defaultHolder = isLib ? func : fallbackHolder,
return function() { forceCurry = ('curry' in options) && options.curry,
var length = arguments.length, forceFixed = ('fixed' in options) && options.fixed,
args = Array(length); forceRearg = ('rearg' in options) && options.rearg,
pristine = isLib ? func.runInContext() : undefined;
while (length--) { var helpers = isLib ? func : {
args[length] = arguments[length]; 'ary': util.ary,
} 'assign': util.assign,
args[0] = iteratee(args[0]); 'clone': util.clone,
var result = func.apply(undefined, args); 'curry': util.curry,
return retArg ? args[0] : result; 'forEach': util.forEach,
}; 'isArray': util.isArray,
'isError': util.isError,
'isFunction': util.isFunction,
'isWeakMap': util.isWeakMap,
'iteratee': util.iteratee,
'keys': util.keys,
'rearg': util.rearg,
'toInteger': util.toInteger,
'toPath': util.toPath
}; };
var ary = helpers.ary,
assign = helpers.assign,
clone = helpers.clone,
curry = helpers.curry,
each = helpers.forEach,
isArray = helpers.isArray,
isError = helpers.isError,
isFunction = helpers.isFunction,
isWeakMap = helpers.isWeakMap,
keys = helpers.keys,
rearg = helpers.rearg,
toInteger = helpers.toInteger,
toPath = helpers.toPath;
var aryMethodKeys = keys(mapping.aryMethod);
var wrappers = { var wrappers = {
'castArray': function(castArray) {
return function() {
var value = arguments[0];
return isArray(value)
? castArray(cloneArray(value))
: castArray.apply(undefined, arguments);
};
},
'iteratee': function(iteratee) { 'iteratee': function(iteratee) {
return function(func, arity) { return function() {
arity = arity > 2 ? (arity - 2) : 1; var func = arguments[0],
func = iteratee(func); arity = arguments[1],
var length = func.length; result = iteratee(func, arity),
return (length && length <= arity) ? func : baseAry(func, arity); length = result.length;
if (config.cap && typeof arity == 'number') {
arity = arity > 2 ? (arity - 2) : 1;
return (length && length <= arity) ? result : baseAry(result, a
rity);
}
return result;
}; };
}, },
'mixin': function(mixin) { 'mixin': function(mixin) {
return function(source) { return function(source) {
var func = this; var func = this;
if (!isFunction(func)) { if (!isFunction(func)) {
return mixin(func, Object(source)); return mixin(func, Object(source));
} }
var methods = [], var pairs = [];
methodNames = [];
each(keys(source), function(key) { each(keys(source), function(key) {
var value = source[key]; if (isFunction(source[key])) {
if (isFunction(value)) { pairs.push([key, func.prototype[key]]);
methodNames.push(key);
methods.push(func.prototype[key]);
} }
}); });
mixin(func, Object(source)); mixin(func, Object(source));
each(methodNames, function(methodName, index) { each(pairs, function(pair) {
var method = methods[index]; var value = pair[1];
if (isFunction(method)) { if (isFunction(value)) {
func.prototype[methodName] = method; func.prototype[pair[0]] = value;
} else { } else {
delete func.prototype[methodName]; delete func.prototype[pair[0]];
} }
}); });
return func; return func;
}; };
}, },
'nthArg': function(nthArg) {
return function(n) {
var arity = n < 0 ? 1 : (toInteger(n) + 1);
return curry(nthArg(n), arity);
};
},
'rearg': function(rearg) {
return function(func, indexes) {
var arity = indexes ? indexes.length : 0;
return curry(rearg(func, indexes), arity);
};
},
'runInContext': function(runInContext) { 'runInContext': function(runInContext) {
return function(context) { return function(context) {
return baseConvert(util, runInContext(context)); return baseConvert(util, runInContext(context), options);
}; };
} }
}; };
var wrap = function(name, func) { /*---------------------------------------------------------------------
var wrapper = wrappers[name]; -----*/
if (wrapper) {
return wrapper(func); /**
* Casts `func` to a function with an arity capped iteratee if needed.
*
* @private
* @param {string} name The name of the function to inspect.
* @param {Function} func The function to inspect.
* @returns {Function} Returns the cast function.
*/
function castCap(name, func) {
if (config.cap) {
var indexes = mapping.iterateeRearg[name];
if (indexes) {
return iterateeRearg(func, indexes);
}
var n = !isLib && mapping.iterateeAry[name];
if (n) {
return iterateeAry(func, n);
}
} }
if (mutateMap.array[name]) { return func;
func = immutWrap(func, cloneArray); }
/**
* Casts `func` to a curried function if needed.
*
* @private
* @param {string} name The name of the function to inspect.
* @param {Function} func The function to inspect.
* @param {number} n The arity of `func`.
* @returns {Function} Returns the cast function.
*/
function castCurry(name, func, n) {
return (forceCurry || (config.curry && n > 1))
? curry(func, n)
: func;
}
/**
* Casts `func` to a fixed arity function if needed.
*
* @private
* @param {string} name The name of the function to inspect.
* @param {Function} func The function to inspect.
* @param {number} n The arity cap.
* @returns {Function} Returns the cast function.
*/
function castFixed(name, func, n) {
if (config.fixed && (forceFixed || !mapping.skipFixed[name])) {
var data = mapping.methodSpread[name],
start = data && data.start;
return start === undefined ? ary(func, n) : flatSpread(func, start
);
} }
else if (mutateMap.object[name]) { return func;
func = immutWrap(func, createCloner(func)); }
/**
* Casts `func` to an rearged function if needed.
*
* @private
* @param {string} name The name of the function to inspect.
* @param {Function} func The function to inspect.
* @param {number} n The arity of `func`.
* @returns {Function} Returns the cast function.
*/
function castRearg(name, func, n) {
return (config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[na
me]))
? rearg(func, mapping.methodRearg[name] || mapping.aryRearg[n])
: func;
}
/**
* Creates a clone of `object` by `path`.
*
* @private
* @param {Object} object The object to clone.
* @param {Array|string} path The path to clone by.
* @returns {Object} Returns the cloned object.
*/
function cloneByPath(object, path) {
path = toPath(path);
var index = -1,
length = path.length,
lastIndex = length - 1,
result = clone(Object(object)),
nested = result;
while (nested != null && ++index < length) {
var key = path[index],
value = nested[key];
if (value != null &&
!(isFunction(value) || isError(value) || isWeakMap(value))) {
nested[key] = clone(index == lastIndex ? value : Object(value));
}
nested = nested[key];
} }
else if (mutateMap.set[name]) { return result;
func = immutWrap(func, cloneDeep); }
}
var result; /**
each(mapping.caps, function(cap) { * Converts `lodash` to an immutable auto-curried iteratee-first data-l
each(mapping.aryMethodMap[cap], function(otherName) { ast
if (name == otherName) { * version with conversion `options` applied.
result = ary(func, cap); *
if (cap > 1 && !mapping.skipReargMap[name]) { * @param {Object} [options] The options object. See `baseConvert` for
result = rearg(result, mapping.methodReargMap[name] || mappin more details.
g.aryReargMap[cap]); * @returns {Function} Returns the converted `lodash`.
} */
var n = !isLib && mapping.aryIterateeMap[name]; function convertLib(options) {
if (n) { return _.runInContext.convert(options)(undefined);
result = iterateeAry(result, n); }
}
if (cap > 1) { /**
result = curry(result, cap); * Create a converter function for `func` of `name`.
} *
* @param {string} name The name of the function to convert.
* @param {Function} func The function to convert.
* @returns {Function} Returns the new converter function.
*/
function createConverter(name, func) {
var realName = mapping.aliasToReal[name] || name,
methodName = mapping.remap[realName] || realName,
oldOptions = options;
return function(options) {
var newUtil = isLib ? pristine : helpers,
newFunc = isLib ? pristine[methodName] : func,
newOptions = assign(assign({}, oldOptions), options);
return baseConvert(newUtil, realName, newFunc, newOptions);
};
}
/**
* Creates a function that wraps `func` to invoke its iteratee, with up
to `n`
* arguments, ignoring any additional arguments.
*
* @private
* @param {Function} func The function to cap iteratee arguments for.
* @param {number} n The arity cap.
* @returns {Function} Returns the new function.
*/
function iterateeAry(func, n) {
return overArg(func, function(func) {
return typeof func == 'function' ? baseAry(func, n) : func;
});
}
/**
* Creates a function that wraps `func` to invoke its iteratee with arg
uments
* arranged according to the specified `indexes` where the argument val
ue at
* the first index is provided as the first argument, the argument valu
e at
* the second index is provided as the second argument, and so on.
*
* @private
* @param {Function} func The function to rearrange iteratee arguments
for.
* @param {number[]} indexes The arranged argument indexes.
* @returns {Function} Returns the new function.
*/
function iterateeRearg(func, indexes) {
return overArg(func, function(func) {
var n = indexes.length;
return baseArity(rearg(baseAry(func, n), indexes), n);
});
}
/**
* Creates a function that invokes `func` with its first argument trans
formed.
*
* @private
* @param {Function} func The function to wrap.
* @param {Function} transform The argument transform.
* @returns {Function} Returns the new function.
*/
function overArg(func, transform) {
return function() {
var length = arguments.length;
if (!length) {
return func();
}
var args = Array(length);
while (length--) {
args[length] = arguments[length];
}
var index = config.rearg ? 0 : (length - 1);
args[index] = transform(args[index]);
return func.apply(undefined, args);
};
}
/**
* Creates a function that wraps `func` and applys the conversions
* rules by `name`.
*
* @private
* @param {string} name The name of the function to wrap.
* @param {Function} func The function to wrap.
* @returns {Function} Returns the converted function.
*/
function wrap(name, func, placeholder) {
var result,
realName = mapping.aliasToReal[name] || name,
wrapped = func,
wrapper = wrappers[realName];
if (wrapper) {
wrapped = wrapper(func);
}
else if (config.immutable) {
if (mapping.mutate.array[realName]) {
wrapped = wrapImmutable(func, cloneArray);
}
else if (mapping.mutate.object[realName]) {
wrapped = wrapImmutable(func, createCloner(func));
}
else if (mapping.mutate.set[realName]) {
wrapped = wrapImmutable(func, cloneByPath);
}
}
each(aryMethodKeys, function(aryKey) {
each(mapping.aryMethod[aryKey], function(otherName) {
if (realName == otherName) {
var data = mapping.methodSpread[realName],
afterRearg = data && data.afterRearg;
result = afterRearg
? castFixed(realName, castRearg(realName, wrapped, aryKey), a
ryKey)
: castRearg(realName, castFixed(realName, wrapped, aryKey), a
ryKey);
result = castCap(realName, result);
result = castCurry(realName, result, aryKey);
return false; return false;
} }
}); });
return !result; return !result;
}); });
return result || func;
};
if (!isLib) { result || (result = wrapped);
return wrap(name, func); if (result == func) {
result = forceCurry ? curry(result, 1) : function() {
return func.apply(this, arguments);
};
}
result.convert = createConverter(realName, func);
result.placeholder = func.placeholder = placeholder;
return result;
}
/*---------------------------------------------------------------------
-----*/
if (!isObj) {
return wrap(name, func, defaultHolder);
} }
// Iterate over methods for the current ary cap. var _ = func;
// Convert methods by ary cap.
var pairs = []; var pairs = [];
each(mapping.caps, function(cap) { each(aryMethodKeys, function(aryKey) {
each(mapping.aryMethodMap[cap], function(key) { each(mapping.aryMethod[aryKey], function(key) {
var func = _[mapping.keyMap[key] || key]; var func = _[mapping.remap[key] || key];
if (func) { if (func) {
pairs.push([key, wrap(key, func)]); pairs.push([key, wrap(key, func, _)]);
} }
}); });
}); });
// Convert remaining methods.
each(keys(_), function(key) {
var func = _[key];
if (typeof func == 'function') {
var length = pairs.length;
while (length--) {
if (pairs[length][0] == key) {
return;
}
}
func.convert = createConverter(key, func);
pairs.push([key, func]);
}
});
// Assign to `_` leaving `_.prototype` unchanged to allow chaining. // Assign to `_` leaving `_.prototype` unchanged to allow chaining.
each(pairs, function(pair) { each(pairs, function(pair) {
_[pair[0]] = pair[1]; _[pair[0]] = pair[1];
}); });
// Wrap the lodash method and its aliases. _.convert = convertLib;
_.placeholder = _;
// Assign aliases.
each(keys(_), function(key) { each(keys(_), function(key) {
each(mapping.aliasMap[key] || [], function(alias) { each(mapping.realToAlias[key] || [], function(alias) {
_[alias] = _[key]; _[alias] = _[key];
}); });
}); });
return _; return _;
} }
module.exports = baseConvert; module.exports = baseConvert;
/***/ }, /***/ }),
/* 2 */ /* 2 */
/***/ function(module, exports) { /***/ (function(module, exports) {
module.exports = { /** Used to map aliases to their real names. */
exports.aliasToReal = {
/** Used to map method names to their aliases. */ // Lodash aliases.
'aliasMap': { 'each': 'forEach',
'ary': ['nAry'], 'eachRight': 'forEachRight',
'overEvery': ['allPass'], 'entries': 'toPairs',
'overSome': ['somePass'], 'entriesIn': 'toPairsIn',
'filter': ['whereEq'], 'extend': 'assignIn',
'flatten': ['unnest'], 'extendAll': 'assignInAll',
'flow': ['pipe'], 'extendAllWith': 'assignInAllWith',
'flowRight': ['compose'], 'extendWith': 'assignInWith',
'forEach': ['each'], 'first': 'head',
'forEachRight': ['eachRight'],
'get': ['path'], // Methods that are curried variants of others.
'getOr': ['pathOr'], 'conforms': 'conformsTo',
'head': ['first'], 'matches': 'isMatch',
'includes': ['contains'], 'property': 'get',
'initial': ['init'],
'isEqual': ['equals'], // Ramda aliases.
'mapValues': ['mapObj'], '__': 'placeholder',
'matchesProperty': ['pathEq'], 'F': 'stubFalse',
'overArgs': ['useWith'], 'T': 'stubTrue',
'omit': ['dissoc', 'omitAll'], 'all': 'every',
'pick': ['pickAll'], 'allPass': 'overEvery',
'property': ['prop'], 'always': 'constant',
'propertyOf': ['propOf'], 'any': 'some',
'rest': ['unapply'], 'anyPass': 'overSome',
'some': ['all'], 'apply': 'spread',
'spread': ['apply'], 'assoc': 'set',
'zipObject': ['zipObj'] 'assocPath': 'set',
}, 'complement': 'negate',
'compose': 'flowRight',
'contains': 'includes',
'dissoc': 'unset',
'dissocPath': 'unset',
'dropLast': 'dropRight',
'dropLastWhile': 'dropRightWhile',
'equals': 'isEqual',
'identical': 'eq',
'indexBy': 'keyBy',
'init': 'initial',
'invertObj': 'invert',
'juxt': 'over',
'omitAll': 'omit',
'nAry': 'ary',
'path': 'get',
'pathEq': 'matchesProperty',
'pathOr': 'getOr',
'paths': 'at',
'pickAll': 'pick',
'pipe': 'flow',
'pluck': 'map',
'prop': 'get',
'propEq': 'matchesProperty',
'propOr': 'getOr',
'props': 'at',
'symmetricDifference': 'xor',
'symmetricDifferenceBy': 'xorBy',
'symmetricDifferenceWith': 'xorWith',
'takeLast': 'takeRight',
'takeLastWhile': 'takeRightWhile',
'unapply': 'rest',
'unnest': 'flatten',
'useWith': 'overArgs',
'where': 'conformsTo',
'whereEq': 'isMatch',
'zipObj': 'zipObject'
};
/** Used to map method names to their iteratee ary. */ /** Used to map ary to method names. */
'aryIterateeMap': { exports.aryMethod = {
'assignWith': 2, '1': [
'cloneDeepWith': 1, 'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create',
'cloneWith': 1, 'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'fl
'dropRightWhile': 1, ow',
'dropWhile': 1, 'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method',
'every': 1, 'mergeAll',
'extendWith': 2, 'methodOf', 'mixin', 'nthArg', 'over', 'overEvery', 'overSome','rest'
'filter': 1, , 'reverse',
'find': 1, 'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'tr
'findIndex': 1, imStart',
'findKey': 1, 'uniqueId', 'words', 'zipAll'
'findLast': 1, ],
'findLastIndex': 1, '2': [
'findLastKey': 1, 'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assign
'flatMap': 1, InAllWith',
'forEach': 1, 'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith
'forEachRight': 1, ',
'forIn': 1, 'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRight
'forInRight': 1, N',
'forOwn': 1, 'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'differ
'forOwnRight': 1, ence',
'isEqualWith': 2, 'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWi
'isMatchWith': 2, th', 'eq',
'map': 1, 'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findL
'mapKeys': 1, astIndex',
'mapValues': 1, 'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach',
'partition': 1, 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get'
'reduce': 2, ,
'reduceRight': 2, 'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'inter
'reject': 1, section',
'remove': 1, 'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'key
'some': 1, By',
'takeRightWhile': 1, 'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesPr
'takeWhile': 1, operty',
'times': 1, 'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth
'transform': 2 ', 'omit',
}, 'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'parti
al',
'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull',
'pullAll',
'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove
',
'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sort
edIndex',
'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqB
y',
'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'ta
keRight',
'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 't
rimChars',
'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uni
qWith',
'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
'zipObjectDeep'
],
'3': [
'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWit
h',
'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'ge
tOr',
'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersec
tionWith',
'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMap
Depth',
'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',
'padCharsStart', 'pullAllBy', 'pullAllWith', 'rangeStep', 'rangeStepR
ight',
'reduce', 'reduceRight', 'replace', 'set', 'slice', 'sortedIndexBy',
'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith', 'update', '
xorBy',
'xorWith', 'zipWith'
],
'4': [
'fill', 'setWith', 'updateWith'
]
};
/** Used to map ary to method names. */ /** Used to map ary to rearg configs. */
'aryMethodMap': { exports.aryRearg = {
1: ( '2': [1, 0],
'attempt,ceil,create,curry,curryRight,floor,fromPairs,iteratee,inve '3': [2, 0, 1],
rt,over,' + '4': [3, 2, 0, 1]
'overEvery,overSome,memoize,method,methodOf,mixin,rest,reverse,roun };
d,' +
'runInContext,template,trim,trimLeft,trimRight,uniqueId,words').spl
it(','),
2: (
'add,ary,assign,at,bind,bindKey,cloneDeepWith,cloneWith,concat,coun
tBy,curryN,' +
'curryRightN,debounce,defaults,defaultsDeep,delay,difference,drop,d
ropRight,' +
'dropRightWhile,dropWhile,endsWith,eq,every,extend,filter,find,find
,findIndex,' +
'findKey,findLast,findLastIndex,findLastKey,flatMap,forEach,forEach
Right,' +
'forIn,forInRight,forOwn,forOwnRight,get,groupBy,includes,indexBy,i
ndexOf,' +
'intersection,invoke,invokeMap,isMatch,lastIndexOf,map,mapKeys,mapV
alues,' +
'matchesProperty,maxBy,mean,minBy,merge,omit,orderBy,overArgs,pad,p
adLeft,' +
'padRight,parseInt,partition,pick,pull,pullAll,pullAt,random,range,
rangeRight,' +
'rearg,reject,remove,repeat,result,sampleSize,some,sortBy,sortedInd
exBy,' +
'sortedLastIndexBy,sortedUniqBy,startsWith,subtract,sumBy,take,take
Right,' +
'takeRightWhile,takeWhile,throttle,times,truncate,union,uniqBy,with
out,wrap,' +
'xor,zip,zipObject').split(','),
3: (
'assignWith,clamp,differenceBy,extendWith,getOr,inRange,intersectio
nBy,' +
'isEqualWith,isMatchWith,mergeWith,omitBy,pickBy,pullAllBy,reduce,'
+
'reduceRight,set,slice,transform,unionBy,xorBy,zipWith').split(',')
,
4:
['fill', 'setWith']
},
/** Used to map ary to rearg configs by method ary. */ /** Used to map method names to their iteratee ary. */
'aryReargMap': { exports.iterateeAry = {
2: [1, 0], 'dropRightWhile': 1,
3: [2, 1, 0], 'dropWhile': 1,
4: [3, 2, 0, 1] 'every': 1,
}, 'filter': 1,
'find': 1,
'findFrom': 1,
'findIndex': 1,
'findIndexFrom': 1,
'findKey': 1,
'findLast': 1,
'findLastFrom': 1,
'findLastIndex': 1,
'findLastIndexFrom': 1,
'findLastKey': 1,
'flatMap': 1,
'flatMapDeep': 1,
'flatMapDepth': 1,
'forEach': 1,
'forEachRight': 1,
'forIn': 1,
'forInRight': 1,
'forOwn': 1,
'forOwnRight': 1,
'map': 1,
'mapKeys': 1,
'mapValues': 1,
'partition': 1,
'reduce': 2,
'reduceRight': 2,
'reject': 1,
'remove': 1,
'some': 1,
'takeRightWhile': 1,
'takeWhile': 1,
'times': 1,
'transform': 2
};
/** Used to map ary to rearg configs by method names. */ /** Used to map method names to iteratee rearg configs. */
'methodReargMap': { exports.iterateeRearg = {
'clamp': [2, 0, 1], 'mapKeys': [1],
'reduce': [2, 0, 1], 'reduceRight': [1, 0]
'reduceRight': [2, 0, 1], };
'setWith': [3, 2, 1, 0],
'slice': [2, 0, 1],
'transform': [2, 0, 1]
},
/** Used to iterate `mapping.aryMethodMap` keys. */ /** Used to map method names to rearg configs. */
'caps': [1, 2, 3, 4], exports.methodRearg = {
'assignInAllWith': [1, 0],
'assignInWith': [1, 2, 0],
'assignAllWith': [1, 0],
'assignWith': [1, 2, 0],
'differenceBy': [1, 2, 0],
'differenceWith': [1, 2, 0],
'getOr': [2, 1, 0],
'intersectionBy': [1, 2, 0],
'intersectionWith': [1, 2, 0],
'isEqualWith': [1, 2, 0],
'isMatchWith': [2, 1, 0],
'mergeAllWith': [1, 0],
'mergeWith': [1, 2, 0],
'padChars': [2, 1, 0],
'padCharsEnd': [2, 1, 0],
'padCharsStart': [2, 1, 0],
'pullAllBy': [2, 1, 0],
'pullAllWith': [2, 1, 0],
'rangeStep': [1, 2, 0],
'rangeStepRight': [1, 2, 0],
'setWith': [3, 1, 2, 0],
'sortedIndexBy': [2, 1, 0],
'sortedLastIndexBy': [2, 1, 0],
'unionBy': [1, 2, 0],
'unionWith': [1, 2, 0],
'updateWith': [3, 1, 2, 0],
'xorBy': [1, 2, 0],
'xorWith': [1, 2, 0],
'zipWith': [1, 2, 0]
};
/** Used to map keys to other keys. */ /** Used to map method names to spread configs. */
'keyMap': { exports.methodSpread = {
'curryN': 'curry', 'assignAll': { 'start': 0 },
'curryRightN': 'curryRight', 'assignAllWith': { 'start': 0 },
'getOr': 'get' 'assignInAll': { 'start': 0 },
}, 'assignInAllWith': { 'start': 0 },
'defaultsAll': { 'start': 0 },
'defaultsDeepAll': { 'start': 0 },
'invokeArgs': { 'start': 2 },
'invokeArgsMap': { 'start': 2 },
'mergeAll': { 'start': 0 },
'mergeAllWith': { 'start': 0 },
'partial': { 'start': 1 },
'partialRight': { 'start': 1 },
'without': { 'start': 1 },
'zipAll': { 'start': 0 }
};
/** Used to identify methods which mutate arrays or objects. */ /** Used to identify methods which mutate arrays or objects. */
'mutateMap': { exports.mutate = {
'array': { 'array': {
'fill': true, 'fill': true,
'pull': true, 'pull': true,
'pullAll': true, 'pullAll': true,
'pullAllBy': true, 'pullAllBy': true,
'pullAt': true, 'pullAllWith': true,
'remove': true, 'pullAt': true,
'reverse': true 'remove': true,
}, 'reverse': true
'object': { },
'assign': true, 'object': {
'assignWith': true, 'assign': true,
'defaults': true, 'assignAll': true,
'defaultsDeep': true, 'assignAllWith': true,
'extend': true, 'assignIn': true,
'extendWith': true, 'assignInAll': true,
'merge': true, 'assignInAllWith': true,
'mergeWith': true 'assignInWith': true,
}, 'assignWith': true,
'set': { 'defaults': true,
'set': true, 'defaultsAll': true,
'setWith': true 'defaultsDeep': true,
} 'defaultsDeepAll': true,
'merge': true,
'mergeAll': true,
'mergeAllWith': true,
'mergeWith': true,
}, },
'set': {
'set': true,
'setWith': true,
'unset': true,
'update': true,
'updateWith': true
}
};
/** Used to track methods that skip `_.rearg`. */ /** Used to map real names to their aliases. */
'skipReargMap': { exports.realToAlias = (function() {
'difference': true, var hasOwnProperty = Object.prototype.hasOwnProperty,
'matchesProperty': true, object = exports.aliasToReal,
'random': true, result = {};
'range': true,
'rangeRight': true, for (var key in object) {
'zip': true, var value = object[key];
'zipObject': true if (hasOwnProperty.call(result, value)) {
result[value].push(key);
} else {
result[value] = [key];
}
} }
return result;
}());
/** Used to map method names to other names. */
exports.remap = {
'assignAll': 'assign',
'assignAllWith': 'assignWith',
'assignInAll': 'assignIn',
'assignInAllWith': 'assignInWith',
'curryN': 'curry',
'curryRightN': 'curryRight',
'defaultsAll': 'defaults',
'defaultsDeepAll': 'defaultsDeep',
'findFrom': 'find',
'findIndexFrom': 'findIndex',
'findLastFrom': 'findLast',
'findLastIndexFrom': 'findLastIndex',
'getOr': 'get',
'includesFrom': 'includes',
'indexOfFrom': 'indexOf',
'invokeArgs': 'invoke',
'invokeArgsMap': 'invokeMap',
'lastIndexOfFrom': 'lastIndexOf',
'mergeAll': 'merge',
'mergeAllWith': 'mergeWith',
'padChars': 'pad',
'padCharsEnd': 'padEnd',
'padCharsStart': 'padStart',
'propertyOf': 'get',
'rangeStep': 'range',
'rangeStepRight': 'rangeRight',
'restFrom': 'rest',
'spreadFrom': 'spread',
'trimChars': 'trim',
'trimCharsEnd': 'trimEnd',
'trimCharsStart': 'trimStart',
'zipAll': 'zip'
};
/** Used to track methods that skip fixing their arity. */
exports.skipFixed = {
'castArray': true,
'flow': true,
'flowRight': true,
'iteratee': true,
'mixin': true,
'rearg': true,
'runInContext': true
};
/** Used to track methods that skip rearranging arguments. */
exports.skipRearg = {
'add': true,
'assign': true,
'assignIn': true,
'bind': true,
'bindKey': true,
'concat': true,
'difference': true,
'divide': true,
'eq': true,
'gt': true,
'gte': true,
'isEqual': true,
'lt': true,
'lte': true,
'matchesProperty': true,
'merge': true,
'multiply': true,
'overArgs': true,
'partial': true,
'partialRight': true,
'propertyOf': true,
'random': true,
'range': true,
'rangeRight': true,
'subtract': true,
'zip': true,
'zipObject': true,
'zipObjectDeep': true
}; };
/***/ } /***/ }),
/* 3 */
/***/ (function(module, exports) {
/**
* The default argument placeholder value for methods.
*
* @type {Object}
*/
module.exports = {};
/***/ })
/******/ ]) /******/ ])
}); });
; ;
 End of changes. 64 change blocks. 
309 lines changed or deleted 911 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)