"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "dist/mapping.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.

mapping.fp.js  (lodash-4.0.0)	:	mapping.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) {		/***/ (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
};		};
/***/ }		/***/ })
/******/ ])		/******/ ])
});		});
;		;
End of changes. 14 change blocks.
171 lines changed or deleted		377 lines changed or added

---