lodash.mergewith
Advanced tools
Comparing version 4.4.0 to 4.5.0
1129
index.js
@@ -9,7 +9,2 @@ /** | ||
*/ | ||
var baseClone = require('lodash._baseclone'), | ||
isPlainObject = require('lodash.isplainobject'), | ||
keysIn = require('lodash.keysin'), | ||
rest = require('lodash.rest'), | ||
root = require('lodash._root'); | ||
@@ -36,5 +31,7 @@ /** Used as the size to enable large array optimizations. */ | ||
objectTag = '[object Object]', | ||
promiseTag = '[object Promise]', | ||
regexpTag = '[object RegExp]', | ||
setTag = '[object Set]', | ||
stringTag = '[object String]', | ||
symbolTag = '[object Symbol]', | ||
weakMapTag = '[object WeakMap]'; | ||
@@ -60,2 +57,5 @@ | ||
/** Used to match `RegExp` flags from their coerced string values. */ | ||
var reFlags = /\w*$/; | ||
/** Used to detect host constructors (Safari). */ | ||
@@ -83,3 +83,98 @@ var reIsHostCtor = /^\[object .+?Constructor\]$/; | ||
/** Used to identify `toStringTag` values supported by `_.clone`. */ | ||
var cloneableTags = {}; | ||
cloneableTags[argsTag] = cloneableTags[arrayTag] = | ||
cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = | ||
cloneableTags[boolTag] = cloneableTags[dateTag] = | ||
cloneableTags[float32Tag] = cloneableTags[float64Tag] = | ||
cloneableTags[int8Tag] = cloneableTags[int16Tag] = | ||
cloneableTags[int32Tag] = cloneableTags[mapTag] = | ||
cloneableTags[numberTag] = cloneableTags[objectTag] = | ||
cloneableTags[regexpTag] = cloneableTags[setTag] = | ||
cloneableTags[stringTag] = cloneableTags[symbolTag] = | ||
cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = | ||
cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; | ||
cloneableTags[errorTag] = cloneableTags[funcTag] = | ||
cloneableTags[weakMapTag] = false; | ||
/** Detect free variable `global` from Node.js. */ | ||
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; | ||
/** Detect free variable `self`. */ | ||
var freeSelf = typeof self == 'object' && self && self.Object === Object && self; | ||
/** Used as a reference to the global object. */ | ||
var root = freeGlobal || freeSelf || Function('return this')(); | ||
/** Detect free variable `exports`. */ | ||
var freeExports = freeGlobal && typeof exports == 'object' && exports; | ||
/** Detect free variable `module`. */ | ||
var freeModule = freeExports && typeof module == 'object' && module; | ||
/** Detect the popular CommonJS extension `module.exports`. */ | ||
var moduleExports = freeModule && freeModule.exports === freeExports; | ||
/** Detect free variable `process` from Node.js. */ | ||
var freeProcess = moduleExports && freeGlobal.process; | ||
/** Used to access faster Node.js helpers. */ | ||
var nodeUtil = (function() { | ||
try { | ||
return freeProcess && freeProcess.binding('util'); | ||
} catch (e) {} | ||
}()); | ||
/* Node.js helper references. */ | ||
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; | ||
/** | ||
* Adds the key-value `pair` to `map`. | ||
* | ||
* @private | ||
* @param {Object} map The map to modify. | ||
* @param {Array} pair The key-value pair to add. | ||
* @returns {Object} Returns `map`. | ||
*/ | ||
function addMapEntry(map, pair) { | ||
// Don't return `map.set` because it's not chainable in IE 11. | ||
map.set(pair[0], pair[1]); | ||
return map; | ||
} | ||
/** | ||
* Adds `value` to `set`. | ||
* | ||
* @private | ||
* @param {Object} set The set to modify. | ||
* @param {*} value The value to add. | ||
* @returns {Object} Returns `set`. | ||
*/ | ||
function addSetEntry(set, value) { | ||
// Don't return `set.add` because it's not chainable in IE 11. | ||
set.add(value); | ||
return set; | ||
} | ||
/** | ||
* A faster alternative to `Function#apply`, this function invokes `func` | ||
* with the `this` binding of `thisArg` and the arguments of `args`. | ||
* | ||
* @private | ||
* @param {Function} func The function to invoke. | ||
* @param {*} thisArg The `this` binding of `func`. | ||
* @param {Array} args The arguments to invoke `func` with. | ||
* @returns {*} Returns the result of `func`. | ||
*/ | ||
function apply(func, thisArg, args) { | ||
switch (args.length) { | ||
case 0: return func.call(thisArg); | ||
case 1: return func.call(thisArg, args[0]); | ||
case 2: return func.call(thisArg, args[0], args[1]); | ||
case 3: return func.call(thisArg, args[0], args[1], args[2]); | ||
} | ||
return func.apply(thisArg, args); | ||
} | ||
/** | ||
* A specialized version of `_.forEach` for arrays without support for | ||
@@ -89,3 +184,3 @@ * iteratee shorthands. | ||
* @private | ||
* @param {Array} array The array to iterate over. | ||
* @param {Array} [array] The array to iterate over. | ||
* @param {Function} iteratee The function invoked per iteration. | ||
@@ -96,3 +191,3 @@ * @returns {Array} Returns `array`. | ||
var index = -1, | ||
length = array.length; | ||
length = array ? array.length : 0; | ||
@@ -108,2 +203,103 @@ while (++index < length) { | ||
/** | ||
* Appends the elements of `values` to `array`. | ||
* | ||
* @private | ||
* @param {Array} array The array to modify. | ||
* @param {Array} values The values to append. | ||
* @returns {Array} Returns `array`. | ||
*/ | ||
function arrayPush(array, values) { | ||
var index = -1, | ||
length = values.length, | ||
offset = array.length; | ||
while (++index < length) { | ||
array[offset + index] = values[index]; | ||
} | ||
return array; | ||
} | ||
/** | ||
* A specialized version of `_.reduce` for arrays without support for | ||
* iteratee shorthands. | ||
* | ||
* @private | ||
* @param {Array} [array] The array to iterate over. | ||
* @param {Function} iteratee The function invoked per iteration. | ||
* @param {*} [accumulator] The initial value. | ||
* @param {boolean} [initAccum] Specify using the first element of `array` as | ||
* the initial value. | ||
* @returns {*} Returns the accumulated value. | ||
*/ | ||
function arrayReduce(array, iteratee, accumulator, initAccum) { | ||
var index = -1, | ||
length = array ? array.length : 0; | ||
if (initAccum && length) { | ||
accumulator = array[++index]; | ||
} | ||
while (++index < length) { | ||
accumulator = iteratee(accumulator, array[index], index, array); | ||
} | ||
return accumulator; | ||
} | ||
/** | ||
* The base implementation of `_.property` without support for deep paths. | ||
* | ||
* @private | ||
* @param {string} key The key of the property to get. | ||
* @returns {Function} Returns the new accessor function. | ||
*/ | ||
function baseProperty(key) { | ||
return function(object) { | ||
return object == null ? undefined : object[key]; | ||
}; | ||
} | ||
/** | ||
* The base implementation of `_.times` without support for iteratee shorthands | ||
* or max array length checks. | ||
* | ||
* @private | ||
* @param {number} n The number of times to invoke `iteratee`. | ||
* @param {Function} iteratee The function invoked per iteration. | ||
* @returns {Array} Returns the array of results. | ||
*/ | ||
function baseTimes(n, iteratee) { | ||
var index = -1, | ||
result = Array(n); | ||
while (++index < n) { | ||
result[index] = iteratee(index); | ||
} | ||
return result; | ||
} | ||
/** | ||
* The base implementation of `_.unary` without support for storing metadata. | ||
* | ||
* @private | ||
* @param {Function} func The function to cap arguments for. | ||
* @returns {Function} Returns the new capped function. | ||
*/ | ||
function baseUnary(func) { | ||
return function(value) { | ||
return func(value); | ||
}; | ||
} | ||
/** | ||
* Gets the value at `key` of `object`. | ||
* | ||
* @private | ||
* @param {Object} [object] The object to query. | ||
* @param {string} key The key of the property to get. | ||
* @returns {*} Returns the property value. | ||
*/ | ||
function getValue(object, key) { | ||
return object == null ? undefined : object[key]; | ||
} | ||
/** | ||
* Checks if `value` is a host object in IE < 9. | ||
@@ -127,2 +323,67 @@ * | ||
/** | ||
* Converts `iterator` to an array. | ||
* | ||
* @private | ||
* @param {Object} iterator The iterator to convert. | ||
* @returns {Array} Returns the converted array. | ||
*/ | ||
function iteratorToArray(iterator) { | ||
var data, | ||
result = []; | ||
while (!(data = iterator.next()).done) { | ||
result.push(data.value); | ||
} | ||
return result; | ||
} | ||
/** | ||
* Converts `map` to its key-value pairs. | ||
* | ||
* @private | ||
* @param {Object} map The map to convert. | ||
* @returns {Array} Returns the key-value pairs. | ||
*/ | ||
function mapToArray(map) { | ||
var index = -1, | ||
result = Array(map.size); | ||
map.forEach(function(value, key) { | ||
result[++index] = [key, value]; | ||
}); | ||
return result; | ||
} | ||
/** | ||
* Creates a function that invokes `func` with its first argument transformed. | ||
* | ||
* @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(arg) { | ||
return func(transform(arg)); | ||
}; | ||
} | ||
/** | ||
* Converts `set` to an array of its values. | ||
* | ||
* @private | ||
* @param {Object} set The set to convert. | ||
* @returns {Array} Returns the values. | ||
*/ | ||
function setToArray(set) { | ||
var index = -1, | ||
result = Array(set.size); | ||
set.forEach(function(value) { | ||
result[++index] = value; | ||
}); | ||
return result; | ||
} | ||
/** Used for built-in method references. */ | ||
@@ -132,2 +393,11 @@ var arrayProto = Array.prototype, | ||
/** Used to detect overreaching core-js shims. */ | ||
var coreJsData = root['__core-js_shared__']; | ||
/** Used to detect methods masquerading as native. */ | ||
var maskSrcKey = (function() { | ||
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); | ||
return uid ? ('Symbol(src)_1.' + uid) : ''; | ||
}()); | ||
/** Used to resolve the decompiled source of functions. */ | ||
@@ -139,2 +409,5 @@ var funcToString = Function.prototype.toString; | ||
/** Used to infer the `Object` constructor. */ | ||
var objectCtorString = funcToString.call(Object); | ||
/** | ||
@@ -154,9 +427,37 @@ * Used to resolve the | ||
/** Built-in value references. */ | ||
var propertyIsEnumerable = objectProto.propertyIsEnumerable, | ||
var Buffer = moduleExports ? root.Buffer : undefined, | ||
Reflect = root.Reflect, | ||
Symbol = root.Symbol, | ||
Uint8Array = root.Uint8Array, | ||
enumerate = Reflect ? Reflect.enumerate : undefined, | ||
objectCreate = Object.create, | ||
propertyIsEnumerable = objectProto.propertyIsEnumerable, | ||
splice = arrayProto.splice; | ||
/* Built-in method references for those with the same name as other `lodash` methods. */ | ||
var nativeGetPrototype = Object.getPrototypeOf, | ||
nativeGetSymbols = Object.getOwnPropertySymbols, | ||
nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, | ||
nativeKeys = Object.keys, | ||
nativeMax = Math.max; | ||
/* Built-in method references that are verified to be native. */ | ||
var Map = getNative(root, 'Map'), | ||
var DataView = getNative(root, 'DataView'), | ||
Map = getNative(root, 'Map'), | ||
Promise = getNative(root, 'Promise'), | ||
Set = getNative(root, 'Set'), | ||
WeakMap = getNative(root, 'WeakMap'), | ||
nativeCreate = getNative(Object, 'create'); | ||
/** Used to detect maps, sets, and weakmaps. */ | ||
var dataViewCtorString = toSource(DataView), | ||
mapCtorString = toSource(Map), | ||
promiseCtorString = toSource(Promise), | ||
setCtorString = toSource(Set), | ||
weakMapCtorString = toSource(WeakMap); | ||
/** Used to convert symbols to primitives and strings. */ | ||
var symbolProto = Symbol ? Symbol.prototype : undefined, | ||
symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; | ||
/** | ||
@@ -539,4 +840,9 @@ * Creates a hash object. | ||
var cache = this.__data__; | ||
if (cache instanceof ListCache && cache.__data__.length == LARGE_ARRAY_SIZE) { | ||
cache = this.__data__ = new MapCache(cache.__data__); | ||
if (cache instanceof ListCache) { | ||
var pairs = cache.__data__; | ||
if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { | ||
pairs.push([key, value]); | ||
return this; | ||
} | ||
cache = this.__data__ = new MapCache(pairs); | ||
} | ||
@@ -607,2 +913,212 @@ cache.set(key, value); | ||
/** | ||
* The base implementation of `_.assign` without support for multiple sources | ||
* or `customizer` functions. | ||
* | ||
* @private | ||
* @param {Object} object The destination object. | ||
* @param {Object} source The source object. | ||
* @returns {Object} Returns `object`. | ||
*/ | ||
function baseAssign(object, source) { | ||
return object && copyObject(source, keys(source), object); | ||
} | ||
/** | ||
* The base implementation of `_.clone` and `_.cloneDeep` which tracks | ||
* traversed objects. | ||
* | ||
* @private | ||
* @param {*} value The value to clone. | ||
* @param {boolean} [isDeep] Specify a deep clone. | ||
* @param {boolean} [isFull] Specify a clone including symbols. | ||
* @param {Function} [customizer] The function to customize cloning. | ||
* @param {string} [key] The key of `value`. | ||
* @param {Object} [object] The parent object of `value`. | ||
* @param {Object} [stack] Tracks traversed objects and their clone counterparts. | ||
* @returns {*} Returns the cloned value. | ||
*/ | ||
function baseClone(value, isDeep, isFull, customizer, key, object, stack) { | ||
var result; | ||
if (customizer) { | ||
result = object ? customizer(value, key, object, stack) : customizer(value); | ||
} | ||
if (result !== undefined) { | ||
return result; | ||
} | ||
if (!isObject(value)) { | ||
return value; | ||
} | ||
var isArr = isArray(value); | ||
if (isArr) { | ||
result = initCloneArray(value); | ||
if (!isDeep) { | ||
return copyArray(value, result); | ||
} | ||
} else { | ||
var tag = getTag(value), | ||
isFunc = tag == funcTag || tag == genTag; | ||
if (isBuffer(value)) { | ||
return cloneBuffer(value, isDeep); | ||
} | ||
if (tag == objectTag || tag == argsTag || (isFunc && !object)) { | ||
if (isHostObject(value)) { | ||
return object ? value : {}; | ||
} | ||
result = initCloneObject(isFunc ? {} : value); | ||
if (!isDeep) { | ||
return copySymbols(value, baseAssign(result, value)); | ||
} | ||
} else { | ||
if (!cloneableTags[tag]) { | ||
return object ? value : {}; | ||
} | ||
result = initCloneByTag(value, tag, baseClone, isDeep); | ||
} | ||
} | ||
// Check for circular references and return its corresponding clone. | ||
stack || (stack = new Stack); | ||
var stacked = stack.get(value); | ||
if (stacked) { | ||
return stacked; | ||
} | ||
stack.set(value, result); | ||
if (!isArr) { | ||
var props = isFull ? getAllKeys(value) : keys(value); | ||
} | ||
arrayEach(props || value, function(subValue, key) { | ||
if (props) { | ||
key = subValue; | ||
subValue = value[key]; | ||
} | ||
// Recursively populate clone (susceptible to call stack limits). | ||
assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack)); | ||
}); | ||
if (!isFull) { | ||
stack['delete'](value); | ||
} | ||
return result; | ||
} | ||
/** | ||
* The base implementation of `_.create` without support for assigning | ||
* properties to the created object. | ||
* | ||
* @private | ||
* @param {Object} prototype The object to inherit from. | ||
* @returns {Object} Returns the new object. | ||
*/ | ||
function baseCreate(proto) { | ||
return isObject(proto) ? objectCreate(proto) : {}; | ||
} | ||
/** | ||
* The base implementation of `getAllKeys` and `getAllKeysIn` which uses | ||
* `keysFunc` and `symbolsFunc` to get the enumerable property names and | ||
* symbols of `object`. | ||
* | ||
* @private | ||
* @param {Object} object The object to query. | ||
* @param {Function} keysFunc The function to get the keys of `object`. | ||
* @param {Function} symbolsFunc The function to get the symbols of `object`. | ||
* @returns {Array} Returns the array of property names and symbols. | ||
*/ | ||
function baseGetAllKeys(object, keysFunc, symbolsFunc) { | ||
var result = keysFunc(object); | ||
return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); | ||
} | ||
/** | ||
* The base implementation of `getTag`. | ||
* | ||
* @private | ||
* @param {*} value The value to query. | ||
* @returns {string} Returns the `toStringTag`. | ||
*/ | ||
function baseGetTag(value) { | ||
return objectToString.call(value); | ||
} | ||
/** | ||
* The base implementation of `_.has` without support for deep paths. | ||
* | ||
* @private | ||
* @param {Object} [object] The object to query. | ||
* @param {Array|string} key The key to check. | ||
* @returns {boolean} Returns `true` if `key` exists, else `false`. | ||
*/ | ||
function baseHas(object, key) { | ||
// Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`, | ||
// that are composed entirely of index properties, return `false` for | ||
// `hasOwnProperty` checks of them. | ||
return object != null && | ||
(hasOwnProperty.call(object, key) || | ||
(typeof object == 'object' && key in object && getPrototype(object) === null)); | ||
} | ||
/** | ||
* The base implementation of `_.isNative` without bad shim checks. | ||
* | ||
* @private | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is a native function, | ||
* else `false`. | ||
*/ | ||
function baseIsNative(value) { | ||
if (!isObject(value) || isMasked(value)) { | ||
return false; | ||
} | ||
var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; | ||
return pattern.test(toSource(value)); | ||
} | ||
/** | ||
* The base implementation of `_.isTypedArray` without Node.js optimizations. | ||
* | ||
* @private | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`. | ||
*/ | ||
function baseIsTypedArray(value) { | ||
return isObjectLike(value) && | ||
isLength(value.length) && !!typedArrayTags[objectToString.call(value)]; | ||
} | ||
/** | ||
* The base implementation of `_.keys` which doesn't skip the constructor | ||
* property of prototypes or treat sparse arrays as dense. | ||
* | ||
* @private | ||
* @param {Object} object The object to query. | ||
* @returns {Array} Returns the array of property names. | ||
*/ | ||
var baseKeys = overArg(nativeKeys, Object); | ||
/** | ||
* The base implementation of `_.keysIn` which doesn't skip the constructor | ||
* property of prototypes or treat sparse arrays as dense. | ||
* | ||
* @private | ||
* @param {Object} object The object to query. | ||
* @returns {Array} Returns the array of property names. | ||
*/ | ||
function baseKeysIn(object) { | ||
object = object == null ? object : Object(object); | ||
var result = []; | ||
for (var key in object) { | ||
result.push(key); | ||
} | ||
return result; | ||
} | ||
// Fallback for IE < 9 with es6-shim. | ||
if (enumerate && !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf')) { | ||
baseKeysIn = function(object) { | ||
return iteratorToArray(enumerate(object)); | ||
}; | ||
} | ||
/** | ||
* The base implementation of `_.merge` without support for multiple sources. | ||
@@ -707,9 +1223,8 @@ * | ||
} | ||
stack.set(srcValue, newValue); | ||
if (isCommon) { | ||
// Recursively merge objects and arrays (susceptible to call stack limits). | ||
stack.set(srcValue, newValue); | ||
mergeFunc(newValue, srcValue, srcIndex, customizer, stack); | ||
stack['delete'](srcValue); | ||
} | ||
stack['delete'](srcValue); | ||
assignMergeValue(object, key, newValue); | ||
@@ -719,11 +1234,27 @@ } | ||
/** | ||
* The base implementation of `_.property` without support for deep paths. | ||
* The base implementation of `_.rest` which doesn't validate or coerce arguments. | ||
* | ||
* @private | ||
* @param {string} key The key of the property to get. | ||
* @returns {Function} Returns the new accessor function. | ||
* @param {Function} func The function to apply a rest parameter to. | ||
* @param {number} [start=func.length-1] The start position of the rest parameter. | ||
* @returns {Function} Returns the new function. | ||
*/ | ||
function baseProperty(key) { | ||
return function(object) { | ||
return object == null ? undefined : object[key]; | ||
function baseRest(func, start) { | ||
start = nativeMax(start === undefined ? (func.length - 1) : start, 0); | ||
return function() { | ||
var args = arguments, | ||
index = -1, | ||
length = nativeMax(args.length - start, 0), | ||
array = Array(length); | ||
while (++index < length) { | ||
array[index] = args[start + index]; | ||
} | ||
index = -1; | ||
var otherArgs = Array(start + 1); | ||
while (++index < start) { | ||
otherArgs[index] = args[index]; | ||
} | ||
otherArgs[start] = array; | ||
return apply(func, this, otherArgs); | ||
}; | ||
@@ -733,2 +1264,110 @@ } | ||
/** | ||
* Creates a clone of `buffer`. | ||
* | ||
* @private | ||
* @param {Buffer} buffer The buffer to clone. | ||
* @param {boolean} [isDeep] Specify a deep clone. | ||
* @returns {Buffer} Returns the cloned buffer. | ||
*/ | ||
function cloneBuffer(buffer, isDeep) { | ||
if (isDeep) { | ||
return buffer.slice(); | ||
} | ||
var result = new buffer.constructor(buffer.length); | ||
buffer.copy(result); | ||
return result; | ||
} | ||
/** | ||
* Creates a clone of `arrayBuffer`. | ||
* | ||
* @private | ||
* @param {ArrayBuffer} arrayBuffer The array buffer to clone. | ||
* @returns {ArrayBuffer} Returns the cloned array buffer. | ||
*/ | ||
function cloneArrayBuffer(arrayBuffer) { | ||
var result = new arrayBuffer.constructor(arrayBuffer.byteLength); | ||
new Uint8Array(result).set(new Uint8Array(arrayBuffer)); | ||
return result; | ||
} | ||
/** | ||
* Creates a clone of `dataView`. | ||
* | ||
* @private | ||
* @param {Object} dataView The data view to clone. | ||
* @param {boolean} [isDeep] Specify a deep clone. | ||
* @returns {Object} Returns the cloned data view. | ||
*/ | ||
function cloneDataView(dataView, isDeep) { | ||
var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; | ||
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); | ||
} | ||
/** | ||
* Creates a clone of `map`. | ||
* | ||
* @private | ||
* @param {Object} map The map to clone. | ||
* @param {Function} cloneFunc The function to clone values. | ||
* @param {boolean} [isDeep] Specify a deep clone. | ||
* @returns {Object} Returns the cloned map. | ||
*/ | ||
function cloneMap(map, isDeep, cloneFunc) { | ||
var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map); | ||
return arrayReduce(array, addMapEntry, new map.constructor); | ||
} | ||
/** | ||
* Creates a clone of `regexp`. | ||
* | ||
* @private | ||
* @param {Object} regexp The regexp to clone. | ||
* @returns {Object} Returns the cloned regexp. | ||
*/ | ||
function cloneRegExp(regexp) { | ||
var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); | ||
result.lastIndex = regexp.lastIndex; | ||
return result; | ||
} | ||
/** | ||
* Creates a clone of `set`. | ||
* | ||
* @private | ||
* @param {Object} set The set to clone. | ||
* @param {Function} cloneFunc The function to clone values. | ||
* @param {boolean} [isDeep] Specify a deep clone. | ||
* @returns {Object} Returns the cloned set. | ||
*/ | ||
function cloneSet(set, isDeep, cloneFunc) { | ||
var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set); | ||
return arrayReduce(array, addSetEntry, new set.constructor); | ||
} | ||
/** | ||
* Creates a clone of the `symbol` object. | ||
* | ||
* @private | ||
* @param {Object} symbol The symbol object to clone. | ||
* @returns {Object} Returns the cloned symbol object. | ||
*/ | ||
function cloneSymbol(symbol) { | ||
return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; | ||
} | ||
/** | ||
* Creates a clone of `typedArray`. | ||
* | ||
* @private | ||
* @param {Object} typedArray The typed array to clone. | ||
* @param {boolean} [isDeep] Specify a deep clone. | ||
* @returns {Object} Returns the cloned typed array. | ||
*/ | ||
function cloneTypedArray(typedArray, isDeep) { | ||
var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; | ||
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); | ||
} | ||
/** | ||
* Copies the values of `source` to `array`. | ||
@@ -773,5 +1412,5 @@ * | ||
? customizer(object[key], source[key], key, object, source) | ||
: source[key]; | ||
: undefined; | ||
assignValue(object, key, newValue); | ||
assignValue(object, key, newValue === undefined ? source[key] : newValue); | ||
} | ||
@@ -782,2 +1421,14 @@ return object; | ||
/** | ||
* Copies own symbol properties of `source` to `object`. | ||
* | ||
* @private | ||
* @param {Object} source The object to copy symbols from. | ||
* @param {Object} [object={}] The object to copy symbols to. | ||
* @returns {Object} Returns `object`. | ||
*/ | ||
function copySymbols(source, object) { | ||
return copyObject(source, getSymbols(source), object); | ||
} | ||
/** | ||
* Creates a function like `_.assign`. | ||
@@ -790,3 +1441,3 @@ * | ||
function createAssigner(assigner) { | ||
return rest(function(object, sources) { | ||
return baseRest(function(object, sources) { | ||
var index = -1, | ||
@@ -817,2 +1468,13 @@ length = sources.length, | ||
/** | ||
* Creates an array of own enumerable property names and symbols of `object`. | ||
* | ||
* @private | ||
* @param {Object} object The object to query. | ||
* @returns {Array} Returns the array of property names and symbols. | ||
*/ | ||
function getAllKeys(object) { | ||
return baseGetAllKeys(object, keys, getSymbols); | ||
} | ||
/** | ||
* Gets the "length" property value of `object`. | ||
@@ -854,7 +1516,157 @@ * | ||
function getNative(object, key) { | ||
var value = object[key]; | ||
return isNative(value) ? value : undefined; | ||
var value = getValue(object, key); | ||
return baseIsNative(value) ? value : undefined; | ||
} | ||
/** | ||
* Gets the `[[Prototype]]` of `value`. | ||
* | ||
* @private | ||
* @param {*} value The value to query. | ||
* @returns {null|Object} Returns the `[[Prototype]]`. | ||
*/ | ||
var getPrototype = overArg(nativeGetPrototype, Object); | ||
/** | ||
* Creates an array of the own enumerable symbol properties of `object`. | ||
* | ||
* @private | ||
* @param {Object} object The object to query. | ||
* @returns {Array} Returns the array of symbols. | ||
*/ | ||
var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray; | ||
/** | ||
* Gets the `toStringTag` of `value`. | ||
* | ||
* @private | ||
* @param {*} value The value to query. | ||
* @returns {string} Returns the `toStringTag`. | ||
*/ | ||
var getTag = baseGetTag; | ||
// Fallback for data views, maps, sets, and weak maps in IE 11, | ||
// for data views in Edge, and promises in Node.js. | ||
if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || | ||
(Map && getTag(new Map) != mapTag) || | ||
(Promise && getTag(Promise.resolve()) != promiseTag) || | ||
(Set && getTag(new Set) != setTag) || | ||
(WeakMap && getTag(new WeakMap) != weakMapTag)) { | ||
getTag = function(value) { | ||
var result = objectToString.call(value), | ||
Ctor = result == objectTag ? value.constructor : undefined, | ||
ctorString = Ctor ? toSource(Ctor) : undefined; | ||
if (ctorString) { | ||
switch (ctorString) { | ||
case dataViewCtorString: return dataViewTag; | ||
case mapCtorString: return mapTag; | ||
case promiseCtorString: return promiseTag; | ||
case setCtorString: return setTag; | ||
case weakMapCtorString: return weakMapTag; | ||
} | ||
} | ||
return result; | ||
}; | ||
} | ||
/** | ||
* Initializes an array clone. | ||
* | ||
* @private | ||
* @param {Array} array The array to clone. | ||
* @returns {Array} Returns the initialized clone. | ||
*/ | ||
function initCloneArray(array) { | ||
var length = array.length, | ||
result = array.constructor(length); | ||
// Add properties assigned by `RegExp#exec`. | ||
if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { | ||
result.index = array.index; | ||
result.input = array.input; | ||
} | ||
return result; | ||
} | ||
/** | ||
* Initializes an object clone. | ||
* | ||
* @private | ||
* @param {Object} object The object to clone. | ||
* @returns {Object} Returns the initialized clone. | ||
*/ | ||
function initCloneObject(object) { | ||
return (typeof object.constructor == 'function' && !isPrototype(object)) | ||
? baseCreate(getPrototype(object)) | ||
: {}; | ||
} | ||
/** | ||
* Initializes an object clone based on its `toStringTag`. | ||
* | ||
* **Note:** This function only supports cloning values with tags of | ||
* `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. | ||
* | ||
* @private | ||
* @param {Object} object The object to clone. | ||
* @param {string} tag The `toStringTag` of the object to clone. | ||
* @param {Function} cloneFunc The function to clone values. | ||
* @param {boolean} [isDeep] Specify a deep clone. | ||
* @returns {Object} Returns the initialized clone. | ||
*/ | ||
function initCloneByTag(object, tag, cloneFunc, isDeep) { | ||
var Ctor = object.constructor; | ||
switch (tag) { | ||
case arrayBufferTag: | ||
return cloneArrayBuffer(object); | ||
case boolTag: | ||
case dateTag: | ||
return new Ctor(+object); | ||
case dataViewTag: | ||
return cloneDataView(object, isDeep); | ||
case float32Tag: case float64Tag: | ||
case int8Tag: case int16Tag: case int32Tag: | ||
case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: | ||
return cloneTypedArray(object, isDeep); | ||
case mapTag: | ||
return cloneMap(object, isDeep, cloneFunc); | ||
case numberTag: | ||
case stringTag: | ||
return new Ctor(object); | ||
case regexpTag: | ||
return cloneRegExp(object); | ||
case setTag: | ||
return cloneSet(object, isDeep, cloneFunc); | ||
case symbolTag: | ||
return cloneSymbol(object); | ||
} | ||
} | ||
/** | ||
* Creates an array of index keys for `object` values of arrays, | ||
* `arguments` objects, and strings, otherwise `null` is returned. | ||
* | ||
* @private | ||
* @param {Object} object The object to query. | ||
* @returns {Array|null} Returns index keys, else `null`. | ||
*/ | ||
function indexKeys(object) { | ||
var length = object ? object.length : undefined; | ||
if (isLength(length) && | ||
(isArray(object) || isString(object) || isArguments(object))) { | ||
return baseTimes(length, String); | ||
} | ||
return null; | ||
} | ||
/** | ||
* Checks if `value` is a valid array-like index. | ||
@@ -913,2 +1725,27 @@ * | ||
/** | ||
* Checks if `func` has its source masked. | ||
* | ||
* @private | ||
* @param {Function} func The function to check. | ||
* @returns {boolean} Returns `true` if `func` is masked, else `false`. | ||
*/ | ||
function isMasked(func) { | ||
return !!maskSrcKey && (maskSrcKey in func); | ||
} | ||
/** | ||
* Checks if `value` is likely a prototype object. | ||
* | ||
* @private | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is a prototype, else `false`. | ||
*/ | ||
function isPrototype(value) { | ||
var Ctor = value && value.constructor, | ||
proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; | ||
return value === proto; | ||
} | ||
/** | ||
* Converts `func` to its source code. | ||
@@ -946,4 +1783,4 @@ * | ||
* | ||
* var object = { 'user': 'fred' }; | ||
* var other = { 'user': 'fred' }; | ||
* var object = { 'a': 1 }; | ||
* var other = { 'a': 1 }; | ||
* | ||
@@ -977,3 +1814,3 @@ * _.eq(object, object); | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is correctly classified, | ||
* @returns {boolean} Returns `true` if `value` is an `arguments` object, | ||
* else `false`. | ||
@@ -1000,7 +1837,5 @@ * @example | ||
* @since 0.1.0 | ||
* @type {Function} | ||
* @category Lang | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is correctly classified, | ||
* else `false`. | ||
* @returns {boolean} Returns `true` if `value` is an array, else `false`. | ||
* @example | ||
@@ -1081,2 +1916,21 @@ * | ||
/** | ||
* Checks if `value` is a buffer. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 4.3.0 | ||
* @category Lang | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is a buffer, else `false`. | ||
* @example | ||
* | ||
* _.isBuffer(new Buffer(2)); | ||
* // => true | ||
* | ||
* _.isBuffer(new Uint8Array(2)); | ||
* // => false | ||
*/ | ||
var isBuffer = nativeIsBuffer || stubFalse; | ||
/** | ||
* Checks if `value` is classified as a `Function` object. | ||
@@ -1089,4 +1943,3 @@ * | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is correctly classified, | ||
* else `false`. | ||
* @returns {boolean} Returns `true` if `value` is a function, else `false`. | ||
* @example | ||
@@ -1199,28 +2052,67 @@ * | ||
/** | ||
* Checks if `value` is a native function. | ||
* Checks if `value` is a plain object, that is, an object created by the | ||
* `Object` constructor or one with a `[[Prototype]]` of `null`. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 3.0.0 | ||
* @since 0.8.0 | ||
* @category Lang | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is a native function, | ||
* @returns {boolean} Returns `true` if `value` is a plain object, | ||
* else `false`. | ||
* @example | ||
* | ||
* _.isNative(Array.prototype.push); | ||
* function Foo() { | ||
* this.a = 1; | ||
* } | ||
* | ||
* _.isPlainObject(new Foo); | ||
* // => false | ||
* | ||
* _.isPlainObject([1, 2, 3]); | ||
* // => false | ||
* | ||
* _.isPlainObject({ 'x': 0, 'y': 0 }); | ||
* // => true | ||
* | ||
* _.isNative(_); | ||
* // => false | ||
* _.isPlainObject(Object.create(null)); | ||
* // => true | ||
*/ | ||
function isNative(value) { | ||
if (!isObject(value)) { | ||
function isPlainObject(value) { | ||
if (!isObjectLike(value) || | ||
objectToString.call(value) != objectTag || isHostObject(value)) { | ||
return false; | ||
} | ||
var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; | ||
return pattern.test(toSource(value)); | ||
var proto = getPrototype(value); | ||
if (proto === null) { | ||
return true; | ||
} | ||
var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; | ||
return (typeof Ctor == 'function' && | ||
Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString); | ||
} | ||
/** | ||
* Checks if `value` is classified as a `String` primitive or object. | ||
* | ||
* @static | ||
* @since 0.1.0 | ||
* @memberOf _ | ||
* @category Lang | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is a string, else `false`. | ||
* @example | ||
* | ||
* _.isString('abc'); | ||
* // => true | ||
* | ||
* _.isString(1); | ||
* // => false | ||
*/ | ||
function isString(value) { | ||
return typeof value == 'string' || | ||
(!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag); | ||
} | ||
/** | ||
* Checks if `value` is classified as a typed array. | ||
@@ -1233,4 +2125,3 @@ * | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is correctly classified, | ||
* else `false`. | ||
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`. | ||
* @example | ||
@@ -1244,6 +2135,3 @@ * | ||
*/ | ||
function isTypedArray(value) { | ||
return isObjectLike(value) && | ||
isLength(value.length) && !!typedArrayTags[objectToString.call(value)]; | ||
} | ||
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; | ||
@@ -1279,2 +2167,93 @@ /** | ||
/** | ||
* Creates an array of the own enumerable property names of `object`. | ||
* | ||
* **Note:** Non-object values are coerced to objects. See the | ||
* [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys) | ||
* for more details. | ||
* | ||
* @static | ||
* @since 0.1.0 | ||
* @memberOf _ | ||
* @category Object | ||
* @param {Object} object The object to query. | ||
* @returns {Array} Returns the array of property names. | ||
* @example | ||
* | ||
* function Foo() { | ||
* this.a = 1; | ||
* this.b = 2; | ||
* } | ||
* | ||
* Foo.prototype.c = 3; | ||
* | ||
* _.keys(new Foo); | ||
* // => ['a', 'b'] (iteration order is not guaranteed) | ||
* | ||
* _.keys('hi'); | ||
* // => ['0', '1'] | ||
*/ | ||
function keys(object) { | ||
var isProto = isPrototype(object); | ||
if (!(isProto || isArrayLike(object))) { | ||
return baseKeys(object); | ||
} | ||
var indexes = indexKeys(object), | ||
skipIndexes = !!indexes, | ||
result = indexes || [], | ||
length = result.length; | ||
for (var key in object) { | ||
if (baseHas(object, key) && | ||
!(skipIndexes && (key == 'length' || isIndex(key, length))) && | ||
!(isProto && key == 'constructor')) { | ||
result.push(key); | ||
} | ||
} | ||
return result; | ||
} | ||
/** | ||
* Creates an array of the own and inherited enumerable property names of `object`. | ||
* | ||
* **Note:** Non-object values are coerced to objects. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 3.0.0 | ||
* @category Object | ||
* @param {Object} object The object to query. | ||
* @returns {Array} Returns the array of property names. | ||
* @example | ||
* | ||
* function Foo() { | ||
* this.a = 1; | ||
* this.b = 2; | ||
* } | ||
* | ||
* Foo.prototype.c = 3; | ||
* | ||
* _.keysIn(new Foo); | ||
* // => ['a', 'b', 'c'] (iteration order is not guaranteed) | ||
*/ | ||
function keysIn(object) { | ||
var index = -1, | ||
isProto = isPrototype(object), | ||
props = baseKeysIn(object), | ||
propsLength = props.length, | ||
indexes = indexKeys(object), | ||
skipIndexes = !!indexes, | ||
result = indexes || [], | ||
length = result.length; | ||
while (++index < propsLength) { | ||
var key = props[index]; | ||
if (!(skipIndexes && (key == 'length' || isIndex(key, length))) && | ||
!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { | ||
result.push(key); | ||
} | ||
} | ||
return result; | ||
} | ||
/** | ||
* This method is like `_.merge` except that it accepts `customizer` which | ||
@@ -1304,14 +2283,7 @@ * is invoked to produce the merged values of the destination and source | ||
* | ||
* var object = { | ||
* 'fruits': ['apple'], | ||
* 'vegetables': ['beet'] | ||
* }; | ||
* var object = { 'a': [1], 'b': [2] }; | ||
* var other = { 'a': [3], 'b': [4] }; | ||
* | ||
* var other = { | ||
* 'fruits': ['banana'], | ||
* 'vegetables': ['carrot'] | ||
* }; | ||
* | ||
* _.mergeWith(object, other, customizer); | ||
* // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] } | ||
* // => { 'a': [1, 3], 'b': [2, 4] } | ||
*/ | ||
@@ -1322,2 +2294,41 @@ var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { | ||
/** | ||
* This method returns a new empty array. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 4.13.0 | ||
* @category Util | ||
* @returns {Array} Returns the new empty array. | ||
* @example | ||
* | ||
* var arrays = _.times(2, _.stubArray); | ||
* | ||
* console.log(arrays); | ||
* // => [[], []] | ||
* | ||
* console.log(arrays[0] === arrays[1]); | ||
* // => false | ||
*/ | ||
function stubArray() { | ||
return []; | ||
} | ||
/** | ||
* This method returns `false`. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 4.13.0 | ||
* @category Util | ||
* @returns {boolean} Returns `false`. | ||
* @example | ||
* | ||
* _.times(2, _.stubFalse); | ||
* // => [false, false] | ||
*/ | ||
function stubFalse() { | ||
return false; | ||
} | ||
module.exports = mergeWith; |
{ | ||
"name": "lodash.mergewith", | ||
"version": "4.4.0", | ||
"version": "4.5.0", | ||
"description": "The lodash method `_.mergeWith` exported as a module.", | ||
@@ -16,10 +16,3 @@ "homepage": "https://lodash.com/", | ||
"repository": "lodash/lodash", | ||
"scripts": { "test": "echo \"See https://travis-ci.org/lodash/lodash-cli for testing details.\"" }, | ||
"dependencies": { | ||
"lodash._baseclone": "~4.5.0", | ||
"lodash._root": "~3.0.0", | ||
"lodash.isplainobject": "^4.0.0", | ||
"lodash.keysin": "^4.0.0", | ||
"lodash.rest": "^4.0.0" | ||
} | ||
"scripts": { "test": "echo \"See https://travis-ci.org/lodash/lodash-cli for testing details.\"" } | ||
} |
@@ -1,2 +0,2 @@ | ||
# lodash.mergewith v4.4.0 | ||
# lodash.mergewith v4.5.0 | ||
@@ -18,2 +18,2 @@ The [lodash](https://lodash.com/) method `_.mergeWith` exported as a [Node.js](https://nodejs.org/) module. | ||
See the [documentation](https://lodash.com/docs#mergeWith) or [package source](https://github.com/lodash/lodash/blob/4.4.0-npm-packages/lodash.mergewith) for more details. | ||
See the [documentation](https://lodash.com/docs#mergeWith) or [package source](https://github.com/lodash/lodash/blob/4.5.0-npm-packages/lodash.mergewith) for more details. |
63861
0
2117
- Removedlodash._baseclone@~4.5.0
- Removedlodash._root@~3.0.0
- Removedlodash.isplainobject@^4.0.0
- Removedlodash.keysin@^4.0.0
- Removedlodash.rest@^4.0.0
- Removedlodash._baseclone@4.5.7(transitive)
- Removedlodash._root@3.0.1(transitive)
- Removedlodash.isplainobject@4.0.6(transitive)
- Removedlodash.keysin@4.2.0(transitive)
- Removedlodash.rest@4.0.5(transitive)