mirror of
https://github.com/whoisclebs/lodash.git
synced 2026-02-04 08:57:49 +00:00
Bump to v3.9.0.
This commit is contained in:
@@ -1,12 +1,12 @@
|
||||
import cachePush from './cachePush';
|
||||
import isNative from '../lang/isNative';
|
||||
import getNative from './getNative';
|
||||
import root from './root';
|
||||
|
||||
/** Native method references. */
|
||||
var Set = isNative(Set = root.Set) && Set;
|
||||
var Set = getNative(root, 'Set');
|
||||
|
||||
/* Native method references for those with the same name as other `lodash` methods. */
|
||||
var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate;
|
||||
var nativeCreate = getNative(Object, 'create');
|
||||
|
||||
/**
|
||||
*
|
||||
|
||||
30
internal/arrayExtremum.js
Normal file
30
internal/arrayExtremum.js
Normal file
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* A specialized version of `baseExtremum` for arrays whichs invokes `iteratee`
|
||||
* with one argument: (value).
|
||||
*
|
||||
* @private
|
||||
* @param {Array} array The array to iterate over.
|
||||
* @param {Function} iteratee The function invoked per iteration.
|
||||
* @param {Function} comparator The function used to compare values.
|
||||
* @param {*} exValue The initial extremum value.
|
||||
* @returns {*} Returns the extremum value.
|
||||
*/
|
||||
function arrayExtremum(array, iteratee, comparator, exValue) {
|
||||
var index = -1,
|
||||
length = array.length,
|
||||
computed = exValue,
|
||||
result = computed;
|
||||
|
||||
while (++index < length) {
|
||||
var value = array[index],
|
||||
current = +iteratee(value);
|
||||
|
||||
if (comparator(current, computed)) {
|
||||
computed = current;
|
||||
result = value;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
export default arrayExtremum;
|
||||
@@ -1,25 +0,0 @@
|
||||
/** Used as references for `-Infinity` and `Infinity`. */
|
||||
var NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY;
|
||||
|
||||
/**
|
||||
* A specialized version of `_.max` for arrays without support for iteratees.
|
||||
*
|
||||
* @private
|
||||
* @param {Array} array The array to iterate over.
|
||||
* @returns {*} Returns the maximum value.
|
||||
*/
|
||||
function arrayMax(array) {
|
||||
var index = -1,
|
||||
length = array.length,
|
||||
result = NEGATIVE_INFINITY;
|
||||
|
||||
while (++index < length) {
|
||||
var value = array[index];
|
||||
if (value > result) {
|
||||
result = value;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
export default arrayMax;
|
||||
@@ -1,25 +0,0 @@
|
||||
/** Used as references for `-Infinity` and `Infinity`. */
|
||||
var POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
|
||||
|
||||
/**
|
||||
* A specialized version of `_.min` for arrays without support for iteratees.
|
||||
*
|
||||
* @private
|
||||
* @param {Array} array The array to iterate over.
|
||||
* @returns {*} Returns the minimum value.
|
||||
*/
|
||||
function arrayMin(array) {
|
||||
var index = -1,
|
||||
length = array.length,
|
||||
result = POSITIVE_INFINITY;
|
||||
|
||||
while (++index < length) {
|
||||
var value = array[index];
|
||||
if (value < result) {
|
||||
result = value;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
export default arrayMin;
|
||||
@@ -1,12 +1,5 @@
|
||||
import getSymbols from './getSymbols';
|
||||
import keys from '../object/keys';
|
||||
|
||||
/** Used for native method references. */
|
||||
var arrayProto = Array.prototype;
|
||||
|
||||
/** Native method references. */
|
||||
var push = arrayProto.push;
|
||||
|
||||
/**
|
||||
* A specialized version of `_.assign` for customizing assigned values without
|
||||
* support for argument juggling, multiple sources, and `this` binding `customizer`
|
||||
@@ -19,10 +12,8 @@ var push = arrayProto.push;
|
||||
* @returns {Object} Returns `object`.
|
||||
*/
|
||||
function assignWith(object, source, customizer) {
|
||||
var props = keys(source);
|
||||
push.apply(props, getSymbols(source));
|
||||
|
||||
var index = -1,
|
||||
props = keys(source),
|
||||
length = props.length;
|
||||
|
||||
while (++index < length) {
|
||||
|
||||
@@ -1,34 +1,6 @@
|
||||
import baseCopy from './baseCopy';
|
||||
import getSymbols from './getSymbols';
|
||||
import isNative from '../lang/isNative';
|
||||
import keys from '../object/keys';
|
||||
|
||||
/** Native method references. */
|
||||
var preventExtensions = isNative(preventExtensions = Object.preventExtensions) && preventExtensions;
|
||||
|
||||
/** Used as `baseAssign`. */
|
||||
var nativeAssign = (function() {
|
||||
// Avoid `Object.assign` in Firefox 34-37 which have an early implementation
|
||||
// with a now defunct try/catch behavior. See https://bugzilla.mozilla.org/show_bug.cgi?id=1103344
|
||||
// for more details.
|
||||
//
|
||||
// Use `Object.preventExtensions` on a plain object instead of simply using
|
||||
// `Object('x')` because Chrome and IE fail to throw an error when attempting
|
||||
// to assign values to readonly indexes of strings.
|
||||
var func = preventExtensions && isNative(func = Object.assign) && func;
|
||||
try {
|
||||
if (func) {
|
||||
var object = preventExtensions({ '1': 0 });
|
||||
object[0] = 1;
|
||||
}
|
||||
} catch(e) {
|
||||
// Only attempt in strict mode.
|
||||
try { func(object, 'xo'); } catch(e) {}
|
||||
return !object[1] && func;
|
||||
}
|
||||
return false;
|
||||
}());
|
||||
|
||||
/**
|
||||
* The base implementation of `_.assign` without support for argument juggling,
|
||||
* multiple sources, and `customizer` functions.
|
||||
@@ -38,10 +10,10 @@ var nativeAssign = (function() {
|
||||
* @param {Object} source The source object.
|
||||
* @returns {Object} Returns `object`.
|
||||
*/
|
||||
var baseAssign = nativeAssign || function(object, source) {
|
||||
function baseAssign(object, source) {
|
||||
return source == null
|
||||
? object
|
||||
: baseCopy(source, getSymbols(source), baseCopy(source, keys(source), object));
|
||||
};
|
||||
: baseCopy(source, keys(source), object);
|
||||
}
|
||||
|
||||
export default baseAssign;
|
||||
|
||||
@@ -14,7 +14,7 @@ function baseAt(collection, props) {
|
||||
var index = -1,
|
||||
isNil = collection == null,
|
||||
isArr = !isNil && isArrayLike(collection),
|
||||
length = isArr && collection.length,
|
||||
length = isArr ? collection.length : 0,
|
||||
propsLength = props.length,
|
||||
result = Array(propsLength);
|
||||
|
||||
|
||||
@@ -3,19 +3,28 @@
|
||||
* sorts them in ascending order without guaranteeing a stable sort.
|
||||
*
|
||||
* @private
|
||||
* @param {*} value The value to compare to `other`.
|
||||
* @param {*} other The value to compare to `value`.
|
||||
* @param {*} value The value to compare.
|
||||
* @param {*} other The other value to compare.
|
||||
* @returns {number} Returns the sort order indicator for `value`.
|
||||
*/
|
||||
function baseCompareAscending(value, other) {
|
||||
if (value !== other) {
|
||||
var valIsReflexive = value === value,
|
||||
var valIsNull = value === null,
|
||||
valIsUndef = value === undefined,
|
||||
valIsReflexive = value === value;
|
||||
|
||||
var othIsNull = other === null,
|
||||
othIsUndef = other === undefined,
|
||||
othIsReflexive = other === other;
|
||||
|
||||
if (value > other || !valIsReflexive || (value === undefined && othIsReflexive)) {
|
||||
if ((value > other && !othIsNull) || !valIsReflexive ||
|
||||
(valIsNull && !othIsUndef && othIsReflexive) ||
|
||||
(valIsUndef && othIsReflexive)) {
|
||||
return 1;
|
||||
}
|
||||
if (value < other || !othIsReflexive || (other === undefined && valIsReflexive)) {
|
||||
if ((value < other && !valIsNull) || !othIsReflexive ||
|
||||
(othIsNull && !valIsUndef && valIsReflexive) ||
|
||||
(othIsUndef && valIsReflexive)) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
import isObject from '../lang/isObject';
|
||||
import root from './root';
|
||||
|
||||
/**
|
||||
* The base implementation of `_.create` without support for assigning
|
||||
@@ -10,14 +9,14 @@ import root from './root';
|
||||
* @returns {Object} Returns the new object.
|
||||
*/
|
||||
var baseCreate = (function() {
|
||||
function Object() {}
|
||||
function object() {}
|
||||
return function(prototype) {
|
||||
if (isObject(prototype)) {
|
||||
Object.prototype = prototype;
|
||||
var result = new Object;
|
||||
Object.prototype = null;
|
||||
object.prototype = prototype;
|
||||
var result = new object;
|
||||
object.prototype = null;
|
||||
}
|
||||
return result || root.Object();
|
||||
return result || {};
|
||||
};
|
||||
}());
|
||||
|
||||
|
||||
@@ -1,30 +1,24 @@
|
||||
import baseEach from './baseEach';
|
||||
|
||||
/** Used as references for `-Infinity` and `Infinity`. */
|
||||
var NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY,
|
||||
POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
|
||||
|
||||
/**
|
||||
* Gets the extremum value of `collection` invoking `iteratee` for each value
|
||||
* in `collection` to generate the criterion by which the value is ranked.
|
||||
* The `iteratee` is invoked with three arguments: (value, index, collection).
|
||||
* The `iteratee` is invoked with three arguments: (value, index|key, collection).
|
||||
*
|
||||
* @private
|
||||
* @param {Array|Object|string} collection The collection to iterate over.
|
||||
* @param {Function} iteratee The function invoked per iteration.
|
||||
* @param {boolean} [isMin] Specify returning the minimum, instead of the
|
||||
* maximum, extremum value.
|
||||
* @param {Function} comparator The function used to compare values.
|
||||
* @param {*} exValue The initial extremum value.
|
||||
* @returns {*} Returns the extremum value.
|
||||
*/
|
||||
function extremumBy(collection, iteratee, isMin) {
|
||||
var exValue = isMin ? POSITIVE_INFINITY : NEGATIVE_INFINITY,
|
||||
computed = exValue,
|
||||
function baseExtremum(collection, iteratee, comparator, exValue) {
|
||||
var computed = exValue,
|
||||
result = computed;
|
||||
|
||||
baseEach(collection, function(value, index, collection) {
|
||||
var current = iteratee(value, index, collection);
|
||||
if ((isMin ? (current < computed) : (current > computed)) ||
|
||||
(current === exValue && current === result)) {
|
||||
var current = +iteratee(value, index, collection);
|
||||
if (comparator(current, computed) || (current === exValue && current === result)) {
|
||||
computed = current;
|
||||
result = value;
|
||||
}
|
||||
@@ -32,4 +26,4 @@ function extremumBy(collection, iteratee, isMin) {
|
||||
return result;
|
||||
}
|
||||
|
||||
export default extremumBy;
|
||||
export default baseExtremum;
|
||||
@@ -17,11 +17,11 @@ function baseGet(object, path, pathKey) {
|
||||
if (pathKey !== undefined && pathKey in toObject(object)) {
|
||||
path = [pathKey];
|
||||
}
|
||||
var index = -1,
|
||||
var index = 0,
|
||||
length = path.length;
|
||||
|
||||
while (object != null && ++index < length) {
|
||||
object = object[path[index]];
|
||||
while (object != null && index < length) {
|
||||
object = object[path[index++]];
|
||||
}
|
||||
return (index && index == length) ? object : undefined;
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import baseIsEqualDeep from './baseIsEqualDeep';
|
||||
import isObject from '../lang/isObject';
|
||||
|
||||
/**
|
||||
* The base implementation of `_.isEqual` without support for `this` binding
|
||||
@@ -14,17 +15,10 @@ import baseIsEqualDeep from './baseIsEqualDeep';
|
||||
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
||||
*/
|
||||
function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
|
||||
// Exit early for identical values.
|
||||
if (value === other) {
|
||||
return true;
|
||||
}
|
||||
var valType = typeof value,
|
||||
othType = typeof other;
|
||||
|
||||
// Exit early for unlike primitive values.
|
||||
if ((valType != 'function' && valType != 'object' && othType != 'function' && othType != 'object') ||
|
||||
value == null || other == null) {
|
||||
// Return `false` unless both values are `NaN`.
|
||||
if (value == null || other == null || (!isObject(value) && !isObject(other))) {
|
||||
return value !== value && other !== other;
|
||||
}
|
||||
return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);
|
||||
|
||||
@@ -66,11 +66,11 @@ function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA,
|
||||
return equalByTag(object, other, objTag);
|
||||
}
|
||||
if (!isLoose) {
|
||||
var valWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
|
||||
othWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
|
||||
var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
|
||||
othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
|
||||
|
||||
if (valWrapped || othWrapped) {
|
||||
return equalFunc(valWrapped ? object.value() : object, othWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
|
||||
if (objIsWrapped || othIsWrapped) {
|
||||
return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
|
||||
}
|
||||
}
|
||||
if (!isSameTag) {
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import baseIsEqual from './baseIsEqual';
|
||||
import toObject from './toObject';
|
||||
|
||||
/**
|
||||
* The base implementation of `_.isMatch` without support for callback
|
||||
@@ -6,41 +7,43 @@ import baseIsEqual from './baseIsEqual';
|
||||
*
|
||||
* @private
|
||||
* @param {Object} object The object to inspect.
|
||||
* @param {Array} props The source property names to match.
|
||||
* @param {Array} values The source values to match.
|
||||
* @param {Array} strictCompareFlags Strict comparison flags for source values.
|
||||
* @param {Array} matchData The propery names, values, and compare flags to match.
|
||||
* @param {Function} [customizer] The function to customize comparing objects.
|
||||
* @returns {boolean} Returns `true` if `object` is a match, else `false`.
|
||||
*/
|
||||
function baseIsMatch(object, props, values, strictCompareFlags, customizer) {
|
||||
var index = -1,
|
||||
length = props.length,
|
||||
function baseIsMatch(object, matchData, customizer) {
|
||||
var index = matchData.length,
|
||||
length = index,
|
||||
noCustomizer = !customizer;
|
||||
|
||||
while (++index < length) {
|
||||
if ((noCustomizer && strictCompareFlags[index])
|
||||
? values[index] !== object[props[index]]
|
||||
: !(props[index] in object)
|
||||
if (object == null) {
|
||||
return !length;
|
||||
}
|
||||
object = toObject(object);
|
||||
while (index--) {
|
||||
var data = matchData[index];
|
||||
if ((noCustomizer && data[2])
|
||||
? data[1] !== object[data[0]]
|
||||
: !(data[0] in object)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
index = -1;
|
||||
while (++index < length) {
|
||||
var key = props[index],
|
||||
data = matchData[index];
|
||||
var key = data[0],
|
||||
objValue = object[key],
|
||||
srcValue = values[index];
|
||||
srcValue = data[1];
|
||||
|
||||
if (noCustomizer && strictCompareFlags[index]) {
|
||||
var result = objValue !== undefined || (key in object);
|
||||
} else {
|
||||
result = customizer ? customizer(objValue, srcValue, key) : undefined;
|
||||
if (result === undefined) {
|
||||
result = baseIsEqual(srcValue, objValue, customizer, true);
|
||||
if (noCustomizer && data[2]) {
|
||||
if (objValue === undefined && !(key in object)) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
var result = customizer ? customizer(objValue, srcValue, key) : undefined;
|
||||
if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (!result) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
|
||||
@@ -1,7 +1,5 @@
|
||||
import baseIsMatch from './baseIsMatch';
|
||||
import constant from '../utility/constant';
|
||||
import isStrictComparable from './isStrictComparable';
|
||||
import keys from '../object/keys';
|
||||
import getMatchData from './getMatchData';
|
||||
import toObject from './toObject';
|
||||
|
||||
/**
|
||||
@@ -12,35 +10,20 @@ import toObject from './toObject';
|
||||
* @returns {Function} Returns the new function.
|
||||
*/
|
||||
function baseMatches(source) {
|
||||
var props = keys(source),
|
||||
length = props.length;
|
||||
var matchData = getMatchData(source);
|
||||
if (matchData.length == 1 && matchData[0][2]) {
|
||||
var key = matchData[0][0],
|
||||
value = matchData[0][1];
|
||||
|
||||
if (!length) {
|
||||
return constant(true);
|
||||
}
|
||||
if (length == 1) {
|
||||
var key = props[0],
|
||||
value = source[key];
|
||||
|
||||
if (isStrictComparable(value)) {
|
||||
return function(object) {
|
||||
if (object == null) {
|
||||
return false;
|
||||
}
|
||||
return object[key] === value && (value !== undefined || (key in toObject(object)));
|
||||
};
|
||||
}
|
||||
}
|
||||
var values = Array(length),
|
||||
strictCompareFlags = Array(length);
|
||||
|
||||
while (length--) {
|
||||
value = source[props[length]];
|
||||
values[length] = value;
|
||||
strictCompareFlags[length] = isStrictComparable(value);
|
||||
return function(object) {
|
||||
if (object == null) {
|
||||
return false;
|
||||
}
|
||||
return object[key] === value && (value !== undefined || (key in toObject(object)));
|
||||
};
|
||||
}
|
||||
return function(object) {
|
||||
return object != null && baseIsMatch(toObject(object), props, values, strictCompareFlags);
|
||||
return baseIsMatch(object, matchData);
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -14,12 +14,12 @@ import toPath from './toPath';
|
||||
*
|
||||
* @private
|
||||
* @param {string} path The path of the property to get.
|
||||
* @param {*} value The value to compare.
|
||||
* @param {*} srcValue The value to compare.
|
||||
* @returns {Function} Returns the new function.
|
||||
*/
|
||||
function baseMatchesProperty(path, value) {
|
||||
function baseMatchesProperty(path, srcValue) {
|
||||
var isArr = isArray(path),
|
||||
isCommon = isKey(path) && isStrictComparable(value),
|
||||
isCommon = isKey(path) && isStrictComparable(srcValue),
|
||||
pathKey = (path + '');
|
||||
|
||||
path = toPath(path);
|
||||
@@ -37,9 +37,9 @@ function baseMatchesProperty(path, value) {
|
||||
key = last(path);
|
||||
object = toObject(object);
|
||||
}
|
||||
return object[key] === value
|
||||
? (value !== undefined || (key in object))
|
||||
: baseIsEqual(value, object[key], null, true);
|
||||
return object[key] === srcValue
|
||||
? (srcValue !== undefined || (key in object))
|
||||
: baseIsEqual(srcValue, object[key], undefined, true);
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
import arrayEach from './arrayEach';
|
||||
import baseMergeDeep from './baseMergeDeep';
|
||||
import getSymbols from './getSymbols';
|
||||
import isArray from '../lang/isArray';
|
||||
import isArrayLike from './isArrayLike';
|
||||
import isObject from '../lang/isObject';
|
||||
@@ -8,12 +7,6 @@ import isObjectLike from './isObjectLike';
|
||||
import isTypedArray from '../lang/isTypedArray';
|
||||
import keys from '../object/keys';
|
||||
|
||||
/** Used for native method references. */
|
||||
var arrayProto = Array.prototype;
|
||||
|
||||
/** Native method references. */
|
||||
var push = arrayProto.push;
|
||||
|
||||
/**
|
||||
* The base implementation of `_.merge` without support for argument juggling,
|
||||
* multiple sources, and `this` binding `customizer` functions.
|
||||
@@ -30,11 +23,9 @@ function baseMerge(object, source, customizer, stackA, stackB) {
|
||||
if (!isObject(object)) {
|
||||
return object;
|
||||
}
|
||||
var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source));
|
||||
if (!isSrcArr) {
|
||||
var props = keys(source);
|
||||
push.apply(props, getSymbols(source));
|
||||
}
|
||||
var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source)),
|
||||
props = isSrcArr ? null : keys(source);
|
||||
|
||||
arrayEach(props || source, function(srcValue, key) {
|
||||
if (props) {
|
||||
key = srcValue;
|
||||
@@ -53,7 +44,7 @@ function baseMerge(object, source, customizer, stackA, stackB) {
|
||||
if (isCommon) {
|
||||
result = srcValue;
|
||||
}
|
||||
if ((isSrcArr || result !== undefined) &&
|
||||
if ((result !== undefined || (isSrcArr && !(key in object))) &&
|
||||
(isCommon || (result === result ? (result !== value) : (value === value)))) {
|
||||
object[key] = result;
|
||||
}
|
||||
|
||||
@@ -18,7 +18,7 @@ var splice = arrayProto.splice;
|
||||
function basePullAt(array, indexes) {
|
||||
var length = array ? indexes.length : 0;
|
||||
while (length--) {
|
||||
var index = parseFloat(indexes[length]);
|
||||
var index = indexes[length];
|
||||
if (index != previous && isIndex(index)) {
|
||||
var previous = index;
|
||||
splice.call(array, index, 1);
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/**
|
||||
* Converts `value` to a string if it is not one. An empty string is returned
|
||||
* Converts `value` to a string if it's not one. An empty string is returned
|
||||
* for `null` or `undefined` values.
|
||||
*
|
||||
* @private
|
||||
|
||||
@@ -2,7 +2,7 @@ import binaryIndexBy from './binaryIndexBy';
|
||||
import identity from '../utility/identity';
|
||||
|
||||
/** Used as references for the maximum length and index of an array. */
|
||||
var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1,
|
||||
var MAX_ARRAY_LENGTH = 4294967295,
|
||||
HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
|
||||
|
||||
/**
|
||||
@@ -25,7 +25,7 @@ function binaryIndex(array, value, retHighest) {
|
||||
var mid = (low + high) >>> 1,
|
||||
computed = array[mid];
|
||||
|
||||
if (retHighest ? (computed <= value) : (computed < value)) {
|
||||
if ((retHighest ? (computed <= value) : (computed < value)) && computed !== null) {
|
||||
low = mid + 1;
|
||||
} else {
|
||||
high = mid;
|
||||
|
||||
@@ -5,7 +5,7 @@ var floor = Math.floor;
|
||||
var nativeMin = Math.min;
|
||||
|
||||
/** Used as references for the maximum length and index of an array. */
|
||||
var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1,
|
||||
var MAX_ARRAY_LENGTH = 4294967295,
|
||||
MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
|
||||
|
||||
/**
|
||||
@@ -27,17 +27,23 @@ function binaryIndexBy(array, value, iteratee, retHighest) {
|
||||
var low = 0,
|
||||
high = array ? array.length : 0,
|
||||
valIsNaN = value !== value,
|
||||
valIsNull = value === null,
|
||||
valIsUndef = value === undefined;
|
||||
|
||||
while (low < high) {
|
||||
var mid = floor((low + high) / 2),
|
||||
computed = iteratee(array[mid]),
|
||||
isDef = computed !== undefined,
|
||||
isReflexive = computed === computed;
|
||||
|
||||
if (valIsNaN) {
|
||||
var setLow = isReflexive || retHighest;
|
||||
} else if (valIsNull) {
|
||||
setLow = isReflexive && isDef && (retHighest || computed != null);
|
||||
} else if (valIsUndef) {
|
||||
setLow = isReflexive && (retHighest || computed !== undefined);
|
||||
setLow = isReflexive && (retHighest || isDef);
|
||||
} else if (computed == null) {
|
||||
setLow = false;
|
||||
} else {
|
||||
setLow = retHighest ? (computed <= value) : (computed < value);
|
||||
}
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
import constant from '../utility/constant';
|
||||
import isNative from '../lang/isNative';
|
||||
import getNative from './getNative';
|
||||
import root from './root';
|
||||
|
||||
/** Native method references. */
|
||||
var ArrayBuffer = isNative(ArrayBuffer = root.ArrayBuffer) && ArrayBuffer,
|
||||
bufferSlice = isNative(bufferSlice = ArrayBuffer && new ArrayBuffer(0).slice) && bufferSlice,
|
||||
var ArrayBuffer = getNative(root, 'ArrayBuffer'),
|
||||
bufferSlice = getNative(ArrayBuffer && new ArrayBuffer(0), 'slice'),
|
||||
floor = Math.floor,
|
||||
Uint8Array = isNative(Uint8Array = root.Uint8Array) && Uint8Array;
|
||||
Uint8Array = getNative(root, 'Uint8Array');
|
||||
|
||||
/** Used to clone array buffers. */
|
||||
var Float64Array = (function() {
|
||||
@@ -14,10 +14,10 @@ var Float64Array = (function() {
|
||||
// where the array buffer's `byteLength` is not a multiple of the typed
|
||||
// array's `BYTES_PER_ELEMENT`.
|
||||
try {
|
||||
var func = isNative(func = root.Float64Array) && func,
|
||||
var func = getNative(root, 'Float64Array'),
|
||||
result = new func(new ArrayBuffer(10), 0, 1) && func;
|
||||
} catch(e) {}
|
||||
return result;
|
||||
return result || null;
|
||||
}());
|
||||
|
||||
/** Used as the size, in bytes, of each `Float64Array` element. */
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
/**
|
||||
* Used by `_.max` and `_.min` as the default callback for string values.
|
||||
*
|
||||
* @private
|
||||
* @param {string} string The string to inspect.
|
||||
* @returns {number} Returns the code unit of the first character of the string.
|
||||
*/
|
||||
function charAtCallback(string) {
|
||||
return string.charCodeAt(0);
|
||||
}
|
||||
|
||||
export default charAtCallback;
|
||||
@@ -16,19 +16,19 @@ function createAssigner(assigner) {
|
||||
return restParam(function(object, sources) {
|
||||
var index = -1,
|
||||
length = object == null ? 0 : sources.length,
|
||||
customizer = length > 2 && sources[length - 2],
|
||||
guard = length > 2 && sources[2],
|
||||
thisArg = length > 1 && sources[length - 1];
|
||||
customizer = length > 2 ? sources[length - 2] : undefined,
|
||||
guard = length > 2 ? sources[2] : undefined,
|
||||
thisArg = length > 1 ? sources[length - 1] : undefined;
|
||||
|
||||
if (typeof customizer == 'function') {
|
||||
customizer = bindCallback(customizer, thisArg, 5);
|
||||
length -= 2;
|
||||
} else {
|
||||
customizer = typeof thisArg == 'function' ? thisArg : null;
|
||||
customizer = typeof thisArg == 'function' ? thisArg : undefined;
|
||||
length -= (customizer ? 1 : 0);
|
||||
}
|
||||
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
||||
customizer = length < 3 ? null : customizer;
|
||||
customizer = length < 3 ? undefined : customizer;
|
||||
length = 1;
|
||||
}
|
||||
while (++index < length) {
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
import SetCache from './SetCache';
|
||||
import constant from '../utility/constant';
|
||||
import isNative from '../lang/isNative';
|
||||
import getNative from './getNative';
|
||||
import root from './root';
|
||||
|
||||
/** Native method references. */
|
||||
var Set = isNative(Set = root.Set) && Set;
|
||||
var Set = getNative(root, 'Set');
|
||||
|
||||
/* Native method references for those with the same name as other `lodash` methods. */
|
||||
var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate;
|
||||
var nativeCreate = getNative(Object, 'create');
|
||||
|
||||
/**
|
||||
* Creates a `Set` cache object to optimize linear searches of large arrays.
|
||||
|
||||
@@ -11,8 +11,20 @@ import isObject from '../lang/isObject';
|
||||
*/
|
||||
function createCtorWrapper(Ctor) {
|
||||
return function() {
|
||||
// Use a `switch` statement to work with class constructors.
|
||||
// See https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-function-objects-call-thisargument-argumentslist
|
||||
// for more details.
|
||||
var args = arguments;
|
||||
switch (args.length) {
|
||||
case 0: return new Ctor;
|
||||
case 1: return new Ctor(args[0]);
|
||||
case 2: return new Ctor(args[0], args[1]);
|
||||
case 3: return new Ctor(args[0], args[1], args[2]);
|
||||
case 4: return new Ctor(args[0], args[1], args[2], args[3]);
|
||||
case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
|
||||
}
|
||||
var thisBinding = baseCreate(Ctor.prototype),
|
||||
result = Ctor.apply(thisBinding, arguments);
|
||||
result = Ctor.apply(thisBinding, args);
|
||||
|
||||
// Mimic the constructor's `return` behavior.
|
||||
// See https://es5.github.io/#x13.2.2 for more details.
|
||||
|
||||
@@ -1,37 +1,31 @@
|
||||
import arrayExtremum from './arrayExtremum';
|
||||
import baseCallback from './baseCallback';
|
||||
import charAtCallback from './charAtCallback';
|
||||
import extremumBy from './extremumBy';
|
||||
import isArray from '../lang/isArray';
|
||||
import baseExtremum from './baseExtremum';
|
||||
import isIterateeCall from './isIterateeCall';
|
||||
import isString from '../lang/isString';
|
||||
import toIterable from './toIterable';
|
||||
|
||||
/**
|
||||
* Creates a `_.max` or `_.min` function.
|
||||
*
|
||||
* @private
|
||||
* @param {Function} arrayFunc The function to get the extremum value from an array.
|
||||
* @param {boolean} [isMin] Specify returning the minimum, instead of the maximum,
|
||||
* extremum value.
|
||||
* @param {Function} comparator The function used to compare values.
|
||||
* @param {*} exValue The initial extremum value.
|
||||
* @returns {Function} Returns the new extremum function.
|
||||
*/
|
||||
function createExtremum(arrayFunc, isMin) {
|
||||
function createExtremum(comparator, exValue) {
|
||||
return function(collection, iteratee, thisArg) {
|
||||
if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {
|
||||
iteratee = null;
|
||||
}
|
||||
var noIteratee = iteratee == null;
|
||||
|
||||
iteratee = noIteratee ? iteratee : baseCallback(iteratee, thisArg, 3);
|
||||
if (noIteratee) {
|
||||
var isArr = isArray(collection);
|
||||
if (!isArr && isString(collection)) {
|
||||
iteratee = charAtCallback;
|
||||
} else {
|
||||
return arrayFunc(isArr ? collection : toIterable(collection));
|
||||
iteratee = baseCallback(iteratee, thisArg, 3);
|
||||
if (iteratee.length == 1) {
|
||||
collection = toIterable(collection);
|
||||
var result = arrayExtremum(collection, iteratee, comparator, exValue);
|
||||
if (!(collection.length && result === exValue)) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return extremumBy(collection, iteratee, isMin);
|
||||
return baseExtremum(collection, iteratee, comparator, exValue);
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -22,11 +22,8 @@ var FUNC_ERROR_TEXT = 'Expected a function';
|
||||
*/
|
||||
function createFlow(fromRight) {
|
||||
return function() {
|
||||
var length = arguments.length;
|
||||
if (!length) {
|
||||
return function() { return arguments[0]; };
|
||||
}
|
||||
var wrapper,
|
||||
length = arguments.length,
|
||||
index = fromRight ? length : -1,
|
||||
leftIndex = 0,
|
||||
funcs = Array(length);
|
||||
@@ -36,15 +33,17 @@ function createFlow(fromRight) {
|
||||
if (typeof func != 'function') {
|
||||
throw new TypeError(FUNC_ERROR_TEXT);
|
||||
}
|
||||
var funcName = wrapper ? '' : getFuncName(func);
|
||||
wrapper = funcName == 'wrapper' ? new LodashWrapper([]) : wrapper;
|
||||
if (!wrapper && LodashWrapper.prototype.thru && getFuncName(func) == 'wrapper') {
|
||||
wrapper = new LodashWrapper([]);
|
||||
}
|
||||
}
|
||||
index = wrapper ? -1 : length;
|
||||
while (++index < length) {
|
||||
func = funcs[index];
|
||||
funcName = getFuncName(func);
|
||||
|
||||
var data = funcName == 'wrapper' ? getData(func) : null;
|
||||
var funcName = getFuncName(func),
|
||||
data = funcName == 'wrapper' ? getData(func) : null;
|
||||
|
||||
if (data && isLaziable(data[0]) && data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) && !data[4].length && data[9] == 1) {
|
||||
wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
|
||||
} else {
|
||||
@@ -57,7 +56,7 @@ function createFlow(fromRight) {
|
||||
return wrapper.plant(args[0]).value();
|
||||
}
|
||||
var index = 0,
|
||||
result = funcs[index].apply(this, args);
|
||||
result = length ? funcs[index].apply(this, args) : args[0];
|
||||
|
||||
while (++index < length) {
|
||||
result = funcs[index].call(this, result);
|
||||
|
||||
@@ -44,10 +44,8 @@ function createHybridWrapper(func, bitmask, thisArg, partials, holders, partials
|
||||
isBindKey = bitmask & BIND_KEY_FLAG,
|
||||
isCurry = bitmask & CURRY_FLAG,
|
||||
isCurryBound = bitmask & CURRY_BOUND_FLAG,
|
||||
isCurryRight = bitmask & CURRY_RIGHT_FLAG;
|
||||
|
||||
var Ctor = !isBindKey && createCtorWrapper(func),
|
||||
key = func;
|
||||
isCurryRight = bitmask & CURRY_RIGHT_FLAG,
|
||||
Ctor = isBindKey ? null : createCtorWrapper(func);
|
||||
|
||||
function wrapper() {
|
||||
// Avoid `arguments` object use disqualifying optimizations by
|
||||
@@ -94,17 +92,18 @@ function createHybridWrapper(func, bitmask, thisArg, partials, holders, partials
|
||||
return result;
|
||||
}
|
||||
}
|
||||
var thisBinding = isBind ? thisArg : this;
|
||||
if (isBindKey) {
|
||||
func = thisBinding[key];
|
||||
}
|
||||
var thisBinding = isBind ? thisArg : this,
|
||||
fn = isBindKey ? thisBinding[func] : func;
|
||||
|
||||
if (argPos) {
|
||||
args = reorder(args, argPos);
|
||||
}
|
||||
if (isAry && ary < args.length) {
|
||||
args.length = ary;
|
||||
}
|
||||
var fn = (this && this !== root && this instanceof wrapper) ? (Ctor || createCtorWrapper(func)) : func;
|
||||
if (this && this !== root && this instanceof wrapper) {
|
||||
fn = Ctor || createCtorWrapper(func);
|
||||
}
|
||||
return fn.apply(thisBinding, args);
|
||||
}
|
||||
return wrapper;
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
import arraySome from './arraySome';
|
||||
|
||||
/**
|
||||
* A specialized version of `baseIsEqualDeep` for arrays with support for
|
||||
* partial deep comparisons.
|
||||
@@ -15,40 +17,35 @@
|
||||
function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
||||
var index = -1,
|
||||
arrLength = array.length,
|
||||
othLength = other.length,
|
||||
result = true;
|
||||
othLength = other.length;
|
||||
|
||||
if (arrLength != othLength && !(isLoose && othLength > arrLength)) {
|
||||
return false;
|
||||
}
|
||||
// Deep compare the contents, ignoring non-numeric properties.
|
||||
while (result && ++index < arrLength) {
|
||||
// Ignore non-index properties.
|
||||
while (++index < arrLength) {
|
||||
var arrValue = array[index],
|
||||
othValue = other[index];
|
||||
othValue = other[index],
|
||||
result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;
|
||||
|
||||
result = undefined;
|
||||
if (customizer) {
|
||||
result = isLoose
|
||||
? customizer(othValue, arrValue, index)
|
||||
: customizer(arrValue, othValue, index);
|
||||
}
|
||||
if (result === undefined) {
|
||||
// Recursively compare arrays (susceptible to call stack limits).
|
||||
if (isLoose) {
|
||||
var othIndex = othLength;
|
||||
while (othIndex--) {
|
||||
othValue = other[othIndex];
|
||||
result = (arrValue && arrValue === othValue) || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
|
||||
if (result) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
result = (arrValue && arrValue === othValue) || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
|
||||
if (result !== undefined) {
|
||||
if (result) {
|
||||
continue;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
// Recursively compare arrays (susceptible to call stack limits).
|
||||
if (isLoose) {
|
||||
if (!arraySome(other, function(othValue) {
|
||||
return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
|
||||
})) {
|
||||
return false;
|
||||
}
|
||||
} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return !!result;
|
||||
return true;
|
||||
}
|
||||
|
||||
export default equalArrays;
|
||||
|
||||
@@ -29,29 +29,22 @@ function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, sta
|
||||
if (objLength != othLength && !isLoose) {
|
||||
return false;
|
||||
}
|
||||
var skipCtor = isLoose,
|
||||
index = -1;
|
||||
|
||||
while (++index < objLength) {
|
||||
var key = objProps[index],
|
||||
result = isLoose ? key in other : hasOwnProperty.call(other, key);
|
||||
|
||||
if (result) {
|
||||
var objValue = object[key],
|
||||
othValue = other[key];
|
||||
|
||||
result = undefined;
|
||||
if (customizer) {
|
||||
result = isLoose
|
||||
? customizer(othValue, objValue, key)
|
||||
: customizer(objValue, othValue, key);
|
||||
}
|
||||
if (result === undefined) {
|
||||
// Recursively compare objects (susceptible to call stack limits).
|
||||
result = (objValue && objValue === othValue) || equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB);
|
||||
}
|
||||
var index = objLength;
|
||||
while (index--) {
|
||||
var key = objProps[index];
|
||||
if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {
|
||||
return false;
|
||||
}
|
||||
if (!result) {
|
||||
}
|
||||
var skipCtor = isLoose;
|
||||
while (++index < objLength) {
|
||||
key = objProps[index];
|
||||
var objValue = object[key],
|
||||
othValue = other[key],
|
||||
result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;
|
||||
|
||||
// Recursively compare objects (susceptible to call stack limits).
|
||||
if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {
|
||||
return false;
|
||||
}
|
||||
skipCtor || (skipCtor = key == 'constructor');
|
||||
|
||||
@@ -1,7 +1,4 @@
|
||||
import baseProperty from './baseProperty';
|
||||
import constant from '../utility/constant';
|
||||
import realNames from './realNames';
|
||||
import support from '../support';
|
||||
|
||||
/**
|
||||
* Gets the name of `func`.
|
||||
@@ -10,28 +7,19 @@ import support from '../support';
|
||||
* @param {Function} func The function to query.
|
||||
* @returns {string} Returns the function name.
|
||||
*/
|
||||
var getFuncName = (function() {
|
||||
if (!support.funcNames) {
|
||||
return constant('');
|
||||
}
|
||||
if (constant.name == 'constant') {
|
||||
return baseProperty('name');
|
||||
}
|
||||
return function(func) {
|
||||
var result = func.name,
|
||||
array = realNames[result],
|
||||
length = array ? array.length : 0;
|
||||
function getFuncName(func) {
|
||||
var result = func.name,
|
||||
array = realNames[result],
|
||||
length = array ? array.length : 0;
|
||||
|
||||
while (length--) {
|
||||
var data = array[length],
|
||||
otherFunc = data.func;
|
||||
|
||||
if (otherFunc == null || otherFunc == func) {
|
||||
return data.name;
|
||||
}
|
||||
while (length--) {
|
||||
var data = array[length],
|
||||
otherFunc = data.func;
|
||||
if (otherFunc == null || otherFunc == func) {
|
||||
return data.name;
|
||||
}
|
||||
return result;
|
||||
};
|
||||
}());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
export default getFuncName;
|
||||
|
||||
21
internal/getMatchData.js
Normal file
21
internal/getMatchData.js
Normal file
@@ -0,0 +1,21 @@
|
||||
import isStrictComparable from './isStrictComparable';
|
||||
import pairs from '../object/pairs';
|
||||
|
||||
/**
|
||||
* Gets the propery names, values, and compare flags of `object`.
|
||||
*
|
||||
* @private
|
||||
* @param {Object} object The object to query.
|
||||
* @returns {Array} Returns the match data of `object`.
|
||||
*/
|
||||
function getMatchData(object) {
|
||||
var result = pairs(object),
|
||||
length = result.length;
|
||||
|
||||
while (length--) {
|
||||
result[length][2] = isStrictComparable(result[length][1]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
export default getMatchData;
|
||||
16
internal/getNative.js
Normal file
16
internal/getNative.js
Normal file
@@ -0,0 +1,16 @@
|
||||
import isNative from '../lang/isNative';
|
||||
|
||||
/**
|
||||
* Gets the native function at `key` of `object`.
|
||||
*
|
||||
* @private
|
||||
* @param {Object} object The object to query.
|
||||
* @param {string} key The key of the method to get.
|
||||
* @returns {*} Returns the function if it's native, else `undefined`.
|
||||
*/
|
||||
function getNative(object, key) {
|
||||
var value = object == null ? undefined : object[key];
|
||||
return isNative(value) ? value : undefined;
|
||||
}
|
||||
|
||||
export default getNative;
|
||||
@@ -1,19 +0,0 @@
|
||||
import constant from '../utility/constant';
|
||||
import isNative from '../lang/isNative';
|
||||
import toObject from './toObject';
|
||||
|
||||
/** Native method references. */
|
||||
var getOwnPropertySymbols = isNative(getOwnPropertySymbols = Object.getOwnPropertySymbols) && getOwnPropertySymbols;
|
||||
|
||||
/**
|
||||
* Creates an array of the own symbols of `object`.
|
||||
*
|
||||
* @private
|
||||
* @param {Object} object The object to query.
|
||||
* @returns {Array} Returns the array of symbols.
|
||||
*/
|
||||
var getSymbols = !getOwnPropertySymbols ? constant([]) : function(object) {
|
||||
return getOwnPropertySymbols(toObject(object));
|
||||
};
|
||||
|
||||
export default getSymbols;
|
||||
@@ -2,7 +2,7 @@
|
||||
* Used as the [maximum length](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer)
|
||||
* of an array-like value.
|
||||
*/
|
||||
var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
|
||||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||||
|
||||
/**
|
||||
* Checks if `value` is a valid array-like index.
|
||||
@@ -13,7 +13,7 @@ var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
|
||||
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
|
||||
*/
|
||||
function isIndex(value, length) {
|
||||
value = +value;
|
||||
value = typeof value == 'number' ? value : parseFloat(value);
|
||||
length = length == null ? MAX_SAFE_INTEGER : length;
|
||||
return value > -1 && value % 1 == 0 && value < length;
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
* Used as the [maximum length](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer)
|
||||
* of an array-like value.
|
||||
*/
|
||||
var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
|
||||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||||
|
||||
/**
|
||||
* Checks if `value` is a valid array-like length.
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
import isNative from '../lang/isNative';
|
||||
import getNative from './getNative';
|
||||
import root from './root';
|
||||
|
||||
/** Native method references. */
|
||||
var WeakMap = isNative(WeakMap = root.WeakMap) && WeakMap;
|
||||
var WeakMap = getNative(root, 'WeakMap');
|
||||
|
||||
/** Used to store function metadata. */
|
||||
var metaMap = WeakMap && new WeakMap;
|
||||
|
||||
@@ -22,7 +22,7 @@ var freeWindow = objectTypes[typeof window] && window && window.Object && window
|
||||
/**
|
||||
* Used as a reference to the global object.
|
||||
*
|
||||
* The `this` value is used if it is the global object to avoid Greasemonkey's
|
||||
* The `this` value is used if it's the global object to avoid Greasemonkey's
|
||||
* restricted `window` object, otherwise the `window` object is used.
|
||||
*/
|
||||
var root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || freeSelf || this;
|
||||
|
||||
@@ -3,7 +3,6 @@ import isArray from '../lang/isArray';
|
||||
import isIndex from './isIndex';
|
||||
import isLength from './isLength';
|
||||
import keysIn from '../object/keysIn';
|
||||
import support from '../support';
|
||||
|
||||
/** Used for native method references. */
|
||||
var objectProto = Object.prototype;
|
||||
@@ -24,8 +23,8 @@ function shimKeys(object) {
|
||||
propsLength = props.length,
|
||||
length = propsLength && object.length;
|
||||
|
||||
var allowIndexes = length && isLength(length) &&
|
||||
(isArray(object) || (support.nonEnumArgs && isArguments(object)));
|
||||
var allowIndexes = !!length && isLength(length) &&
|
||||
(isArray(object) || isArguments(object));
|
||||
|
||||
var index = -1,
|
||||
result = [];
|
||||
|
||||
@@ -3,7 +3,7 @@ import isObject from '../lang/isObject';
|
||||
import values from '../object/values';
|
||||
|
||||
/**
|
||||
* Converts `value` to an array-like object if it is not one.
|
||||
* Converts `value` to an array-like object if it's not one.
|
||||
*
|
||||
* @private
|
||||
* @param {*} value The value to process.
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import isObject from '../lang/isObject';
|
||||
|
||||
/**
|
||||
* Converts `value` to an object if it is not one.
|
||||
* Converts `value` to an object if it's not one.
|
||||
*
|
||||
* @private
|
||||
* @param {*} value The value to process.
|
||||
|
||||
@@ -8,7 +8,7 @@ var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?
|
||||
var reEscapeChar = /\\(\\)?/g;
|
||||
|
||||
/**
|
||||
* Converts `value` to property path array if it is not one.
|
||||
* Converts `value` to property path array if it's not one.
|
||||
*
|
||||
* @private
|
||||
* @param {*} value The value to process.
|
||||
|
||||
Reference in New Issue
Block a user