Lines Matching refs:value
496 var value = array[index];
497 setter(accumulator, value, iteratee(value), array);
581 var value = array[index];
582 if (predicate(value, index, array)) {
583 result[resIndex++] = value;
598 function arrayIncludes(array, value) { argument
600 return !!length && baseIndexOf(array, value, 0) > -1;
612 function arrayIncludesWith(array, value, comparator) { argument
617 if (comparator(value, array[index])) {
777 eachFunc(collection, function(value, key, collection) { argument
778 if (predicate(value, key, collection)) {
818 function baseIndexOf(array, value, fromIndex) { argument
819 return value === value
820 ? strictIndexOf(array, value, fromIndex)
834 function baseIndexOfWith(array, value, fromIndex, comparator) { argument
839 if (comparator(array[index], value)) {
853 function baseIsNaN(value) { argument
854 return value !== value;
911 eachFunc(collection, function(value, index, collection) { argument
913 ? (initAccum = false, value)
914 : iteratee(accumulator, value, index, collection);
934 array[length] = array[length].value;
1004 return function(value) { argument
1005 return func(value);
1166 result.push(data.value);
1182 map.forEach(function(value, key) { argument
1183 result[++index] = [key, value];
1218 var value = array[index];
1219 if (value === placeholder || value === PLACEHOLDER) {
1238 set.forEach(function(value) { argument
1239 result[++index] = value;
1255 set.forEach(function(value) { argument
1256 result[++index] = [value, value];
1271 function strictIndexOf(array, value, fromIndex) { argument
1276 if (array[index] === value) {
1293 function strictLastIndexOf(array, value, fromIndex) { argument
1296 if (array[index] === value) {
1648 function lodash(value) { argument
1649 if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
1650 if (value instanceof LodashWrapper) {
1651 return value;
1653 if (hasOwnProperty.call(value, '__wrapped__')) {
1654 return wrapperClone(value);
1657 return new LodashWrapper(value);
1700 function LodashWrapper(value, chainAll) { argument
1701 this.__wrapped__ = value;
1785 function LazyWrapper(value) { argument
1786 this.__wrapped__ = value;
1843 var array = this.__wrapped__.value(),
1868 value = array[index];
1874 computed = iteratee(value);
1877 value = computed;
1886 result[resIndex++] = value;
1985 function hashSet(key, value) { argument
1988 data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
2096 function listCacheSet(key, value) { argument
2102 data.push([key, value]);
2104 data[index][1] = value;
2203 function mapCacheSet(key, value) { argument
2207 data.set(key, value);
2249 function setCacheAdd(value) { argument
2250 this.__data__.set(value, HASH_UNDEFINED);
2263 function setCacheHas(value) { argument
2264 return this.__data__.has(value);
2350 function stackSet(key, value) { argument
2355 pairs.push([key, value]);
2361 data.set(key, value);
2383 function arrayLikeKeys(value, inherited) { argument
2384 var isArr = isArray(value),
2385 isArg = !isArr && isArguments(value),
2386 isBuff = !isArr && !isArg && isBuffer(value),
2387 isType = !isArr && !isArg && !isBuff && isTypedArray(value),
2389 result = skipIndexes ? baseTimes(value.length, String) : [],
2392 for (var key in value) {
2393 if ((inherited || hasOwnProperty.call(value, key)) &&
2454 function assignMergeValue(object, key, value) { argument
2455 if ((value !== undefined && !eq(object[key], value)) ||
2456 (value === undefined && !(key in object))) {
2457 baseAssignValue(object, key, value);
2471 function assignValue(object, key, value) { argument
2473 if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
2474 (value === undefined && !(key in object))) {
2475 baseAssignValue(object, key, value);
2509 baseEach(collection, function(value, key, collection) { argument
2510 setter(accumulator, value, iteratee(value), collection);
2550 function baseAssignValue(object, key, value) { argument
2555 'value': value,
2559 object[key] = value;
2620 function baseClone(value, bitmask, customizer, key, object, stack) { argument
2627 result = object ? customizer(value, key, object, stack) : customizer(value);
2632 if (!isObject(value)) {
2633 return value;
2635 var isArr = isArray(value);
2637 result = initCloneArray(value);
2639 return copyArray(value, result);
2642 var tag = getTag(value),
2645 if (isBuffer(value)) {
2646 return cloneBuffer(value, isDeep);
2649 result = (isFlat || isFunc) ? {} : initCloneObject(value);
2652 ? copySymbolsIn(value, baseAssignIn(result, value))
2653 : copySymbols(value, baseAssign(result, value));
2657 return object ? value : {};
2659 result = initCloneByTag(value, tag, isDeep);
2664 var stacked = stack.get(value);
2668 stack.set(value, result);
2670 if (isSet(value)) {
2671 value.forEach(function(subValue) {
2672 result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
2674 } else if (isMap(value)) {
2675 value.forEach(function(subValue, key) {
2676 result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
2684 var props = isArr ? undefined : keysFunc(value);
2685 arrayEach(props || value, function(subValue, key) {
2688 subValue = value[key];
2691 assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
2727 value = object[key];
2729 if ((value === undefined && !(key in object)) || !predicate(value)) {
2789 var value = array[index],
2790 computed = iteratee == null ? value : iteratee(value);
2792 value = (comparator || value !== 0) ? value : 0;
2800 result.push(value);
2803 result.push(value);
2840 baseEach(collection, function(value, index, collection) { argument
2841 result = !!predicate(value, index, collection);
2862 var value = array[index],
2863 current = iteratee(value);
2870 result = value;
2886 function baseFill(array, value, start, end) { argument
2899 array[start++] = value;
2914 baseEach(collection, function(value, index, collection) { argument
2915 if (predicate(value, index, collection)) {
2916 result.push(value);
2941 var value = array[index];
2942 if (depth > 0 && predicate(value)) {
2945 baseFlatten(value, depth - 1, predicate, isStrict, result);
2947 arrayPush(result, value);
2950 result[result.length] = value;
3063 function baseGetTag(value) { argument
3064 if (value == null) {
3065 return value === undefined ? undefinedTag : nullTag;
3067 return (symToStringTag && symToStringTag in Object(value))
3068 ? getRawTag(value)
3069 : objectToString(value);
3081 function baseGt(value, other) { argument
3082 return value > other;
3158 var value = array[index],
3159 computed = iteratee ? iteratee(value) : value;
3161 value = (comparator || value !== 0) ? value : 0;
3179 result.push(value);
3197 baseForOwn(object, function(value, key, object) { argument
3198 setter(accumulator, iteratee(value), key, object);
3227 function baseIsArguments(value) { argument
3228 return isObjectLike(value) && baseGetTag(value) == argsTag;
3238 function baseIsArrayBuffer(value) { argument
3239 return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
3249 function baseIsDate(value) { argument
3250 return isObjectLike(value) && baseGetTag(value) == dateTag;
3267 function baseIsEqual(value, other, bitmask, customizer, stack) { argument
3268 if (value === other) {
3271 if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
3272 return value !== value && other !== other;
3274 return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
3322 var objUnwrapped = objIsWrapped ? object.value() : object,
3323 othUnwrapped = othIsWrapped ? other.value() : other;
3343 function baseIsMap(value) { argument
3344 return isObjectLike(value) && getTag(value) == mapTag;
3409 function baseIsNative(value) { argument
3410 if (!isObject(value) || isMasked(value)) {
3413 var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
3414 return pattern.test(toSource(value));
3424 function baseIsRegExp(value) { argument
3425 return isObjectLike(value) && baseGetTag(value) == regexpTag;
3435 function baseIsSet(value) { argument
3436 return isObjectLike(value) && getTag(value) == setTag;
3446 function baseIsTypedArray(value) { argument
3447 return isObjectLike(value) &&
3448 isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
3458 function baseIteratee(value) { argument
3461 if (typeof value == 'function') {
3462 return value;
3464 if (value == null) {
3467 if (typeof value == 'object') {
3468 return isArray(value)
3469 ? baseMatchesProperty(value[0], value[1])
3470 : baseMatches(value);
3472 return property(value);
3526 function baseLt(value, other) { argument
3527 return value < other;
3542 baseEach(collection, function(value, key, collection) { argument
3543 result[++index] = iteratee(value, key, collection);
3725 var result = baseMap(collection, function(value, key, collection) { argument
3727 return iteratee(value);
3729 return { 'criteria': criteria, 'index': ++index, 'value': value };
3747 return basePickBy(object, paths, function(value, path) { argument
3768 value = baseGet(object, path);
3770 if (predicate(value, path)) {
3771 baseSet(result, castPath(path, object), value);
3815 value = values[index],
3816 computed = iteratee ? iteratee(value) : value;
3965 function baseSet(object, path, value, customizer) { argument
3978 newValue = value;
4078 baseEach(collection, function(value, index, collection) { argument
4079 result = predicate(value, index, collection);
4097 function baseSortedIndex(array, value, retHighest) { argument
4101 if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
4107 (retHighest ? (computed <= value) : (computed < value))) {
4115 return baseSortedIndexBy(array, value, identity, retHighest);
4131 function baseSortedIndexBy(array, value, iteratee, retHighest) { argument
4132 value = iteratee(value);
4136 valIsNaN = value !== value,
4137 valIsNull = value === null,
4138 valIsSymbol = isSymbol(value),
4139 valIsUndefined = value === undefined;
4160 setLow = retHighest ? (computed <= value) : (computed < value);
4187 var value = array[index],
4188 computed = iteratee ? iteratee(value) : value;
4192 result[resIndex++] = value === 0 ? 0 : value;
4206 function baseToNumber(value) { argument
4207 if (typeof value == 'number') {
4208 return value;
4210 if (isSymbol(value)) {
4213 return +value;
4224 function baseToString(value) { argument
4226 if (typeof value == 'string') {
4227 return value;
4229 if (isArray(value)) {
4231 return arrayMap(value, baseToString) + '';
4233 if (isSymbol(value)) {
4234 return symbolToString ? symbolToString.call(value) : '';
4236 var result = (value + '');
4237 return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
4275 var value = array[index],
4276 computed = iteratee ? iteratee(value) : value;
4278 value = (comparator || value !== 0) ? value : 0;
4289 result.push(value);
4295 result.push(value);
4362 function baseWrapperValue(value, actions) { argument
4363 var result = value;
4365 result = result.value();
4419 var value = index < valsLength ? values[index] : undefined;
4420 assignFunc(result, props[index], value);
4432 function castArrayLikeObject(value) { argument
4433 return isArrayLikeObject(value) ? value : [];
4443 function castFunction(value) { argument
4444 return typeof value == 'function' ? value : identity;
4455 function castPath(value, object) { argument
4456 if (isArray(value)) {
4457 return value;
4459 return isKey(value, object) ? [value] : stringToPath(toString(value));
4588 function compareAscending(value, other) { argument
4589 if (value !== other) {
4590 var valIsDefined = value !== undefined,
4591 valIsNull = value === null,
4592 valIsReflexive = value === value,
4593 valIsSymbol = isSymbol(value);
4600 if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
4607 if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
5109 value = args[0];
5111 if (wrapper && args.length == 1 && isArray(value)) {
5112 return wrapper.plant(value).value();
5115 result = length ? funcs[index].apply(this, args) : value;
5221 return function(value, other) { argument
5223 if (value === undefined && other === undefined) {
5226 if (value !== undefined) {
5227 result = value;
5233 if (typeof value == 'string' || typeof other == 'string') {
5234 value = baseToString(value);
5237 value = baseToNumber(value);
5240 result = operator(value, other);
5355 return function(value, other) { argument
5356 if (!(typeof value == 'string' && typeof other == 'string')) {
5357 value = toNumber(value);
5360 return operator(value, other);
5423 value = func(pair[0] + 'e' + (+pair[1] + precision));
5425 pair = (toString(value) + 'e').split('e');
5596 function customOmitClone(value) { argument
5597 return isPlainObject(value) ? undefined : value;
5957 value = object[key];
5959 result[length] = [key, value, isStrictComparable(value)];
5973 var value = getValue(object, key);
5974 return baseIsNative(value) ? value : undefined;
5984 function getRawTag(value) { argument
5985 var isOwn = hasOwnProperty.call(value, symToStringTag),
5986 tag = value[symToStringTag];
5989 value[symToStringTag] = undefined;
5993 var result = nativeObjectToString.call(value);
5996 value[symToStringTag] = tag;
5998 delete value[symToStringTag];
6052 getTag = function(value) { argument
6053 var result = baseGetTag(value),
6054 Ctor = result == objectTag ? value.constructor : undefined,
6247 function isFlattenable(value) {
6248 return isArray(value) || isArguments(value) ||
6249 !!(spreadableSymbol && value && value[spreadableSymbol]);
6260 function isIndex(value, length) {
6261 var type = typeof value;
6266 (type != 'symbol' && reIsUint.test(value))) &&
6267 (value > -1 && value % 1 == 0 && value < length);
6280 function isIterateeCall(value, index, object) {
6289 return eq(object[index], value);
6302 function isKey(value, object) {
6303 if (isArray(value)) {
6306 var type = typeof value;
6308 value == null || isSymbol(value)) {
6311 return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
6312 (object != null && value in Object(object));
6322 function isKeyable(value) {
6323 var type = typeof value;
6325 ? (value !== '__proto__')
6326 : (value === null);
6378 function isPrototype(value) {
6379 var Ctor = value && value.constructor,
6382 return value === proto;
6393 function isStrictComparable(value) {
6394 return value === value && !isObject(value);
6474 var value = source[3];
6475 if (value) {
6477 data[3] = partials ? composeArgs(partials, value, source[4]) : value;
6481 value = source[5];
6482 if (value) {
6484 data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
6488 value = source[7];
6489 if (value) {
6490 data[7] = value;
6533 function objectToString(value) {
6534 return nativeObjectToString.call(value);
6719 value = array[rand];
6722 array[index] = value;
6753 function toKey(value) {
6754 if (typeof value == 'string' || isSymbol(value)) {
6755 return value;
6757 var result = (value + '');
6758 return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
6790 var value = '_.' + pair[0];
6791 if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
6792 details.push(value);
6881 var value = array[index];
6882 if (value) {
6883 result[resIndex++] = value;
7202 function fill(array, value, start, end) {
7207 if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
7211 return baseFill(array, value, start, end);
7450 function indexOf(array, value, fromIndex) {
7459 return baseIndexOf(array, value, index);
7635 function lastIndexOf(array, value, fromIndex) {
7645 return value === value
7646 ? strictLastIndexOf(array, value, index)
7858 var value = array[index];
7859 if (predicate(value, index, array)) {
7860 result.push(value);
7944 function sortedIndex(array, value) {
7945 return baseSortedIndex(array, value);
7973 function sortedIndexBy(array, value, iteratee) {
7974 return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
7993 function sortedIndexOf(array, value) {
7996 var index = baseSortedIndex(array, value);
7997 if (index < length && eq(array[index], value)) {
8022 function sortedLastIndex(array, value) {
8023 return baseSortedIndex(array, value, true);
8051 function sortedLastIndexBy(array, value, iteratee) {
8052 return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
8071 function sortedLastIndexOf(array, value) {
8074 var index = baseSortedIndex(array, value, true) - 1;
8075 if (eq(array[index], value)) {
8737 function chain(value) {
8738 var result = lodash(value);
8766 function tap(value, interceptor) {
8767 interceptor(value);
8768 return value;
8794 function thru(value, interceptor) {
8795 return interceptor(value);
8817 value = this.__wrapped__,
8821 !(value instanceof LazyWrapper) || !isIndex(start)) {
8824 value = value.slice(start, +start + (length ? 1 : 0));
8825 value.__actions__.push({
8830 return new LodashWrapper(value, this.__chain__).thru(function(array) {
8896 return new LodashWrapper(this.value(), this.__chain__);
8923 this.__values__ = toArray(this.value());
8926 value = done ? undefined : this.__values__[this.__index__++];
8928 return { 'done': done, 'value': value };
8977 function wrapperPlant(value) {
8993 previous.__wrapped__ = value;
9018 var value = this.__wrapped__;
9019 if (value instanceof LazyWrapper) {
9020 var wrapped = value;
9077 var countBy = createAggregator(function(result, value, key) {
9393 var groupBy = createAggregator(function(result, value, key) {
9395 result[key].push(value);
9397 baseAssignValue(result, key, [value]);
9431 function includes(collection, value, fromIndex, guard) {
9440 ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
9441 : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
9472 baseEach(collection, function(value) {
9473 result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
9506 var keyBy = createAggregator(function(result, value, key) {
9507 baseAssignValue(result, key, value);
9636 var partition = createAggregator(function(result, value, key) {
9637 result[key ? 0 : 1].push(value);
10956 function wrap(value, wrapper) {
10957 return partial(castFunction(wrapper), value);
10999 var value = arguments[0];
11000 return isArray(value) ? value : [value];
11029 function clone(value) {
11030 return baseClone(value, CLONE_SYMBOLS_FLAG);
11064 function cloneWith(value, customizer) {
11066 return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
11087 function cloneDeep(value) {
11088 return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
11119 function cloneDeepWith(value, customizer) {
11121 return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
11184 function eq(value, other) {
11185 return value === other || (value !== value && other !== other);
11236 var gte = createRelationalOperation(function(value, other) {
11237 return value >= other;
11258 …guments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
11259 return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
11260 !propertyIsEnumerable.call(value, 'callee');
11332 function isArrayLike(value) {
11333 return value != null && isLength(value.length) && !isFunction(value);
11361 function isArrayLikeObject(value) {
11362 return isObjectLike(value) && isArrayLike(value);
11382 function isBoolean(value) {
11383 return value === true || value === false ||
11384 (isObjectLike(value) && baseGetTag(value) == boolTag);
11442 function isElement(value) {
11443 return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
11479 function isEmpty(value) {
11480 if (value == null) {
11483 if (isArrayLike(value) &&
11484 (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
11485 isBuffer(value) || isTypedArray(value) || isArguments(value))) {
11486 return !value.length;
11488 var tag = getTag(value);
11490 return !value.size;
11492 if (isPrototype(value)) {
11493 return !baseKeys(value).length;
11495 for (var key in value) {
11496 if (hasOwnProperty.call(value, key)) {
11531 function isEqual(value, other) {
11532 return baseIsEqual(value, other);
11567 function isEqualWith(value, other, customizer) {
11569 var result = customizer ? customizer(value, other) : undefined;
11570 return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
11591 function isError(value) {
11592 if (!isObjectLike(value)) {
11595 var tag = baseGetTag(value);
11597 … (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
11626 function isFinite(value) {
11627 return typeof value == 'number' && nativeIsFinite(value);
11647 function isFunction(value) {
11648 if (!isObject(value)) {
11653 var tag = baseGetTag(value);
11683 function isInteger(value) {
11684 return typeof value == 'number' && value == toInteger(value);
11713 function isLength(value) {
11714 return typeof value == 'number' &&
11715 value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
11743 function isObject(value) {
11744 var type = typeof value;
11745 return value != null && (type == 'object' || type == 'function');
11772 function isObjectLike(value) {
11773 return value != null && typeof value == 'object';
11892 function isNaN(value) {
11896 return isNumber(value) && value != +value;
11925 function isNative(value) {
11926 if (isMaskable(value)) {
11929 return baseIsNative(value);
11949 function isNull(value) {
11950 return value === null;
11973 function isNil(value) {
11974 return value == null;
12003 function isNumber(value) {
12004 return typeof value == 'number' ||
12005 (isObjectLike(value) && baseGetTag(value) == numberTag);
12036 function isPlainObject(value) {
12037 if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
12040 var proto = getPrototype(value);
12095 function isSafeInteger(value) {
12096 return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
12135 function isString(value) {
12136 return typeof value == 'string' ||
12137 (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
12157 function isSymbol(value) {
12158 return typeof value == 'symbol' ||
12159 (isObjectLike(value) && baseGetTag(value) == symbolTag);
12198 function isUndefined(value) {
12199 return value === undefined;
12219 function isWeakMap(value) {
12220 return isObjectLike(value) && getTag(value) == weakMapTag;
12240 function isWeakSet(value) {
12241 return isObjectLike(value) && baseGetTag(value) == weakSetTag;
12292 var lte = createRelationalOperation(function(value, other) {
12293 return value <= other;
12319 function toArray(value) {
12320 if (!value) {
12323 if (isArrayLike(value)) {
12324 return isString(value) ? stringToArray(value) : copyArray(value);
12326 if (symIterator && value[symIterator]) {
12327 return iteratorToArray(value[symIterator]());
12329 var tag = getTag(value),
12332 return func(value);
12358 function toFinite(value) {
12359 if (!value) {
12360 return value === 0 ? value : 0;
12362 value = toNumber(value);
12363 if (value === INFINITY || value === -INFINITY) {
12364 var sign = (value < 0 ? -1 : 1);
12367 return value === value ? value : 0;
12396 function toInteger(value) {
12397 var result = toFinite(value),
12430 function toLength(value) {
12431 return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
12457 function toNumber(value) {
12458 if (typeof value == 'number') {
12459 return value;
12461 if (isSymbol(value)) {
12464 if (isObject(value)) {
12465 var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
12466 value = isObject(other) ? (other + '') : other;
12468 if (typeof value != 'string') {
12469 return value === 0 ? value : +value;
12471 value = value.replace(reTrim, '');
12472 var isBinary = reIsBinary.test(value);
12473 return (isBinary || reIsOctal.test(value))
12474 ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
12475 : (reIsBadHex.test(value) ? NAN : +value);
12502 function toPlainObject(value) {
12503 return copyObject(value, keysIn(value));
12530 function toSafeInteger(value) {
12531 return value
12532 ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
12533 : (value === 0 ? value : 0);
12557 function toString(value) {
12558 return value == null ? '' : baseToString(value);
12805 var value = object[key];
12807 if (value === undefined ||
12808 (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
13210 var invert = createInverter(function(result, value, key) {
13211 if (value != null &&
13212 typeof value.toString != 'function') {
13213 value = nativeObjectToString.call(value);
13216 result[value] = key;
13245 var invertBy = createInverter(function(result, value, key) {
13246 if (value != null &&
13247 typeof value.toString != 'function') {
13248 value = nativeObjectToString.call(value);
13251 if (hasOwnProperty.call(result, value)) {
13252 result[value].push(key);
13254 result[value] = [key];
13362 baseForOwn(object, function(value, key, object) {
13363 baseAssignValue(result, iteratee(value, key, object), value);
13400 baseForOwn(object, function(value, key, object) {
13401 baseAssignValue(result, key, iteratee(value, key, object));
13589 return basePickBy(object, props, function(value, path) {
13590 return predicate(value, path[0]);
13635 var value = object == null ? undefined : object[toKey(path[index])];
13636 if (value === undefined) {
13638 value = defaultValue;
13640 object = isFunction(value) ? value.call(object) : value;
13673 function set(object, path, value) {
13674 return object == null ? object : baseSet(object, path, value);
13701 function setWith(object, path, value, customizer) {
13703 return object == null ? object : baseSet(object, path, value, customizer);
13805 (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
13806 return iteratee(accumulator, value, index, object);
14904 function toLower(value) {
14905 return toString(value).toLowerCase();
14929 function toUpper(value) {
14930 return toString(value).toUpperCase();
15392 function constant(value) {
15394 return value;
15418 function defaultTo(value, defaultValue) {
15419 return (value == null || value !== value) ? defaultValue : value;
15485 function identity(value) {
15486 return value;
15720 return func.apply(object, arrayPush([this.value()], arguments));
16146 function toPath(value) {
16147 if (isArray(value)) {
16148 return arrayMap(value, toKey);
16150 return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
16914 return this[takeName](1).value()[0];
16943 return this.map(function(value) {
16944 return baseInvoke(value, path, args);
16990 var value = this.__wrapped__,
16992 isLazy = value instanceof LazyWrapper,
16994 useLazy = isLazy || isArray(value);
16996 var interceptor = function(value) {
16997 var result = lodashFunc.apply(lodash, arrayPush([value], args));
17011 value = onlyLazy ? value : new LazyWrapper(this);
17012 var result = func.apply(value, args);
17020 return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
17033 var value = this.value();
17034 return func.apply(isArray(value) ? value : [], args);
17036 return this[chainName](function(value) {
17037 return func.apply(isArray(value) ? value : [], args);
17062 LazyWrapper.prototype.value = lazyValue;
17071 lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;