1705 lines
48 KiB
JavaScript
1705 lines
48 KiB
JavaScript
|
/**
|
||
|
|
* @license
|
||
|
|
* Lodash (Custom Build) <https://lodash.com/>
|
||
|
|
* Build: `lodash exports="node" include="get,set,chunk"`
|
||
|
|
* Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
|
||
|
|
* Released under MIT license <https://lodash.com/license>
|
||
|
|
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
|
||
|
|
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
||
|
|
*/
|
||
|
|
;(function() {
|
||
|
|
|
||
|
|
/** Used as a safe reference for `undefined` in pre-ES5 environments. */
|
||
|
|
var undefined;
|
||
|
|
|
||
|
|
/** Used as the semantic version number. */
|
||
|
|
var VERSION = '4.17.21';
|
||
|
|
|
||
|
|
/** Error message constants. */
|
||
|
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
||
|
|
|
||
|
|
/** Used to stand-in for `undefined` hash values. */
|
||
|
|
var HASH_UNDEFINED = '__lodash_hash_undefined__';
|
||
|
|
|
||
|
|
/** Used as the maximum memoize cache size. */
|
||
|
|
var MAX_MEMOIZE_SIZE = 500;
|
||
|
|
|
||
|
|
/** Used as references for various `Number` constants. */
|
||
|
|
var INFINITY = 1 / 0,
|
||
|
|
MAX_SAFE_INTEGER = 9007199254740991,
|
||
|
|
MAX_INTEGER = 1.7976931348623157e+308,
|
||
|
|
NAN = 0 / 0;
|
||
|
|
|
||
|
|
/** `Object#toString` result references. */
|
||
|
|
var asyncTag = '[object AsyncFunction]',
|
||
|
|
funcTag = '[object Function]',
|
||
|
|
genTag = '[object GeneratorFunction]',
|
||
|
|
nullTag = '[object Null]',
|
||
|
|
proxyTag = '[object Proxy]',
|
||
|
|
symbolTag = '[object Symbol]',
|
||
|
|
undefinedTag = '[object Undefined]';
|
||
|
|
|
||
|
|
/** Used to match property names within property paths. */
|
||
|
|
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
|
||
|
|
reIsPlainProp = /^\w*$/,
|
||
|
|
rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Used to match `RegExp`
|
||
|
|
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
|
||
|
|
*/
|
||
|
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
||
|
|
|
||
|
|
/** Used to match leading whitespace. */
|
||
|
|
var reTrimStart = /^\s+/;
|
||
|
|
|
||
|
|
/** Used to match a single whitespace character. */
|
||
|
|
var reWhitespace = /\s/;
|
||
|
|
|
||
|
|
/** Used to match backslashes in property paths. */
|
||
|
|
var reEscapeChar = /\\(\\)?/g;
|
||
|
|
|
||
|
|
/** Used to detect bad signed hexadecimal string values. */
|
||
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
||
|
|
|
||
|
|
/** Used to detect binary string values. */
|
||
|
|
var reIsBinary = /^0b[01]+$/i;
|
||
|
|
|
||
|
|
/** Used to detect host constructors (Safari). */
|
||
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
||
|
|
|
||
|
|
/** Used to detect octal string values. */
|
||
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
||
|
|
|
||
|
|
/** Used to detect unsigned integer values. */
|
||
|
|
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
||
|
|
|
||
|
|
/** Built-in method references without a dependency on `root`. */
|
||
|
|
var freeParseInt = parseInt;
|
||
|
|
|
||
|
|
/** 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 = typeof exports == 'object' && exports && !exports.nodeType && exports;
|
||
|
|
|
||
|
|
/** Detect free variable `module`. */
|
||
|
|
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
|
||
|
|
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A specialized version of `_.map` for arrays without support for iteratee
|
||
|
|
* shorthands.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Array} [array] The array to iterate over.
|
||
|
|
* @param {Function} iteratee The function invoked per iteration.
|
||
|
|
* @returns {Array} Returns the new mapped array.
|
||
|
|
*/
|
||
|
|
function arrayMap(array, iteratee) {
|
||
|
|
var index = -1,
|
||
|
|
length = array == null ? 0 : array.length,
|
||
|
|
result = Array(length);
|
||
|
|
|
||
|
|
while (++index < length) {
|
||
|
|
result[index] = iteratee(array[index], index, array);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The base implementation of `_.trim`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {string} string The string to trim.
|
||
|
|
* @returns {string} Returns the trimmed string.
|
||
|
|
*/
|
||
|
|
function baseTrim(string) {
|
||
|
|
return string
|
||
|
|
? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
|
||
|
|
: string;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
|
||
|
|
* character of `string`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {string} string The string to inspect.
|
||
|
|
* @returns {number} Returns the index of the last non-whitespace character.
|
||
|
|
*/
|
||
|
|
function trimmedEndIndex(string) {
|
||
|
|
var index = string.length;
|
||
|
|
|
||
|
|
while (index-- && reWhitespace.test(string.charAt(index))) {}
|
||
|
|
return index;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/** Used for built-in method references. */
|
||
|
|
var arrayProto = Array.prototype,
|
||
|
|
funcProto = Function.prototype,
|
||
|
|
objectProto = Object.prototype;
|
||
|
|
|
||
|
|
/** Used to detect overreaching core-js shims. */
|
||
|
|
var coreJsData = root['__core-js_shared__'];
|
||
|
|
|
||
|
|
/** Used to resolve the decompiled source of functions. */
|
||
|
|
var funcToString = funcProto.toString;
|
||
|
|
|
||
|
|
/** Used to check objects for own properties. */
|
||
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
|
|
||
|
|
/** 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
|
||
|
|
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
|
||
|
|
* of values.
|
||
|
|
*/
|
||
|
|
var nativeObjectToString = objectProto.toString;
|
||
|
|
|
||
|
|
/** Used to detect if a method is native. */
|
||
|
|
var reIsNative = RegExp('^' +
|
||
|
|
funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
|
||
|
|
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
||
|
|
);
|
||
|
|
|
||
|
|
/** Built-in value references. */
|
||
|
|
var Symbol = root.Symbol,
|
||
|
|
splice = arrayProto.splice,
|
||
|
|
symToStringTag = Symbol ? Symbol.toStringTag : undefined;
|
||
|
|
|
||
|
|
var defineProperty = (function() {
|
||
|
|
try {
|
||
|
|
var func = getNative(Object, 'defineProperty');
|
||
|
|
func({}, '', {});
|
||
|
|
return func;
|
||
|
|
} catch (e) {}
|
||
|
|
}());
|
||
|
|
|
||
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
||
|
|
var nativeCeil = Math.ceil,
|
||
|
|
nativeMax = Math.max;
|
||
|
|
|
||
|
|
/* Built-in method references that are verified to be native. */
|
||
|
|
var Map = getNative(root, 'Map'),
|
||
|
|
nativeCreate = getNative(Object, 'create');
|
||
|
|
|
||
|
|
/** Used to lookup unminified function names. */
|
||
|
|
var realNames = {};
|
||
|
|
|
||
|
|
/** Used to convert symbols to primitives and strings. */
|
||
|
|
var symbolProto = Symbol ? Symbol.prototype : undefined,
|
||
|
|
symbolToString = symbolProto ? symbolProto.toString : undefined;
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a `lodash` object which wraps `value` to enable implicit method
|
||
|
|
* chain sequences. Methods that operate on and return arrays, collections,
|
||
|
|
* and functions can be chained together. Methods that retrieve a single value
|
||
|
|
* or may return a primitive value will automatically end the chain sequence
|
||
|
|
* and return the unwrapped value. Otherwise, the value must be unwrapped
|
||
|
|
* with `_#value`.
|
||
|
|
*
|
||
|
|
* Explicit chain sequences, which must be unwrapped with `_#value`, may be
|
||
|
|
* enabled using `_.chain`.
|
||
|
|
*
|
||
|
|
* The execution of chained methods is lazy, that is, it's deferred until
|
||
|
|
* `_#value` is implicitly or explicitly called.
|
||
|
|
*
|
||
|
|
* Lazy evaluation allows several methods to support shortcut fusion.
|
||
|
|
* Shortcut fusion is an optimization to merge iteratee calls; this avoids
|
||
|
|
* the creation of intermediate arrays and can greatly reduce the number of
|
||
|
|
* iteratee executions. Sections of a chain sequence qualify for shortcut
|
||
|
|
* fusion if the section is applied to an array and iteratees accept only
|
||
|
|
* one argument. The heuristic for whether a section qualifies for shortcut
|
||
|
|
* fusion is subject to change.
|
||
|
|
*
|
||
|
|
* Chaining is supported in custom builds as long as the `_#value` method is
|
||
|
|
* directly or indirectly included in the build.
|
||
|
|
*
|
||
|
|
* In addition to lodash methods, wrappers have `Array` and `String` methods.
|
||
|
|
*
|
||
|
|
* The wrapper `Array` methods are:
|
||
|
|
* `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
|
||
|
|
*
|
||
|
|
* The wrapper `String` methods are:
|
||
|
|
* `replace` and `split`
|
||
|
|
*
|
||
|
|
* The wrapper methods that support shortcut fusion are:
|
||
|
|
* `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
|
||
|
|
* `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
|
||
|
|
* `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
|
||
|
|
*
|
||
|
|
* The chainable wrapper methods are:
|
||
|
|
* `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
|
||
|
|
* `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
|
||
|
|
* `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
|
||
|
|
* `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
|
||
|
|
* `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
|
||
|
|
* `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
|
||
|
|
* `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
|
||
|
|
* `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
|
||
|
|
* `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
|
||
|
|
* `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
|
||
|
|
* `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
|
||
|
|
* `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
|
||
|
|
* `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
|
||
|
|
* `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
|
||
|
|
* `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
|
||
|
|
* `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
|
||
|
|
* `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
|
||
|
|
* `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
|
||
|
|
* `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
|
||
|
|
* `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
|
||
|
|
* `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
|
||
|
|
* `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
|
||
|
|
* `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
|
||
|
|
* `zipObject`, `zipObjectDeep`, and `zipWith`
|
||
|
|
*
|
||
|
|
* The wrapper methods that are **not** chainable by default are:
|
||
|
|
* `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
|
||
|
|
* `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
|
||
|
|
* `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
|
||
|
|
* `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
|
||
|
|
* `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
|
||
|
|
* `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
|
||
|
|
* `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
|
||
|
|
* `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
|
||
|
|
* `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
|
||
|
|
* `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
|
||
|
|
* `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
|
||
|
|
* `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
|
||
|
|
* `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
|
||
|
|
* `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
|
||
|
|
* `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
|
||
|
|
* `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
|
||
|
|
* `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
|
||
|
|
* `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
|
||
|
|
* `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
|
||
|
|
* `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
|
||
|
|
* `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
|
||
|
|
* `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
|
||
|
|
* `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
|
||
|
|
* `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
|
||
|
|
* `upperFirst`, `value`, and `words`
|
||
|
|
*
|
||
|
|
* @name _
|
||
|
|
* @constructor
|
||
|
|
* @category Seq
|
||
|
|
* @param {*} value The value to wrap in a `lodash` instance.
|
||
|
|
* @returns {Object} Returns the new `lodash` wrapper instance.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* function square(n) {
|
||
|
|
* return n * n;
|
||
|
|
* }
|
||
|
|
*
|
||
|
|
* var wrapped = _([1, 2, 3]);
|
||
|
|
*
|
||
|
|
* // Returns an unwrapped value.
|
||
|
|
* wrapped.reduce(_.add);
|
||
|
|
* // => 6
|
||
|
|
*
|
||
|
|
* // Returns a wrapped value.
|
||
|
|
* var squares = wrapped.map(square);
|
||
|
|
*
|
||
|
|
* _.isArray(squares);
|
||
|
|
* // => false
|
||
|
|
*
|
||
|
|
* _.isArray(squares.value());
|
||
|
|
* // => true
|
||
|
|
*/
|
||
|
|
function lodash() {
|
||
|
|
// No operation performed.
|
||
|
|
}
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a hash object.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @constructor
|
||
|
|
* @param {Array} [entries] The key-value pairs to cache.
|
||
|
|
*/
|
||
|
|
function Hash(entries) {
|
||
|
|
var index = -1,
|
||
|
|
length = entries == null ? 0 : entries.length;
|
||
|
|
|
||
|
|
this.clear();
|
||
|
|
while (++index < length) {
|
||
|
|
var entry = entries[index];
|
||
|
|
this.set(entry[0], entry[1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes all key-value entries from the hash.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name clear
|
||
|
|
* @memberOf Hash
|
||
|
|
*/
|
||
|
|
function hashClear() {
|
||
|
|
this.__data__ = nativeCreate ? nativeCreate(null) : {};
|
||
|
|
this.size = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes `key` and its value from the hash.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name delete
|
||
|
|
* @memberOf Hash
|
||
|
|
* @param {Object} hash The hash to modify.
|
||
|
|
* @param {string} key The key of the value to remove.
|
||
|
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
|
||
|
|
*/
|
||
|
|
function hashDelete(key) {
|
||
|
|
var result = this.has(key) && delete this.__data__[key];
|
||
|
|
this.size -= result ? 1 : 0;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the hash value for `key`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name get
|
||
|
|
* @memberOf Hash
|
||
|
|
* @param {string} key The key of the value to get.
|
||
|
|
* @returns {*} Returns the entry value.
|
||
|
|
*/
|
||
|
|
function hashGet(key) {
|
||
|
|
var data = this.__data__;
|
||
|
|
if (nativeCreate) {
|
||
|
|
var result = data[key];
|
||
|
|
return result === HASH_UNDEFINED ? undefined : result;
|
||
|
|
}
|
||
|
|
return hasOwnProperty.call(data, key) ? data[key] : undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if a hash value for `key` exists.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name has
|
||
|
|
* @memberOf Hash
|
||
|
|
* @param {string} key The key of the entry to check.
|
||
|
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
|
||
|
|
*/
|
||
|
|
function hashHas(key) {
|
||
|
|
var data = this.__data__;
|
||
|
|
return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets the hash `key` to `value`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name set
|
||
|
|
* @memberOf Hash
|
||
|
|
* @param {string} key The key of the value to set.
|
||
|
|
* @param {*} value The value to set.
|
||
|
|
* @returns {Object} Returns the hash instance.
|
||
|
|
*/
|
||
|
|
function hashSet(key, value) {
|
||
|
|
var data = this.__data__;
|
||
|
|
this.size += this.has(key) ? 0 : 1;
|
||
|
|
data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add methods to `Hash`.
|
||
|
|
Hash.prototype.clear = hashClear;
|
||
|
|
Hash.prototype['delete'] = hashDelete;
|
||
|
|
Hash.prototype.get = hashGet;
|
||
|
|
Hash.prototype.has = hashHas;
|
||
|
|
Hash.prototype.set = hashSet;
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates an list cache object.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @constructor
|
||
|
|
* @param {Array} [entries] The key-value pairs to cache.
|
||
|
|
*/
|
||
|
|
function ListCache(entries) {
|
||
|
|
var index = -1,
|
||
|
|
length = entries == null ? 0 : entries.length;
|
||
|
|
|
||
|
|
this.clear();
|
||
|
|
while (++index < length) {
|
||
|
|
var entry = entries[index];
|
||
|
|
this.set(entry[0], entry[1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes all key-value entries from the list cache.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name clear
|
||
|
|
* @memberOf ListCache
|
||
|
|
*/
|
||
|
|
function listCacheClear() {
|
||
|
|
this.__data__ = [];
|
||
|
|
this.size = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes `key` and its value from the list cache.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name delete
|
||
|
|
* @memberOf ListCache
|
||
|
|
* @param {string} key The key of the value to remove.
|
||
|
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
|
||
|
|
*/
|
||
|
|
function listCacheDelete(key) {
|
||
|
|
var data = this.__data__,
|
||
|
|
index = assocIndexOf(data, key);
|
||
|
|
|
||
|
|
if (index < 0) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
var lastIndex = data.length - 1;
|
||
|
|
if (index == lastIndex) {
|
||
|
|
data.pop();
|
||
|
|
} else {
|
||
|
|
splice.call(data, index, 1);
|
||
|
|
}
|
||
|
|
--this.size;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the list cache value for `key`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name get
|
||
|
|
* @memberOf ListCache
|
||
|
|
* @param {string} key The key of the value to get.
|
||
|
|
* @returns {*} Returns the entry value.
|
||
|
|
*/
|
||
|
|
function listCacheGet(key) {
|
||
|
|
var data = this.__data__,
|
||
|
|
index = assocIndexOf(data, key);
|
||
|
|
|
||
|
|
return index < 0 ? undefined : data[index][1];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if a list cache value for `key` exists.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name has
|
||
|
|
* @memberOf ListCache
|
||
|
|
* @param {string} key The key of the entry to check.
|
||
|
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
|
||
|
|
*/
|
||
|
|
function listCacheHas(key) {
|
||
|
|
return assocIndexOf(this.__data__, key) > -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets the list cache `key` to `value`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name set
|
||
|
|
* @memberOf ListCache
|
||
|
|
* @param {string} key The key of the value to set.
|
||
|
|
* @param {*} value The value to set.
|
||
|
|
* @returns {Object} Returns the list cache instance.
|
||
|
|
*/
|
||
|
|
function listCacheSet(key, value) {
|
||
|
|
var data = this.__data__,
|
||
|
|
index = assocIndexOf(data, key);
|
||
|
|
|
||
|
|
if (index < 0) {
|
||
|
|
++this.size;
|
||
|
|
data.push([key, value]);
|
||
|
|
} else {
|
||
|
|
data[index][1] = value;
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add methods to `ListCache`.
|
||
|
|
ListCache.prototype.clear = listCacheClear;
|
||
|
|
ListCache.prototype['delete'] = listCacheDelete;
|
||
|
|
ListCache.prototype.get = listCacheGet;
|
||
|
|
ListCache.prototype.has = listCacheHas;
|
||
|
|
ListCache.prototype.set = listCacheSet;
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a map cache object to store key-value pairs.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @constructor
|
||
|
|
* @param {Array} [entries] The key-value pairs to cache.
|
||
|
|
*/
|
||
|
|
function MapCache(entries) {
|
||
|
|
var index = -1,
|
||
|
|
length = entries == null ? 0 : entries.length;
|
||
|
|
|
||
|
|
this.clear();
|
||
|
|
while (++index < length) {
|
||
|
|
var entry = entries[index];
|
||
|
|
this.set(entry[0], entry[1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes all key-value entries from the map.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name clear
|
||
|
|
* @memberOf MapCache
|
||
|
|
*/
|
||
|
|
function mapCacheClear() {
|
||
|
|
this.size = 0;
|
||
|
|
this.__data__ = {
|
||
|
|
'hash': new Hash,
|
||
|
|
'map': new (Map || ListCache),
|
||
|
|
'string': new Hash
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes `key` and its value from the map.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name delete
|
||
|
|
* @memberOf MapCache
|
||
|
|
* @param {string} key The key of the value to remove.
|
||
|
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
|
||
|
|
*/
|
||
|
|
function mapCacheDelete(key) {
|
||
|
|
var result = getMapData(this, key)['delete'](key);
|
||
|
|
this.size -= result ? 1 : 0;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the map value for `key`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name get
|
||
|
|
* @memberOf MapCache
|
||
|
|
* @param {string} key The key of the value to get.
|
||
|
|
* @returns {*} Returns the entry value.
|
||
|
|
*/
|
||
|
|
function mapCacheGet(key) {
|
||
|
|
return getMapData(this, key).get(key);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if a map value for `key` exists.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name has
|
||
|
|
* @memberOf MapCache
|
||
|
|
* @param {string} key The key of the entry to check.
|
||
|
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
|
||
|
|
*/
|
||
|
|
function mapCacheHas(key) {
|
||
|
|
return getMapData(this, key).has(key);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets the map `key` to `value`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @name set
|
||
|
|
* @memberOf MapCache
|
||
|
|
* @param {string} key The key of the value to set.
|
||
|
|
* @param {*} value The value to set.
|
||
|
|
* @returns {Object} Returns the map cache instance.
|
||
|
|
*/
|
||
|
|
function mapCacheSet(key, value) {
|
||
|
|
var data = getMapData(this, key),
|
||
|
|
size = data.size;
|
||
|
|
|
||
|
|
data.set(key, value);
|
||
|
|
this.size += data.size == size ? 0 : 1;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add methods to `MapCache`.
|
||
|
|
MapCache.prototype.clear = mapCacheClear;
|
||
|
|
MapCache.prototype['delete'] = mapCacheDelete;
|
||
|
|
MapCache.prototype.get = mapCacheGet;
|
||
|
|
MapCache.prototype.has = mapCacheHas;
|
||
|
|
MapCache.prototype.set = mapCacheSet;
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Assigns `value` to `key` of `object` if the existing value is not equivalent
|
||
|
|
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
|
||
|
|
* for equality comparisons.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Object} object The object to modify.
|
||
|
|
* @param {string} key The key of the property to assign.
|
||
|
|
* @param {*} value The value to assign.
|
||
|
|
*/
|
||
|
|
function assignValue(object, key, value) {
|
||
|
|
var objValue = object[key];
|
||
|
|
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
|
||
|
|
(value === undefined && !(key in object))) {
|
||
|
|
baseAssignValue(object, key, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the index at which the `key` is found in `array` of key-value pairs.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Array} array The array to inspect.
|
||
|
|
* @param {*} key The key to search for.
|
||
|
|
* @returns {number} Returns the index of the matched value, else `-1`.
|
||
|
|
*/
|
||
|
|
function assocIndexOf(array, key) {
|
||
|
|
var length = array.length;
|
||
|
|
while (length--) {
|
||
|
|
if (eq(array[length][0], key)) {
|
||
|
|
return length;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The base implementation of `assignValue` and `assignMergeValue` without
|
||
|
|
* value checks.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Object} object The object to modify.
|
||
|
|
* @param {string} key The key of the property to assign.
|
||
|
|
* @param {*} value The value to assign.
|
||
|
|
*/
|
||
|
|
function baseAssignValue(object, key, value) {
|
||
|
|
if (key == '__proto__' && defineProperty) {
|
||
|
|
defineProperty(object, key, {
|
||
|
|
'configurable': true,
|
||
|
|
'enumerable': true,
|
||
|
|
'value': value,
|
||
|
|
'writable': true
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
object[key] = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The base implementation of `_.get` without support for default values.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Object} object The object to query.
|
||
|
|
* @param {Array|string} path The path of the property to get.
|
||
|
|
* @returns {*} Returns the resolved value.
|
||
|
|
*/
|
||
|
|
function baseGet(object, path) {
|
||
|
|
path = castPath(path, object);
|
||
|
|
|
||
|
|
var index = 0,
|
||
|
|
length = path.length;
|
||
|
|
|
||
|
|
while (object != null && index < length) {
|
||
|
|
object = object[toKey(path[index++])];
|
||
|
|
}
|
||
|
|
return (index && index == length) ? object : undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The base implementation of `getTag` without fallbacks for buggy environments.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to query.
|
||
|
|
* @returns {string} Returns the `toStringTag`.
|
||
|
|
*/
|
||
|
|
function baseGetTag(value) {
|
||
|
|
if (value == null) {
|
||
|
|
return value === undefined ? undefinedTag : nullTag;
|
||
|
|
}
|
||
|
|
return (symToStringTag && symToStringTag in Object(value))
|
||
|
|
? getRawTag(value)
|
||
|
|
: objectToString(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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) ? reIsNative : reIsHostCtor;
|
||
|
|
return pattern.test(toSource(value));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The base implementation of `_.set`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Object} object The object to modify.
|
||
|
|
* @param {Array|string} path The path of the property to set.
|
||
|
|
* @param {*} value The value to set.
|
||
|
|
* @param {Function} [customizer] The function to customize path creation.
|
||
|
|
* @returns {Object} Returns `object`.
|
||
|
|
*/
|
||
|
|
function baseSet(object, path, value, customizer) {
|
||
|
|
if (!isObject(object)) {
|
||
|
|
return object;
|
||
|
|
}
|
||
|
|
path = castPath(path, object);
|
||
|
|
|
||
|
|
var index = -1,
|
||
|
|
length = path.length,
|
||
|
|
lastIndex = length - 1,
|
||
|
|
nested = object;
|
||
|
|
|
||
|
|
while (nested != null && ++index < length) {
|
||
|
|
var key = toKey(path[index]),
|
||
|
|
newValue = value;
|
||
|
|
|
||
|
|
if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
|
||
|
|
return object;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (index != lastIndex) {
|
||
|
|
var objValue = nested[key];
|
||
|
|
newValue = customizer ? customizer(objValue, key, nested) : undefined;
|
||
|
|
if (newValue === undefined) {
|
||
|
|
newValue = isObject(objValue)
|
||
|
|
? objValue
|
||
|
|
: (isIndex(path[index + 1]) ? [] : {});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
assignValue(nested, key, newValue);
|
||
|
|
nested = nested[key];
|
||
|
|
}
|
||
|
|
return object;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The base implementation of `_.slice` without an iteratee call guard.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Array} array The array to slice.
|
||
|
|
* @param {number} [start=0] The start position.
|
||
|
|
* @param {number} [end=array.length] The end position.
|
||
|
|
* @returns {Array} Returns the slice of `array`.
|
||
|
|
*/
|
||
|
|
function baseSlice(array, start, end) {
|
||
|
|
var index = -1,
|
||
|
|
length = array.length;
|
||
|
|
|
||
|
|
if (start < 0) {
|
||
|
|
start = -start > length ? 0 : (length + start);
|
||
|
|
}
|
||
|
|
end = end > length ? length : end;
|
||
|
|
if (end < 0) {
|
||
|
|
end += length;
|
||
|
|
}
|
||
|
|
length = start > end ? 0 : ((end - start) >>> 0);
|
||
|
|
start >>>= 0;
|
||
|
|
|
||
|
|
var result = Array(length);
|
||
|
|
while (++index < length) {
|
||
|
|
result[index] = array[index + start];
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The base implementation of `_.toString` which doesn't convert nullish
|
||
|
|
* values to empty strings.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to process.
|
||
|
|
* @returns {string} Returns the string.
|
||
|
|
*/
|
||
|
|
function baseToString(value) {
|
||
|
|
// Exit early for strings to avoid a performance hit in some environments.
|
||
|
|
if (typeof value == 'string') {
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
if (isArray(value)) {
|
||
|
|
// Recursively convert values (susceptible to call stack limits).
|
||
|
|
return arrayMap(value, baseToString) + '';
|
||
|
|
}
|
||
|
|
if (isSymbol(value)) {
|
||
|
|
return symbolToString ? symbolToString.call(value) : '';
|
||
|
|
}
|
||
|
|
var result = (value + '');
|
||
|
|
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Casts `value` to a path array if it's not one.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to inspect.
|
||
|
|
* @param {Object} [object] The object to query keys on.
|
||
|
|
* @returns {Array} Returns the cast property path array.
|
||
|
|
*/
|
||
|
|
function castPath(value, object) {
|
||
|
|
if (isArray(value)) {
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
return isKey(value, object) ? [value] : stringToPath(toString(value));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the data for `map`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Object} map The map to query.
|
||
|
|
* @param {string} key The reference key.
|
||
|
|
* @returns {*} Returns the map data.
|
||
|
|
*/
|
||
|
|
function getMapData(map, key) {
|
||
|
|
var data = map.__data__;
|
||
|
|
return isKeyable(key)
|
||
|
|
? data[typeof key == 'string' ? 'string' : 'hash']
|
||
|
|
: data.map;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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 = getValue(object, key);
|
||
|
|
return baseIsNative(value) ? value : undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to query.
|
||
|
|
* @returns {string} Returns the raw `toStringTag`.
|
||
|
|
*/
|
||
|
|
function getRawTag(value) {
|
||
|
|
var isOwn = hasOwnProperty.call(value, symToStringTag),
|
||
|
|
tag = value[symToStringTag];
|
||
|
|
|
||
|
|
try {
|
||
|
|
value[symToStringTag] = undefined;
|
||
|
|
var unmasked = true;
|
||
|
|
} catch (e) {}
|
||
|
|
|
||
|
|
var result = nativeObjectToString.call(value);
|
||
|
|
if (unmasked) {
|
||
|
|
if (isOwn) {
|
||
|
|
value[symToStringTag] = tag;
|
||
|
|
} else {
|
||
|
|
delete value[symToStringTag];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is a valid array-like index.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
|
||
|
|
*/
|
||
|
|
function isIndex(value, length) {
|
||
|
|
var type = typeof value;
|
||
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
||
|
|
|
||
|
|
return !!length &&
|
||
|
|
(type == 'number' ||
|
||
|
|
(type != 'symbol' && reIsUint.test(value))) &&
|
||
|
|
(value > -1 && value % 1 == 0 && value < length);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if the given arguments are from an iteratee call.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The potential iteratee value argument.
|
||
|
|
* @param {*} index The potential iteratee index or key argument.
|
||
|
|
* @param {*} object The potential iteratee object argument.
|
||
|
|
* @returns {boolean} Returns `true` if the arguments are from an iteratee call,
|
||
|
|
* else `false`.
|
||
|
|
*/
|
||
|
|
function isIterateeCall(value, index, object) {
|
||
|
|
if (!isObject(object)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
var type = typeof index;
|
||
|
|
if (type == 'number'
|
||
|
|
? (isArrayLike(object) && isIndex(index, object.length))
|
||
|
|
: (type == 'string' && index in object)
|
||
|
|
) {
|
||
|
|
return eq(object[index], value);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is a property name and not a property path.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @param {Object} [object] The object to query keys on.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
|
||
|
|
*/
|
||
|
|
function isKey(value, object) {
|
||
|
|
if (isArray(value)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
var type = typeof value;
|
||
|
|
if (type == 'number' || type == 'symbol' || type == 'boolean' ||
|
||
|
|
value == null || isSymbol(value)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
|
||
|
|
(object != null && value in Object(object));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is suitable for use as unique object key.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
|
||
|
|
*/
|
||
|
|
function isKeyable(value) {
|
||
|
|
var type = typeof value;
|
||
|
|
return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
|
||
|
|
? (value !== '__proto__')
|
||
|
|
: (value === null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A specialized version of `_.memoize` which clears the memoized function's
|
||
|
|
* cache when it exceeds `MAX_MEMOIZE_SIZE`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Function} func The function to have its output memoized.
|
||
|
|
* @returns {Function} Returns the new memoized function.
|
||
|
|
*/
|
||
|
|
function memoizeCapped(func) {
|
||
|
|
var result = memoize(func, function(key) {
|
||
|
|
if (cache.size === MAX_MEMOIZE_SIZE) {
|
||
|
|
cache.clear();
|
||
|
|
}
|
||
|
|
return key;
|
||
|
|
});
|
||
|
|
|
||
|
|
var cache = result.cache;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts `value` to a string using `Object.prototype.toString`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to convert.
|
||
|
|
* @returns {string} Returns the converted string.
|
||
|
|
*/
|
||
|
|
function objectToString(value) {
|
||
|
|
return nativeObjectToString.call(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts `string` to a property path array.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {string} string The string to convert.
|
||
|
|
* @returns {Array} Returns the property path array.
|
||
|
|
*/
|
||
|
|
var stringToPath = memoizeCapped(function(string) {
|
||
|
|
var result = [];
|
||
|
|
if (string.charCodeAt(0) === 46 /* . */) {
|
||
|
|
result.push('');
|
||
|
|
}
|
||
|
|
string.replace(rePropName, function(match, number, quote, subString) {
|
||
|
|
result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
|
||
|
|
});
|
||
|
|
return result;
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts `value` to a string key if it's not a string or symbol.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {*} value The value to inspect.
|
||
|
|
* @returns {string|symbol} Returns the key.
|
||
|
|
*/
|
||
|
|
function toKey(value) {
|
||
|
|
if (typeof value == 'string' || isSymbol(value)) {
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
var result = (value + '');
|
||
|
|
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts `func` to its source code.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
* @param {Function} func The function to convert.
|
||
|
|
* @returns {string} Returns the source code.
|
||
|
|
*/
|
||
|
|
function toSource(func) {
|
||
|
|
if (func != null) {
|
||
|
|
try {
|
||
|
|
return funcToString.call(func);
|
||
|
|
} catch (e) {}
|
||
|
|
try {
|
||
|
|
return (func + '');
|
||
|
|
} catch (e) {}
|
||
|
|
}
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates an array of elements split into groups the length of `size`.
|
||
|
|
* If `array` can't be split evenly, the final chunk will be the remaining
|
||
|
|
* elements.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 3.0.0
|
||
|
|
* @category Array
|
||
|
|
* @param {Array} array The array to process.
|
||
|
|
* @param {number} [size=1] The length of each chunk
|
||
|
|
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
|
||
|
|
* @returns {Array} Returns the new array of chunks.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.chunk(['a', 'b', 'c', 'd'], 2);
|
||
|
|
* // => [['a', 'b'], ['c', 'd']]
|
||
|
|
*
|
||
|
|
* _.chunk(['a', 'b', 'c', 'd'], 3);
|
||
|
|
* // => [['a', 'b', 'c'], ['d']]
|
||
|
|
*/
|
||
|
|
function chunk(array, size, guard) {
|
||
|
|
if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
|
||
|
|
size = 1;
|
||
|
|
} else {
|
||
|
|
size = nativeMax(toInteger(size), 0);
|
||
|
|
}
|
||
|
|
var length = array == null ? 0 : array.length;
|
||
|
|
if (!length || size < 1) {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
var index = 0,
|
||
|
|
resIndex = 0,
|
||
|
|
result = Array(nativeCeil(length / size));
|
||
|
|
|
||
|
|
while (index < length) {
|
||
|
|
result[resIndex++] = baseSlice(array, index, (index += size));
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a function that memoizes the result of `func`. If `resolver` is
|
||
|
|
* provided, it determines the cache key for storing the result based on the
|
||
|
|
* arguments provided to the memoized function. By default, the first argument
|
||
|
|
* provided to the memoized function is used as the map cache key. The `func`
|
||
|
|
* is invoked with the `this` binding of the memoized function.
|
||
|
|
*
|
||
|
|
* **Note:** The cache is exposed as the `cache` property on the memoized
|
||
|
|
* function. Its creation may be customized by replacing the `_.memoize.Cache`
|
||
|
|
* constructor with one whose instances implement the
|
||
|
|
* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
|
||
|
|
* method interface of `clear`, `delete`, `get`, `has`, and `set`.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 0.1.0
|
||
|
|
* @category Function
|
||
|
|
* @param {Function} func The function to have its output memoized.
|
||
|
|
* @param {Function} [resolver] The function to resolve the cache key.
|
||
|
|
* @returns {Function} Returns the new memoized function.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* var object = { 'a': 1, 'b': 2 };
|
||
|
|
* var other = { 'c': 3, 'd': 4 };
|
||
|
|
*
|
||
|
|
* var values = _.memoize(_.values);
|
||
|
|
* values(object);
|
||
|
|
* // => [1, 2]
|
||
|
|
*
|
||
|
|
* values(other);
|
||
|
|
* // => [3, 4]
|
||
|
|
*
|
||
|
|
* object.a = 2;
|
||
|
|
* values(object);
|
||
|
|
* // => [1, 2]
|
||
|
|
*
|
||
|
|
* // Modify the result cache.
|
||
|
|
* values.cache.set(object, ['a', 'b']);
|
||
|
|
* values(object);
|
||
|
|
* // => ['a', 'b']
|
||
|
|
*
|
||
|
|
* // Replace `_.memoize.Cache`.
|
||
|
|
* _.memoize.Cache = WeakMap;
|
||
|
|
*/
|
||
|
|
function memoize(func, resolver) {
|
||
|
|
if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
|
||
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
||
|
|
}
|
||
|
|
var memoized = function() {
|
||
|
|
var args = arguments,
|
||
|
|
key = resolver ? resolver.apply(this, args) : args[0],
|
||
|
|
cache = memoized.cache;
|
||
|
|
|
||
|
|
if (cache.has(key)) {
|
||
|
|
return cache.get(key);
|
||
|
|
}
|
||
|
|
var result = func.apply(this, args);
|
||
|
|
memoized.cache = cache.set(key, result) || cache;
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
memoized.cache = new (memoize.Cache || MapCache);
|
||
|
|
return memoized;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Expose `MapCache`.
|
||
|
|
memoize.Cache = MapCache;
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Performs a
|
||
|
|
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
|
||
|
|
* comparison between two values to determine if they are equivalent.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.0.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to compare.
|
||
|
|
* @param {*} other The other value to compare.
|
||
|
|
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* var object = { 'a': 1 };
|
||
|
|
* var other = { 'a': 1 };
|
||
|
|
*
|
||
|
|
* _.eq(object, object);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.eq(object, other);
|
||
|
|
* // => false
|
||
|
|
*
|
||
|
|
* _.eq('a', 'a');
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.eq('a', Object('a'));
|
||
|
|
* // => false
|
||
|
|
*
|
||
|
|
* _.eq(NaN, NaN);
|
||
|
|
* // => true
|
||
|
|
*/
|
||
|
|
function eq(value, other) {
|
||
|
|
return value === other || (value !== value && other !== other);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is classified as an `Array` object.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 0.1.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is an array, else `false`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.isArray([1, 2, 3]);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isArray(document.body.children);
|
||
|
|
* // => false
|
||
|
|
*
|
||
|
|
* _.isArray('abc');
|
||
|
|
* // => false
|
||
|
|
*
|
||
|
|
* _.isArray(_.noop);
|
||
|
|
* // => false
|
||
|
|
*/
|
||
|
|
var isArray = Array.isArray;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is array-like. A value is considered array-like if it's
|
||
|
|
* not a function and has a `value.length` that's an integer greater than or
|
||
|
|
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.0.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.isArrayLike([1, 2, 3]);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isArrayLike(document.body.children);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isArrayLike('abc');
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isArrayLike(_.noop);
|
||
|
|
* // => false
|
||
|
|
*/
|
||
|
|
function isArrayLike(value) {
|
||
|
|
return value != null && isLength(value.length) && !isFunction(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is classified as a `Function` object.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 0.1.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is a function, else `false`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.isFunction(_);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isFunction(/abc/);
|
||
|
|
* // => false
|
||
|
|
*/
|
||
|
|
function isFunction(value) {
|
||
|
|
if (!isObject(value)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
// The use of `Object#toString` avoids issues with the `typeof` operator
|
||
|
|
// in Safari 9 which returns 'object' for typed arrays and other constructors.
|
||
|
|
var tag = baseGetTag(value);
|
||
|
|
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is a valid array-like length.
|
||
|
|
*
|
||
|
|
* **Note:** This method is loosely based on
|
||
|
|
* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.0.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.isLength(3);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isLength(Number.MIN_VALUE);
|
||
|
|
* // => false
|
||
|
|
*
|
||
|
|
* _.isLength(Infinity);
|
||
|
|
* // => false
|
||
|
|
*
|
||
|
|
* _.isLength('3');
|
||
|
|
* // => false
|
||
|
|
*/
|
||
|
|
function isLength(value) {
|
||
|
|
return typeof value == 'number' &&
|
||
|
|
value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is the
|
||
|
|
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
|
||
|
|
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 0.1.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.isObject({});
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isObject([1, 2, 3]);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isObject(_.noop);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isObject(null);
|
||
|
|
* // => false
|
||
|
|
*/
|
||
|
|
function isObject(value) {
|
||
|
|
var type = typeof value;
|
||
|
|
return value != null && (type == 'object' || type == 'function');
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is object-like. A value is object-like if it's not `null`
|
||
|
|
* and has a `typeof` result of "object".
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.0.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.isObjectLike({});
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isObjectLike([1, 2, 3]);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isObjectLike(_.noop);
|
||
|
|
* // => false
|
||
|
|
*
|
||
|
|
* _.isObjectLike(null);
|
||
|
|
* // => false
|
||
|
|
*/
|
||
|
|
function isObjectLike(value) {
|
||
|
|
return value != null && typeof value == 'object';
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if `value` is classified as a `Symbol` primitive or object.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.0.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to check.
|
||
|
|
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.isSymbol(Symbol.iterator);
|
||
|
|
* // => true
|
||
|
|
*
|
||
|
|
* _.isSymbol('abc');
|
||
|
|
* // => false
|
||
|
|
*/
|
||
|
|
function isSymbol(value) {
|
||
|
|
return typeof value == 'symbol' ||
|
||
|
|
(isObjectLike(value) && baseGetTag(value) == symbolTag);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts `value` to a finite number.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.12.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to convert.
|
||
|
|
* @returns {number} Returns the converted number.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.toFinite(3.2);
|
||
|
|
* // => 3.2
|
||
|
|
*
|
||
|
|
* _.toFinite(Number.MIN_VALUE);
|
||
|
|
* // => 5e-324
|
||
|
|
*
|
||
|
|
* _.toFinite(Infinity);
|
||
|
|
* // => 1.7976931348623157e+308
|
||
|
|
*
|
||
|
|
* _.toFinite('3.2');
|
||
|
|
* // => 3.2
|
||
|
|
*/
|
||
|
|
function toFinite(value) {
|
||
|
|
if (!value) {
|
||
|
|
return value === 0 ? value : 0;
|
||
|
|
}
|
||
|
|
value = toNumber(value);
|
||
|
|
if (value === INFINITY || value === -INFINITY) {
|
||
|
|
var sign = (value < 0 ? -1 : 1);
|
||
|
|
return sign * MAX_INTEGER;
|
||
|
|
}
|
||
|
|
return value === value ? value : 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts `value` to an integer.
|
||
|
|
*
|
||
|
|
* **Note:** This method is loosely based on
|
||
|
|
* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.0.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to convert.
|
||
|
|
* @returns {number} Returns the converted integer.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.toInteger(3.2);
|
||
|
|
* // => 3
|
||
|
|
*
|
||
|
|
* _.toInteger(Number.MIN_VALUE);
|
||
|
|
* // => 0
|
||
|
|
*
|
||
|
|
* _.toInteger(Infinity);
|
||
|
|
* // => 1.7976931348623157e+308
|
||
|
|
*
|
||
|
|
* _.toInteger('3.2');
|
||
|
|
* // => 3
|
||
|
|
*/
|
||
|
|
function toInteger(value) {
|
||
|
|
var result = toFinite(value),
|
||
|
|
remainder = result % 1;
|
||
|
|
|
||
|
|
return result === result ? (remainder ? result - remainder : result) : 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts `value` to a number.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.0.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to process.
|
||
|
|
* @returns {number} Returns the number.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.toNumber(3.2);
|
||
|
|
* // => 3.2
|
||
|
|
*
|
||
|
|
* _.toNumber(Number.MIN_VALUE);
|
||
|
|
* // => 5e-324
|
||
|
|
*
|
||
|
|
* _.toNumber(Infinity);
|
||
|
|
* // => Infinity
|
||
|
|
*
|
||
|
|
* _.toNumber('3.2');
|
||
|
|
* // => 3.2
|
||
|
|
*/
|
||
|
|
function toNumber(value) {
|
||
|
|
if (typeof value == 'number') {
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
if (isSymbol(value)) {
|
||
|
|
return NAN;
|
||
|
|
}
|
||
|
|
if (isObject(value)) {
|
||
|
|
var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
|
||
|
|
value = isObject(other) ? (other + '') : other;
|
||
|
|
}
|
||
|
|
if (typeof value != 'string') {
|
||
|
|
return value === 0 ? value : +value;
|
||
|
|
}
|
||
|
|
value = baseTrim(value);
|
||
|
|
var isBinary = reIsBinary.test(value);
|
||
|
|
return (isBinary || reIsOctal.test(value))
|
||
|
|
? freeParseInt(value.slice(2), isBinary ? 2 : 8)
|
||
|
|
: (reIsBadHex.test(value) ? NAN : +value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts `value` to a string. An empty string is returned for `null`
|
||
|
|
* and `undefined` values. The sign of `-0` is preserved.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 4.0.0
|
||
|
|
* @category Lang
|
||
|
|
* @param {*} value The value to convert.
|
||
|
|
* @returns {string} Returns the converted string.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* _.toString(null);
|
||
|
|
* // => ''
|
||
|
|
*
|
||
|
|
* _.toString(-0);
|
||
|
|
* // => '-0'
|
||
|
|
*
|
||
|
|
* _.toString([1, 2, 3]);
|
||
|
|
* // => '1,2,3'
|
||
|
|
*/
|
||
|
|
function toString(value) {
|
||
|
|
return value == null ? '' : baseToString(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the value at `path` of `object`. If the resolved value is
|
||
|
|
* `undefined`, the `defaultValue` is returned in its place.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 3.7.0
|
||
|
|
* @category Object
|
||
|
|
* @param {Object} object The object to query.
|
||
|
|
* @param {Array|string} path The path of the property to get.
|
||
|
|
* @param {*} [defaultValue] The value returned for `undefined` resolved values.
|
||
|
|
* @returns {*} Returns the resolved value.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* var object = { 'a': [{ 'b': { 'c': 3 } }] };
|
||
|
|
*
|
||
|
|
* _.get(object, 'a[0].b.c');
|
||
|
|
* // => 3
|
||
|
|
*
|
||
|
|
* _.get(object, ['a', '0', 'b', 'c']);
|
||
|
|
* // => 3
|
||
|
|
*
|
||
|
|
* _.get(object, 'a.b.c', 'default');
|
||
|
|
* // => 'default'
|
||
|
|
*/
|
||
|
|
function get(object, path, defaultValue) {
|
||
|
|
var result = object == null ? undefined : baseGet(object, path);
|
||
|
|
return result === undefined ? defaultValue : result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
|
||
|
|
* it's created. Arrays are created for missing index properties while objects
|
||
|
|
* are created for all other missing properties. Use `_.setWith` to customize
|
||
|
|
* `path` creation.
|
||
|
|
*
|
||
|
|
* **Note:** This method mutates `object`.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @since 3.7.0
|
||
|
|
* @category Object
|
||
|
|
* @param {Object} object The object to modify.
|
||
|
|
* @param {Array|string} path The path of the property to set.
|
||
|
|
* @param {*} value The value to set.
|
||
|
|
* @returns {Object} Returns `object`.
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* var object = { 'a': [{ 'b': { 'c': 3 } }] };
|
||
|
|
*
|
||
|
|
* _.set(object, 'a[0].b.c', 4);
|
||
|
|
* console.log(object.a[0].b.c);
|
||
|
|
* // => 4
|
||
|
|
*
|
||
|
|
* _.set(object, ['x', '0', 'y', 'z'], 5);
|
||
|
|
* console.log(object.x[0].y.z);
|
||
|
|
* // => 5
|
||
|
|
*/
|
||
|
|
function set(object, path, value) {
|
||
|
|
return object == null ? object : baseSet(object, path, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
// Add methods that return wrapped values in chain sequences.
|
||
|
|
lodash.chunk = chunk;
|
||
|
|
lodash.memoize = memoize;
|
||
|
|
lodash.set = set;
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
// Add methods that return unwrapped values in chain sequences.
|
||
|
|
lodash.eq = eq;
|
||
|
|
lodash.get = get;
|
||
|
|
lodash.isArray = isArray;
|
||
|
|
lodash.isArrayLike = isArrayLike;
|
||
|
|
lodash.isFunction = isFunction;
|
||
|
|
lodash.isLength = isLength;
|
||
|
|
lodash.isObject = isObject;
|
||
|
|
lodash.isObjectLike = isObjectLike;
|
||
|
|
lodash.isSymbol = isSymbol;
|
||
|
|
lodash.toFinite = toFinite;
|
||
|
|
lodash.toInteger = toInteger;
|
||
|
|
lodash.toNumber = toNumber;
|
||
|
|
lodash.toString = toString;
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The semantic version number.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @memberOf _
|
||
|
|
* @type {string}
|
||
|
|
*/
|
||
|
|
lodash.VERSION = VERSION;
|
||
|
|
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
if (freeModule) {
|
||
|
|
// Export for Node.js.
|
||
|
|
(freeModule.exports = lodash)._ = lodash;
|
||
|
|
// Export for CommonJS support.
|
||
|
|
freeExports._ = lodash;
|
||
|
|
}
|
||
|
|
}.call(this));
|