/**
|
* lodash (Custom Build) <https://lodash.com/>
|
* Build: `lodash modularize exports="npm" -o ./`
|
* Copyright jQuery Foundation and other contributors <https://jquery.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
|
*/
|
|
/** Used as the `TypeError` message for "Functions" methods. */
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
|
/** Used to stand-in for `undefined` hash values. */
|
var HASH_UNDEFINED = '__lodash_hash_undefined__';
|
|
/** `Object#toString` result references. */
|
var funcTag = '[object Function]',
|
genTag = '[object GeneratorFunction]';
|
|
/**
|
* Used to match `RegExp`
|
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
|
*/
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
|
/** Used to detect host constructors (Safari). */
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
/** 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')();
|
|
/**
|
* Gets the value at `key` of `object`.
|
*
|
* @private
|
* @param {Object} [object] The object to query.
|
* @param {string} key The key of the property to get.
|
* @returns {*} Returns the property value.
|
*/
|
function getValue(object, key) {
|
return object == null ? undefined : object[key];
|
}
|
|
/**
|
* Checks if `value` is a host object in IE < 9.
|
*
|
* @private
|
* @param {*} value The value to check.
|
* @returns {boolean} Returns `true` if `value` is a host object, else `false`.
|
*/
|
function isHostObject(value) {
|
// Many host objects are `Object` objects that can coerce to strings
|
// despite having improperly defined `toString` methods.
|
var result = false;
|
if (value != null && typeof value.toString != 'function') {
|
try {
|
result = !!(value + '');
|
} catch (e) {}
|
}
|
return result;
|
}
|
|
/** 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 detect methods masquerading as native. */
|
var maskSrcKey = (function() {
|
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
|
return uid ? ('Symbol(src)_1.' + uid) : '';
|
}());
|
|
/** Used to resolve the decompiled source of functions. */
|
var funcToString = funcProto.toString;
|
|
/** Used to check objects for own properties. */
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
/**
|
* Used to resolve the
|
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
|
* of values.
|
*/
|
var objectToString = 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 splice = arrayProto.splice;
|
|
/* Built-in method references that are verified to be native. */
|
var Map = getNative(root, 'Map'),
|
nativeCreate = getNative(Object, 'create');
|
|
/**
|
* Creates a hash object.
|
*
|
* @private
|
* @constructor
|
* @param {Array} [entries] The key-value pairs to cache.
|
*/
|
function Hash(entries) {
|
var index = -1,
|
length = entries ? entries.length : 0;
|
|
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) : {};
|
}
|
|
/**
|
* 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) {
|
return this.has(key) && delete this.__data__[key];
|
}
|
|
/**
|
* 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__;
|
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 ? entries.length : 0;
|
|
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__ = [];
|
}
|
|
/**
|
* 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);
|
}
|
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) {
|
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 ? entries.length : 0;
|
|
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.__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) {
|
return getMapData(this, key)['delete'](key);
|
}
|
|
/**
|
* 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) {
|
getMapData(this, key).set(key, value);
|
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;
|
|
/**
|
* 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 `_.isNative` without bad shim checks.
|
*
|
* @private
|
* @param {*} value The value to check.
|
* @returns {boolean} Returns `true` if `value` is a native function,
|
* else `false`.
|
*/
|
function baseIsNative(value) {
|
if (!isObject(value) || isMasked(value)) {
|
return false;
|
}
|
var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
|
return pattern.test(toSource(value));
|
}
|
|
/**
|
* 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;
|
}
|
|
/**
|
* 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);
|
}
|
|
/**
|
* Converts `func` to its source code.
|
*
|
* @private
|
* @param {Function} func The function to process.
|
* @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 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 `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 && 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);
|
return result;
|
};
|
memoized.cache = new (memoize.Cache || MapCache);
|
return memoized;
|
}
|
|
// Assign cache to `_.memoize`.
|
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 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) {
|
// The use of `Object#toString` avoids issues with the `typeof` operator
|
// in Safari 8-9 which returns 'object' for typed array and other constructors.
|
var tag = isObject(value) ? objectToString.call(value) : '';
|
return tag == funcTag || tag == genTag;
|
}
|
|
/**
|
* 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 && (type == 'object' || type == 'function');
|
}
|
|
module.exports = memoize;
|
