diff --git a/dist/index.js b/dist/index.js index e1f6f99..625b967 100644 --- a/dist/index.js +++ b/dist/index.js @@ -16952,173 +16952,247 @@ module.exports={ } },{}],9:[function(require,module,exports){ +var hashClear = require('./_hashClear'), + hashDelete = require('./_hashDelete'), + hashGet = require('./_hashGet'), + hashHas = require('./_hashHas'), + hashSet = require('./_hashSet'); + /** - * lodash (Custom Build) - * Build: `lodash modularize exports="npm" -o ./` - * Copyright jQuery Foundation and other contributors - * Released under MIT license - * Based on Underscore.js 1.8.3 - * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * 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; -/** 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 argsTag = '[object Arguments]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - stringTag = '[object String]', - symbolTag = '[object Symbol]'; - -/** Used to match leading and trailing whitespace. */ -var reTrim = /^\s+|\s+$/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; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} -/** Used to detect octal string values. */ -var reIsOctal = /^0o[0-7]+$/i; +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; -/** Used to detect unsigned integer values. */ -var reIsUint = /^(?:0|[1-9]\d*)$/; +module.exports = Hash; -/** Built-in method references without a dependency on `root`. */ -var freeParseInt = parseInt; +},{"./_hashClear":51,"./_hashDelete":52,"./_hashGet":53,"./_hashHas":54,"./_hashSet":55}],10:[function(require,module,exports){ +var listCacheClear = require('./_listCacheClear'), + listCacheDelete = require('./_listCacheDelete'), + listCacheGet = require('./_listCacheGet'), + listCacheHas = require('./_listCacheHas'), + listCacheSet = require('./_listCacheSet'); /** - * A specialized version of `_.map` for arrays without support for iteratee - * shorthands. + * Creates an list cache object. * * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. + * @constructor + * @param {Array} [entries] The key-value pairs to cache. */ -function arrayMap(array, iteratee) { +function ListCache(entries) { var index = -1, - length = array ? array.length : 0, - result = Array(length); + length = entries == null ? 0 : entries.length; + this.clear(); while (++index < length) { - result[index] = iteratee(array[index], index, array); + var entry = entries[index]; + this.set(entry[0], entry[1]); } - return result; } +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +module.exports = ListCache; + +},{"./_listCacheClear":62,"./_listCacheDelete":63,"./_listCacheGet":64,"./_listCacheHas":65,"./_listCacheSet":66}],11:[function(require,module,exports){ +var getNative = require('./_getNative'), + root = require('./_root'); + +/* Built-in method references that are verified to be native. */ +var Map = getNative(root, 'Map'); + +module.exports = Map; + +},{"./_getNative":47,"./_root":79}],12:[function(require,module,exports){ +var mapCacheClear = require('./_mapCacheClear'), + mapCacheDelete = require('./_mapCacheDelete'), + mapCacheGet = require('./_mapCacheGet'), + mapCacheHas = require('./_mapCacheHas'), + mapCacheSet = require('./_mapCacheSet'); + /** - * The base implementation of `_.findIndex` and `_.findLastIndex` without - * support for iteratee shorthands. + * Creates a map cache object to store key-value pairs. * * @private - * @param {Array} array The array to inspect. - * @param {Function} predicate The function invoked per iteration. - * @param {number} fromIndex The index to search from. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {number} Returns the index of the matched value, else `-1`. + * @constructor + * @param {Array} [entries] The key-value pairs to cache. */ -function baseFindIndex(array, predicate, fromIndex, fromRight) { - var length = array.length, - index = fromIndex + (fromRight ? 1 : -1); +function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; - while ((fromRight ? index-- : ++index < length)) { - if (predicate(array[index], index, array)) { - return index; - } + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); } - return -1; } +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +module.exports = MapCache; + +},{"./_mapCacheClear":67,"./_mapCacheDelete":68,"./_mapCacheGet":69,"./_mapCacheHas":70,"./_mapCacheSet":71}],13:[function(require,module,exports){ +var root = require('./_root'); + +/** Built-in value references. */ +var Symbol = root.Symbol; + +module.exports = Symbol; + +},{"./_root":79}],14:[function(require,module,exports){ /** - * The base implementation of `_.indexOf` without `fromIndex` bounds checks. + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. * * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. + * @param {Function} func The function to invoke. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} args The arguments to invoke `func` with. + * @returns {*} Returns the result of `func`. */ -function baseIndexOf(array, value, fromIndex) { - if (value !== value) { - return baseFindIndex(array, baseIsNaN, fromIndex); - } - var index = fromIndex - 1, - length = array.length; - - while (++index < length) { - if (array[index] === value) { - return index; - } +function apply(func, thisArg, args) { + switch (args.length) { + case 0: return func.call(thisArg); + case 1: return func.call(thisArg, args[0]); + case 2: return func.call(thisArg, args[0], args[1]); + case 3: return func.call(thisArg, args[0], args[1], args[2]); } - return -1; + return func.apply(thisArg, args); } +module.exports = apply; + +},{}],15:[function(require,module,exports){ +var baseTimes = require('./_baseTimes'), + isArguments = require('./isArguments'), + isArray = require('./isArray'), + isBuffer = require('./isBuffer'), + isIndex = require('./_isIndex'), + isTypedArray = require('./isTypedArray'); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + /** - * The base implementation of `_.isNaN` without support for number objects. + * Creates an array of the enumerable property names of the array-like `value`. * * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. */ -function baseIsNaN(value) { - return value !== value; +function arrayLikeKeys(value, inherited) { + var isArr = isArray(value), + isArg = !isArr && isArguments(value), + isBuff = !isArr && !isArg && isBuffer(value), + isType = !isArr && !isArg && !isBuff && isTypedArray(value), + skipIndexes = isArr || isArg || isBuff || isType, + result = skipIndexes ? baseTimes(value.length, String) : [], + length = result.length; + + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && + !(skipIndexes && ( + // Safari 9 has enumerable `arguments.length` in strict mode. + key == 'length' || + // Node.js 0.10 has enumerable non-index properties on buffers. + (isBuff && (key == 'offset' || key == 'parent')) || + // PhantomJS 2 has enumerable non-index properties on typed arrays. + (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || + // Skip index properties. + isIndex(key, length) + ))) { + result.push(key); + } + } + return result; } +module.exports = arrayLikeKeys; + +},{"./_baseTimes":36,"./_isIndex":57,"./isArguments":93,"./isArray":94,"./isBuffer":96,"./isTypedArray":103}],16:[function(require,module,exports){ /** - * The base implementation of `_.times` without support for iteratee shorthands - * or max array length checks. + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. * * @private - * @param {number} n The number of times to invoke `iteratee`. + * @param {Array} [array] The array to iterate over. * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the array of results. + * @returns {Array} Returns the new mapped array. */ -function baseTimes(n, iteratee) { +function arrayMap(array, iteratee) { var index = -1, - result = Array(n); + length = array == null ? 0 : array.length, + result = Array(length); - while (++index < n) { - result[index] = iteratee(index); + while (++index < length) { + result[index] = iteratee(array[index], index, array); } return result; } -/** - * The base implementation of `_.values` and `_.valuesIn` which creates an - * array of `object` property values corresponding to the property names - * of `props`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} props The property names to get values for. - * @returns {Object} Returns the array of property values. - */ -function baseValues(object, props) { - return arrayMap(props, function(key) { - return object[key]; - }); -} +module.exports = arrayMap; +},{}],17:[function(require,module,exports){ /** - * Creates a unary function that invokes `func` with its argument transformed. + * Appends the elements of `values` to `array`. * * @private - * @param {Function} func The function to wrap. - * @param {Function} transform The argument transform. - * @returns {Function} Returns the new function. + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. */ -function overArg(func, transform) { - return function(arg) { - return func(transform(arg)); - }; +function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; } +module.exports = arrayPush; + +},{}],18:[function(require,module,exports){ +var baseAssignValue = require('./_baseAssignValue'), + eq = require('./eq'); + /** Used for built-in method references. */ var objectProto = Object.prototype; @@ -17126,618 +17200,1453 @@ var objectProto = Object.prototype; var hasOwnProperty = objectProto.hasOwnProperty; /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. + * 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. */ -var objectToString = objectProto.toString; +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); + } +} -/** Built-in value references. */ -var propertyIsEnumerable = objectProto.propertyIsEnumerable; +module.exports = assignValue; -/* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeKeys = overArg(Object.keys, Object), - nativeMax = Math.max; +},{"./_baseAssignValue":20,"./eq":88}],19:[function(require,module,exports){ +var eq = require('./eq'); /** - * Creates an array of the enumerable property names of the array-like `value`. + * Gets the index at which the `key` is found in `array` of key-value pairs. * * @private - * @param {*} value The value to query. - * @param {boolean} inherited Specify returning inherited property names. - * @returns {Array} Returns the array of property names. + * @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 arrayLikeKeys(value, inherited) { - // Safari 8.1 makes `arguments.callee` enumerable in strict mode. - // Safari 9 makes `arguments.length` enumerable in strict mode. - var result = (isArray(value) || isArguments(value)) - ? baseTimes(value.length, String) - : []; - - var length = result.length, - skipIndexes = !!length; - - for (var key in value) { - if ((inherited || hasOwnProperty.call(value, key)) && - !(skipIndexes && (key == 'length' || isIndex(key, length)))) { - result.push(key); +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; } } - return result; + return -1; } +module.exports = assocIndexOf; + +},{"./eq":88}],20:[function(require,module,exports){ +var defineProperty = require('./_defineProperty'); + /** - * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * The base implementation of `assignValue` and `assignMergeValue` without + * value checks. * * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. */ -function baseKeys(object) { - if (!isPrototype(object)) { - return nativeKeys(object); - } - var result = []; - for (var key in Object(object)) { - if (hasOwnProperty.call(object, key) && key != 'constructor') { - result.push(key); - } +function baseAssignValue(object, key, value) { + if (key == '__proto__' && defineProperty) { + defineProperty(object, key, { + 'configurable': true, + 'enumerable': true, + 'value': value, + 'writable': true + }); + } else { + object[key] = value; } - return result; } +module.exports = baseAssignValue; + +},{"./_defineProperty":43}],21:[function(require,module,exports){ /** - * Checks if `value` is a valid array-like index. + * The base implementation of `_.findIndex` and `_.findLastIndex` without + * support for iteratee shorthands. * * @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`. + * @param {Array} array The array to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {number} fromIndex The index to search from. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {number} Returns the index of the matched value, else `-1`. */ -function isIndex(value, length) { - length = length == null ? MAX_SAFE_INTEGER : length; - return !!length && - (typeof value == 'number' || reIsUint.test(value)) && - (value > -1 && value % 1 == 0 && value < length); +function baseFindIndex(array, predicate, fromIndex, fromRight) { + var length = array.length, + index = fromIndex + (fromRight ? 1 : -1); + + while ((fromRight ? index-- : ++index < length)) { + if (predicate(array[index], index, array)) { + return index; + } + } + return -1; } +module.exports = baseFindIndex; + +},{}],22:[function(require,module,exports){ +var arrayPush = require('./_arrayPush'), + isFlattenable = require('./_isFlattenable'); + /** - * Checks if `value` is likely a prototype object. + * The base implementation of `_.flatten` with support for restricting flattening. * * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + * @param {Array} array The array to flatten. + * @param {number} depth The maximum recursion depth. + * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. + * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. + * @param {Array} [result=[]] The initial result value. + * @returns {Array} Returns the new flattened array. */ -function isPrototype(value) { - var Ctor = value && value.constructor, - proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; +function baseFlatten(array, depth, predicate, isStrict, result) { + var index = -1, + length = array.length; - return value === proto; + predicate || (predicate = isFlattenable); + result || (result = []); + + while (++index < length) { + var value = array[index]; + if (depth > 0 && predicate(value)) { + if (depth > 1) { + // Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value, depth - 1, predicate, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + return result; } +module.exports = baseFlatten; + +},{"./_arrayPush":17,"./_isFlattenable":56}],23:[function(require,module,exports){ +var castPath = require('./_castPath'), + toKey = require('./_toKey'); + /** - * Checks if `value` is in `collection`. If `collection` is a string, it's - * checked for a substring of `value`, otherwise - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * is used for equality comparisons. If `fromIndex` is negative, it's used as - * the offset from the end of `collection`. + * The base implementation of `_.get` without support for default values. * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object|string} collection The collection to inspect. + * @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; +} + +module.exports = baseGet; + +},{"./_castPath":41,"./_toKey":84}],24:[function(require,module,exports){ +var Symbol = require('./_Symbol'), + getRawTag = require('./_getRawTag'), + objectToString = require('./_objectToString'); + +/** `Object#toString` result references. */ +var nullTag = '[object Null]', + undefinedTag = '[object Undefined]'; + +/** Built-in value references. */ +var symToStringTag = Symbol ? Symbol.toStringTag : 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); +} + +module.exports = baseGetTag; + +},{"./_Symbol":13,"./_getRawTag":48,"./_objectToString":76}],25:[function(require,module,exports){ +/** + * The base implementation of `_.hasIn` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ +function baseHasIn(object, key) { + return object != null && key in Object(object); +} + +module.exports = baseHasIn; + +},{}],26:[function(require,module,exports){ +var baseFindIndex = require('./_baseFindIndex'), + baseIsNaN = require('./_baseIsNaN'), + strictIndexOf = require('./_strictIndexOf'); + +/** + * The base implementation of `_.indexOf` without `fromIndex` bounds checks. + * + * @private + * @param {Array} array The array to inspect. * @param {*} value The value to search for. - * @param {number} [fromIndex=0] The index to search from. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. - * @returns {boolean} Returns `true` if `value` is found, else `false`. - * @example + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function baseIndexOf(array, value, fromIndex) { + return value === value + ? strictIndexOf(array, value, fromIndex) + : baseFindIndex(array, baseIsNaN, fromIndex); +} + +module.exports = baseIndexOf; + +},{"./_baseFindIndex":21,"./_baseIsNaN":28,"./_strictIndexOf":82}],27:[function(require,module,exports){ +var baseGetTag = require('./_baseGetTag'), + isObjectLike = require('./isObjectLike'); + +/** `Object#toString` result references. */ +var argsTag = '[object Arguments]'; + +/** + * The base implementation of `_.isArguments`. * - * _.includes([1, 2, 3], 1); - * // => true + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + */ +function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag; +} + +module.exports = baseIsArguments; + +},{"./_baseGetTag":24,"./isObjectLike":100}],28:[function(require,module,exports){ +/** + * The base implementation of `_.isNaN` without support for number objects. * - * _.includes([1, 2, 3], 1, 2); - * // => false + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + */ +function baseIsNaN(value) { + return value !== value; +} + +module.exports = baseIsNaN; + +},{}],29:[function(require,module,exports){ +var isFunction = require('./isFunction'), + isMasked = require('./_isMasked'), + isObject = require('./isObject'), + toSource = require('./_toSource'); + +/** + * 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\]$/; + +/** Used for built-in method references. */ +var funcProto = Function.prototype, + objectProto = Object.prototype; + +/** 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 if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** + * The base implementation of `_.isNative` without bad shim checks. * - * _.includes({ 'a': 1, 'b': 2 }, 1); - * // => true + * @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)); +} + +module.exports = baseIsNative; + +},{"./_isMasked":60,"./_toSource":85,"./isFunction":97,"./isObject":99}],30:[function(require,module,exports){ +var baseGetTag = require('./_baseGetTag'), + isLength = require('./isLength'), + isObjectLike = require('./isObjectLike'); + +/** `Object#toString` result references. */ +var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + mapTag = '[object Map]', + numberTag = '[object Number]', + objectTag = '[object Object]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + weakMapTag = '[object WeakMap]'; + +var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + +/** Used to identify `toStringTag` values of typed arrays. */ +var typedArrayTags = {}; +typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = +typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = +typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = +typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = +typedArrayTags[uint32Tag] = true; +typedArrayTags[argsTag] = typedArrayTags[arrayTag] = +typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = +typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = +typedArrayTags[errorTag] = typedArrayTags[funcTag] = +typedArrayTags[mapTag] = typedArrayTags[numberTag] = +typedArrayTags[objectTag] = typedArrayTags[regexpTag] = +typedArrayTags[setTag] = typedArrayTags[stringTag] = +typedArrayTags[weakMapTag] = false; + +/** + * The base implementation of `_.isTypedArray` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + */ +function baseIsTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; +} + +module.exports = baseIsTypedArray; + +},{"./_baseGetTag":24,"./isLength":98,"./isObjectLike":100}],31:[function(require,module,exports){ +var isPrototype = require('./_isPrototype'), + nativeKeys = require('./_nativeKeys'); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ +function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; +} + +module.exports = baseKeys; + +},{"./_isPrototype":61,"./_nativeKeys":74}],32:[function(require,module,exports){ +var basePickBy = require('./_basePickBy'), + hasIn = require('./hasIn'); + +/** + * The base implementation of `_.pick` without support for individual + * property identifiers. + * + * @private + * @param {Object} object The source object. + * @param {string[]} paths The property paths to pick. + * @returns {Object} Returns the new object. + */ +function basePick(object, paths) { + return basePickBy(object, paths, function(value, path) { + return hasIn(object, path); + }); +} + +module.exports = basePick; + +},{"./_basePickBy":33,"./hasIn":90}],33:[function(require,module,exports){ +var baseGet = require('./_baseGet'), + baseSet = require('./_baseSet'), + castPath = require('./_castPath'); + +/** + * The base implementation of `_.pickBy` without support for iteratee shorthands. + * + * @private + * @param {Object} object The source object. + * @param {string[]} paths The property paths to pick. + * @param {Function} predicate The function invoked per property. + * @returns {Object} Returns the new object. + */ +function basePickBy(object, paths, predicate) { + var index = -1, + length = paths.length, + result = {}; + + while (++index < length) { + var path = paths[index], + value = baseGet(object, path); + + if (predicate(value, path)) { + baseSet(result, castPath(path, object), value); + } + } + return result; +} + +module.exports = basePickBy; + +},{"./_baseGet":23,"./_baseSet":34,"./_castPath":41}],34:[function(require,module,exports){ +var assignValue = require('./_assignValue'), + castPath = require('./_castPath'), + isIndex = require('./_isIndex'), + isObject = require('./isObject'), + toKey = require('./_toKey'); + +/** + * 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; +} + +module.exports = baseSet; + +},{"./_assignValue":18,"./_castPath":41,"./_isIndex":57,"./_toKey":84,"./isObject":99}],35:[function(require,module,exports){ +var constant = require('./constant'), + defineProperty = require('./_defineProperty'), + identity = require('./identity'); + +/** + * The base implementation of `setToString` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ +var baseSetToString = !defineProperty ? identity : function(func, string) { + return defineProperty(func, 'toString', { + 'configurable': true, + 'enumerable': false, + 'value': constant(string), + 'writable': true + }); +}; + +module.exports = baseSetToString; + +},{"./_defineProperty":43,"./constant":87,"./identity":91}],36:[function(require,module,exports){ +/** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ +function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; +} + +module.exports = baseTimes; + +},{}],37:[function(require,module,exports){ +var Symbol = require('./_Symbol'), + arrayMap = require('./_arrayMap'), + isArray = require('./isArray'), + isSymbol = require('./isSymbol'); + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + +/** + * 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; +} + +module.exports = baseToString; + +},{"./_Symbol":13,"./_arrayMap":16,"./isArray":94,"./isSymbol":102}],38:[function(require,module,exports){ +var trimmedEndIndex = require('./_trimmedEndIndex'); + +/** Used to match leading whitespace. */ +var reTrimStart = /^\s+/; + +/** + * 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; +} + +module.exports = baseTrim; + +},{"./_trimmedEndIndex":86}],39:[function(require,module,exports){ +/** + * The base implementation of `_.unary` without support for storing metadata. + * + * @private + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + */ +function baseUnary(func) { + return function(value) { + return func(value); + }; +} + +module.exports = baseUnary; + +},{}],40:[function(require,module,exports){ +var arrayMap = require('./_arrayMap'); + +/** + * The base implementation of `_.values` and `_.valuesIn` which creates an + * array of `object` property values corresponding to the property names + * of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the array of property values. + */ +function baseValues(object, props) { + return arrayMap(props, function(key) { + return object[key]; + }); +} + +module.exports = baseValues; + +},{"./_arrayMap":16}],41:[function(require,module,exports){ +var isArray = require('./isArray'), + isKey = require('./_isKey'), + stringToPath = require('./_stringToPath'), + toString = require('./toString'); + +/** + * 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)); +} + +module.exports = castPath; + +},{"./_isKey":58,"./_stringToPath":83,"./isArray":94,"./toString":111}],42:[function(require,module,exports){ +var root = require('./_root'); + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +module.exports = coreJsData; + +},{"./_root":79}],43:[function(require,module,exports){ +var getNative = require('./_getNative'); + +var defineProperty = (function() { + try { + var func = getNative(Object, 'defineProperty'); + func({}, '', {}); + return func; + } catch (e) {} +}()); + +module.exports = defineProperty; + +},{"./_getNative":47}],44:[function(require,module,exports){ +var flatten = require('./flatten'), + overRest = require('./_overRest'), + setToString = require('./_setToString'); + +/** + * A specialized version of `baseRest` which flattens the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @returns {Function} Returns the new function. + */ +function flatRest(func) { + return setToString(overRest(func, undefined, flatten), func + ''); +} + +module.exports = flatRest; + +},{"./_overRest":78,"./_setToString":80,"./flatten":89}],45:[function(require,module,exports){ +(function (global){ +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +module.exports = freeGlobal; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],46:[function(require,module,exports){ +var isKeyable = require('./_isKeyable'); + +/** + * 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; +} + +module.exports = getMapData; + +},{"./_isKeyable":59}],47:[function(require,module,exports){ +var baseIsNative = require('./_baseIsNative'), + getValue = require('./_getValue'); + +/** + * 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; +} + +module.exports = getNative; + +},{"./_baseIsNative":29,"./_getValue":49}],48:[function(require,module,exports){ +var Symbol = require('./_Symbol'); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** 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 nativeObjectToString = objectProto.toString; + +/** Built-in value references. */ +var symToStringTag = Symbol ? Symbol.toStringTag : 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; +} + +module.exports = getRawTag; + +},{"./_Symbol":13}],49:[function(require,module,exports){ +/** + * 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]; +} + +module.exports = getValue; + +},{}],50:[function(require,module,exports){ +var castPath = require('./_castPath'), + isArguments = require('./isArguments'), + isArray = require('./isArray'), + isIndex = require('./_isIndex'), + isLength = require('./isLength'), + toKey = require('./_toKey'); + +/** + * Checks if `path` exists on `object`. * - * _.includes('abcd', 'bc'); - * // => true + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @param {Function} hasFunc The function to check properties. + * @returns {boolean} Returns `true` if `path` exists, else `false`. */ -function includes(collection, value, fromIndex, guard) { - collection = isArrayLike(collection) ? collection : values(collection); - fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0; +function hasPath(object, path, hasFunc) { + path = castPath(path, object); - var length = collection.length; - if (fromIndex < 0) { - fromIndex = nativeMax(length + fromIndex, 0); + var index = -1, + length = path.length, + result = false; + + while (++index < length) { + var key = toKey(path[index]); + if (!(result = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; } - return isString(collection) - ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1) - : (!!length && baseIndexOf(collection, value, fromIndex) > -1); + if (result || ++index != length) { + return result; + } + length = object == null ? 0 : object.length; + return !!length && isLength(length) && isIndex(key, length) && + (isArray(object) || isArguments(object)); } +module.exports = hasPath; + +},{"./_castPath":41,"./_isIndex":57,"./_toKey":84,"./isArguments":93,"./isArray":94,"./isLength":98}],51:[function(require,module,exports){ +var nativeCreate = require('./_nativeCreate'); + /** - * Checks if `value` is likely an `arguments` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - * else `false`. - * @example + * Removes all key-value entries from the hash. * - * _.isArguments(function() { return arguments; }()); - * // => true - * - * _.isArguments([1, 2, 3]); - * // => false + * @private + * @name clear + * @memberOf Hash */ -function isArguments(value) { - // Safari 8.1 makes `arguments.callee` enumerable in strict mode. - return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && - (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; } +module.exports = hashClear; + +},{"./_nativeCreate":73}],52:[function(require,module,exports){ /** - * 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 + * Removes `key` and its value from the hash. * - * _.isArray(_.noop); - * // => false + * @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`. */ -var isArray = Array.isArray; +function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; +} + +module.exports = hashDelete; + +},{}],53:[function(require,module,exports){ +var nativeCreate = require('./_nativeCreate'); + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; /** - * 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 + * Gets the hash value for `key`. * - * _.isArrayLike(_.noop); - * // => false + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. */ -function isArrayLike(value) { - return value != null && isLength(value.length) && !isFunction(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; } +module.exports = hashGet; + +},{"./_nativeCreate":73}],54:[function(require,module,exports){ +var nativeCreate = require('./_nativeCreate'); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + /** - * This method is like `_.isArrayLike` except that it also checks if `value` - * is an object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array-like object, - * else `false`. - * @example - * - * _.isArrayLikeObject([1, 2, 3]); - * // => true + * Checks if a hash value for `key` exists. * - * _.isArrayLikeObject(document.body.children); - * // => true - * - * _.isArrayLikeObject('abc'); - * // => false + * @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); +} + +module.exports = hashHas; + +},{"./_nativeCreate":73}],55:[function(require,module,exports){ +var nativeCreate = require('./_nativeCreate'); + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** + * Sets the hash `key` to `value`. * - * _.isArrayLikeObject(_.noop); - * // => false + * @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 isArrayLikeObject(value) { - return isObjectLike(value) && isArrayLike(value); +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; } +module.exports = hashSet; + +},{"./_nativeCreate":73}],56:[function(require,module,exports){ +var Symbol = require('./_Symbol'), + isArguments = require('./isArguments'), + isArray = require('./isArray'); + +/** Built-in value references. */ +var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined; + /** - * Checks if `value` is classified as a `Function` object. + * Checks if `value` is a flattenable `arguments` object or array. * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang + * @private * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - * - * _.isFunction(/abc/); - * // => false + * @returns {boolean} Returns `true` if `value` is flattenable, else `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; +function isFlattenable(value) { + return isArray(value) || isArguments(value) || + !!(spreadableSymbol && value && value[spreadableSymbol]); } +module.exports = isFlattenable; + +},{"./_Symbol":13,"./isArguments":93,"./isArray":94}],57:[function(require,module,exports){ +/** Used as references for various `Number` constants. */ +var MAX_SAFE_INTEGER = 9007199254740991; + +/** Used to detect unsigned integer values. */ +var reIsUint = /^(?:0|[1-9]\d*)$/; + /** - * 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). + * Checks if `value` is a valid array-like index. * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang + * @private * @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 + * @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 isLength(value) { - return typeof value == 'number' && - value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; +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); } +module.exports = isIndex; + +},{}],58:[function(require,module,exports){ +var isArray = require('./isArray'), + isSymbol = require('./isSymbol'); + +/** Used to match property names within property paths. */ +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; + /** - * 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('')`) + * Checks if `value` is a property name and not a property path. * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang + * @private * @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 + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. */ -function isObject(value) { +function isKey(value, object) { + if (isArray(value)) { + return false; + } var type = typeof value; - return !!value && (type == 'object' || type == 'function'); + 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)); } +module.exports = isKey; + +},{"./isArray":94,"./isSymbol":102}],59:[function(require,module,exports){ /** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". + * Checks if `value` is suitable for use as unique object key. * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang + * @private * @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 + * @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); +} + +module.exports = isKeyable; + +},{}],60:[function(require,module,exports){ +var coreJsData = require('./_coreJsData'); + +/** 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) : ''; +}()); + +/** + * Checks if `func` has its source masked. * - * _.isObjectLike(null); - * // => false + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. */ -function isObjectLike(value) { - return !!value && typeof value == 'object'; +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); } +module.exports = isMasked; + +},{"./_coreJsData":42}],61:[function(require,module,exports){ +/** Used for built-in method references. */ +var objectProto = Object.prototype; + /** - * Checks if `value` is classified as a `String` primitive or object. + * Checks if `value` is likely a prototype object. * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang + * @private * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a string, else `false`. - * @example - * - * _.isString('abc'); - * // => true - * - * _.isString(1); - * // => false + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. */ -function isString(value) { - return typeof value == 'string' || - (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag); +function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; + + return value === proto; } +module.exports = isPrototype; + +},{}],62:[function(require,module,exports){ /** - * 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 + * Removes all key-value entries from the list cache. * - * _.isSymbol('abc'); - * // => false + * @private + * @name clear + * @memberOf ListCache */ -function isSymbol(value) { - return typeof value == 'symbol' || - (isObjectLike(value) && objectToString.call(value) == symbolTag); +function listCacheClear() { + this.__data__ = []; + this.size = 0; } +module.exports = listCacheClear; + +},{}],63:[function(require,module,exports){ +var assocIndexOf = require('./_assocIndexOf'); + +/** Used for built-in method references. */ +var arrayProto = Array.prototype; + +/** Built-in value references. */ +var splice = arrayProto.splice; + /** - * 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 + * Removes `key` and its value from the list cache. * - * _.toFinite(Infinity); - * // => 1.7976931348623157e+308 - * - * _.toFinite('3.2'); - * // => 3.2 + * @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 toFinite(value) { - if (!value) { - return value === 0 ? value : 0; +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; } - value = toNumber(value); - if (value === INFINITY || value === -INFINITY) { - var sign = (value < 0 ? -1 : 1); - return sign * MAX_INTEGER; + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); } - return value === value ? value : 0; + --this.size; + return true; } +module.exports = listCacheDelete; + +},{"./_assocIndexOf":19}],64:[function(require,module,exports){ +var assocIndexOf = require('./_assocIndexOf'); + /** - * 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 + * Gets the list cache value for `key`. * - * _.toInteger('3.2'); - * // => 3 + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. */ -function toInteger(value) { - var result = toFinite(value), - remainder = result % 1; +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); - return result === result ? (remainder ? result - remainder : result) : 0; + return index < 0 ? undefined : data[index][1]; } +module.exports = listCacheGet; + +},{"./_assocIndexOf":19}],65:[function(require,module,exports){ +var assocIndexOf = require('./_assocIndexOf'); + /** - * 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 + * Checks if a list cache value for `key` exists. * - * _.toNumber(Infinity); - * // => Infinity + * @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; +} + +module.exports = listCacheHas; + +},{"./_assocIndexOf":19}],66:[function(require,module,exports){ +var assocIndexOf = require('./_assocIndexOf'); + +/** + * Sets the list cache `key` to `value`. * - * _.toNumber('3.2'); - * // => 3.2 + * @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 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; +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; } - if (typeof value != 'string') { - return value === 0 ? value : +value; - } - value = value.replace(reTrim, ''); - var isBinary = reIsBinary.test(value); - return (isBinary || reIsOctal.test(value)) - ? freeParseInt(value.slice(2), isBinary ? 2 : 8) - : (reIsBadHex.test(value) ? NAN : +value); + return this; } +module.exports = listCacheSet; + +},{"./_assocIndexOf":19}],67:[function(require,module,exports){ +var Hash = require('./_Hash'), + ListCache = require('./_ListCache'), + Map = require('./_Map'); + /** - * Creates an array of the own enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. See the - * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * for more details. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keys(new Foo); - * // => ['a', 'b'] (iteration order is not guaranteed) + * Removes all key-value entries from the map. * - * _.keys('hi'); - * // => ['0', '1'] + * @private + * @name clear + * @memberOf MapCache */ -function keys(object) { - return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); +function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; } +module.exports = mapCacheClear; + +},{"./_Hash":9,"./_ListCache":10,"./_Map":11}],68:[function(require,module,exports){ +var getMapData = require('./_getMapData'); + /** - * Creates an array of the own enumerable string keyed property values of `object`. - * - * **Note:** Non-object values are coerced to objects. + * Removes `key` and its value from the map. * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property values. - * @example + * @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; +} + +module.exports = mapCacheDelete; + +},{"./_getMapData":46}],69:[function(require,module,exports){ +var getMapData = require('./_getMapData'); + +/** + * Gets the map value for `key`. * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } + * @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); +} + +module.exports = mapCacheGet; + +},{"./_getMapData":46}],70:[function(require,module,exports){ +var getMapData = require('./_getMapData'); + +/** + * Checks if a map value for `key` exists. * - * Foo.prototype.c = 3; + * @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); +} + +module.exports = mapCacheHas; + +},{"./_getMapData":46}],71:[function(require,module,exports){ +var getMapData = require('./_getMapData'); + +/** + * Sets the map `key` to `value`. * - * _.values(new Foo); - * // => [1, 2] (iteration order is not guaranteed) + * @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; +} + +module.exports = mapCacheSet; + +},{"./_getMapData":46}],72:[function(require,module,exports){ +var memoize = require('./memoize'); + +/** Used as the maximum memoize cache size. */ +var MAX_MEMOIZE_SIZE = 500; + +/** + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. * - * _.values('hi'); - * // => ['h', 'i'] + * @private + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. */ -function values(object) { - return object ? baseValues(object, keys(object)) : []; +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; } -module.exports = includes; +module.exports = memoizeCapped; + +},{"./memoize":105}],73:[function(require,module,exports){ +var getNative = require('./_getNative'); + +/* Built-in method references that are verified to be native. */ +var nativeCreate = getNative(Object, 'create'); + +module.exports = nativeCreate; + +},{"./_getNative":47}],74:[function(require,module,exports){ +var overArg = require('./_overArg'); + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeKeys = overArg(Object.keys, Object); + +module.exports = nativeKeys; -},{}],10:[function(require,module,exports){ -/** - * lodash (Custom Build) - * Build: `lodash modularize exports="npm" -o ./` - * Copyright jQuery Foundation and other contributors - * Released under MIT license - * Based on Underscore.js 1.8.3 - * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors - */ +},{"./_overArg":77}],75:[function(require,module,exports){ +var freeGlobal = require('./_freeGlobal'); -/** Used as references for various `Number` constants. */ -var MAX_SAFE_INTEGER = 9007199254740991; +/** Detect free variable `exports`. */ +var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; -/** `Object#toString` result references. */ -var argsTag = '[object Arguments]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]'; +/** Detect free variable `module`. */ +var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; -/** Used to detect unsigned integer values. */ -var reIsUint = /^(?:0|[1-9]\d*)$/; +/** Detect the popular CommonJS extension `module.exports`. */ +var moduleExports = freeModule && freeModule.exports === freeExports; + +/** Detect free variable `process` from Node.js. */ +var freeProcess = moduleExports && freeGlobal.process; + +/** Used to access faster Node.js helpers. */ +var nodeUtil = (function() { + try { + // Use `util.types` for Node.js 10+. + var types = freeModule && freeModule.require && freeModule.require('util').types; + + if (types) { + return types; + } + + // Legacy `process.binding('util')` for Node.js < 10. + return freeProcess && freeProcess.binding && freeProcess.binding('util'); + } catch (e) {} +}()); + +module.exports = nodeUtil; + +},{"./_freeGlobal":45}],76:[function(require,module,exports){ +/** Used for built-in method references. */ +var objectProto = Object.prototype; /** - * The base implementation of `_.times` without support for iteratee shorthands - * or max array length checks. + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto.toString; + +/** + * Converts `value` to a string using `Object.prototype.toString`. * * @private - * @param {number} n The number of times to invoke `iteratee`. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the array of results. + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. */ -function baseTimes(n, iteratee) { - var index = -1, - result = Array(n); - - while (++index < n) { - result[index] = iteratee(index); - } - return result; +function objectToString(value) { + return nativeObjectToString.call(value); } +module.exports = objectToString; + +},{}],77:[function(require,module,exports){ /** * Creates a unary function that invokes `func` with its argument transformed. * @@ -17752,863 +18661,1192 @@ function overArg(func, transform) { }; } -/** Used for built-in method references. */ -var objectProto = Object.prototype; +module.exports = overArg; -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; +},{}],78:[function(require,module,exports){ +var apply = require('./_apply'); + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max; /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. + * A specialized version of `baseRest` which transforms the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @param {Function} transform The rest array transform. + * @returns {Function} Returns the new function. */ -var objectToString = objectProto.toString; +function overRest(func, start, transform) { + start = nativeMax(start === undefined ? (func.length - 1) : start, 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + array = Array(length); -/** Built-in value references. */ -var propertyIsEnumerable = objectProto.propertyIsEnumerable; + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = transform(array); + return apply(func, this, otherArgs); + }; +} + +module.exports = overRest; + +},{"./_apply":14}],79:[function(require,module,exports){ +var freeGlobal = require('./_freeGlobal'); + +/** 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')(); + +module.exports = root; + +},{"./_freeGlobal":45}],80:[function(require,module,exports){ +var baseSetToString = require('./_baseSetToString'), + shortOut = require('./_shortOut'); + +/** + * Sets the `toString` method of `func` to return `string`. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ +var setToString = shortOut(baseSetToString); + +module.exports = setToString; + +},{"./_baseSetToString":35,"./_shortOut":81}],81:[function(require,module,exports){ +/** Used to detect hot functions by number of calls within a span of milliseconds. */ +var HOT_COUNT = 800, + HOT_SPAN = 16; /* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeKeys = overArg(Object.keys, Object); +var nativeNow = Date.now; /** - * Creates an array of the enumerable property names of the array-like `value`. + * Creates a function that'll short out and invoke `identity` instead + * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` + * milliseconds. * * @private - * @param {*} value The value to query. - * @param {boolean} inherited Specify returning inherited property names. - * @returns {Array} Returns the array of property names. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new shortable function. */ -function arrayLikeKeys(value, inherited) { - // Safari 8.1 makes `arguments.callee` enumerable in strict mode. - // Safari 9 makes `arguments.length` enumerable in strict mode. - var result = (isArray(value) || isArguments(value)) - ? baseTimes(value.length, String) - : []; +function shortOut(func) { + var count = 0, + lastCalled = 0; - var length = result.length, - skipIndexes = !!length; + return function() { + var stamp = nativeNow(), + remaining = HOT_SPAN - (stamp - lastCalled); - for (var key in value) { - if ((inherited || hasOwnProperty.call(value, key)) && - !(skipIndexes && (key == 'length' || isIndex(key, length)))) { - result.push(key); + lastCalled = stamp; + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; } - } - return result; + return func.apply(undefined, arguments); + }; } +module.exports = shortOut; + +},{}],82:[function(require,module,exports){ /** - * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * A specialized version of `_.indexOf` which performs strict equality + * comparisons of values, i.e. `===`. * * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. */ -function baseKeys(object) { - if (!isPrototype(object)) { - return nativeKeys(object); +function strictIndexOf(array, value, fromIndex) { + var index = fromIndex - 1, + length = array.length; + + while (++index < length) { + if (array[index] === value) { + return index; + } } + return -1; +} + +module.exports = strictIndexOf; + +},{}],83:[function(require,module,exports){ +var memoizeCapped = require('./_memoizeCapped'); + +/** Used to match property names within property paths. */ +var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + +/** Used to match backslashes in property paths. */ +var reEscapeChar = /\\(\\)?/g; + +/** + * 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 = []; - for (var key in Object(object)) { - if (hasOwnProperty.call(object, key) && key != 'constructor') { - result.push(key); - } + 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; +}); + +module.exports = stringToPath; + +},{"./_memoizeCapped":72}],84:[function(require,module,exports){ +var isSymbol = require('./isSymbol'); + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** + * 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; } +module.exports = toKey; + +},{"./isSymbol":102}],85:[function(require,module,exports){ +/** Used for built-in method references. */ +var funcProto = Function.prototype; + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + /** - * Checks if `value` is a valid array-like index. + * Converts `func` to its source code. * * @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`. + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. */ -function isIndex(value, length) { - length = length == null ? MAX_SAFE_INTEGER : length; - return !!length && - (typeof value == 'number' || reIsUint.test(value)) && - (value > -1 && value % 1 == 0 && value < length); +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; } +module.exports = toSource; + +},{}],86:[function(require,module,exports){ +/** Used to match a single whitespace character. */ +var reWhitespace = /\s/; + /** - * Checks if `value` is likely a prototype object. + * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace + * character of `string`. * * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + * @param {string} string The string to inspect. + * @returns {number} Returns the index of the last non-whitespace character. */ -function isPrototype(value) { - var Ctor = value && value.constructor, - proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; +function trimmedEndIndex(string) { + var index = string.length; - return value === proto; + while (index-- && reWhitespace.test(string.charAt(index))) {} + return index; } +module.exports = trimmedEndIndex; + +},{}],87:[function(require,module,exports){ /** - * Checks if `value` is likely an `arguments` object. + * Creates a function that returns `value`. * * @static * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - * else `false`. + * @since 2.4.0 + * @category Util + * @param {*} value The value to return from the new function. + * @returns {Function} Returns the new constant function. * @example * - * _.isArguments(function() { return arguments; }()); - * // => true + * var objects = _.times(2, _.constant({ 'a': 1 })); * - * _.isArguments([1, 2, 3]); - * // => false + * console.log(objects); + * // => [{ 'a': 1 }, { 'a': 1 }] + * + * console.log(objects[0] === objects[1]); + * // => true */ -function isArguments(value) { - // Safari 8.1 makes `arguments.callee` enumerable in strict mode. - return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && - (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); +function constant(value) { + return function() { + return value; + }; } +module.exports = constant; + +},{}],88:[function(require,module,exports){ /** - * Checks if `value` is classified as an `Array` object. + * 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 0.1.0 + * @since 4.0.0 * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @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 * - * _.isArray([1, 2, 3]); + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); * // => true * - * _.isArray(document.body.children); + * _.eq(object, other); * // => false * - * _.isArray('abc'); - * // => false + * _.eq('a', 'a'); + * // => true * - * _.isArray(_.noop); + * _.eq('a', Object('a')); * // => false + * + * _.eq(NaN, NaN); + * // => true */ -var isArray = Array.isArray; +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +module.exports = eq; + +},{}],89:[function(require,module,exports){ +var baseFlatten = require('./_baseFlatten'); /** - * 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`. + * Flattens `array` a single level deep. * * @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`. + * @since 0.1.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. * @example * - * _.isArrayLike([1, 2, 3]); - * // => true - * - * _.isArrayLike(document.body.children); - * // => true - * - * _.isArrayLike('abc'); - * // => true - * - * _.isArrayLike(_.noop); - * // => false + * _.flatten([1, [2, [3, [4]], 5]]); + * // => [1, 2, [3, [4]], 5] */ -function isArrayLike(value) { - return value != null && isLength(value.length) && !isFunction(value); +function flatten(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, 1) : []; } +module.exports = flatten; + +},{"./_baseFlatten":22}],90:[function(require,module,exports){ +var baseHasIn = require('./_baseHasIn'), + hasPath = require('./_hasPath'); + /** - * This method is like `_.isArrayLike` except that it also checks if `value` - * is an object. + * Checks if `path` is a direct or inherited property of `object`. * * @static * @memberOf _ * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array-like object, - * else `false`. + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. * @example * - * _.isArrayLikeObject([1, 2, 3]); + * var object = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.hasIn(object, 'a'); * // => true * - * _.isArrayLikeObject(document.body.children); + * _.hasIn(object, 'a.b'); * // => true * - * _.isArrayLikeObject('abc'); - * // => false + * _.hasIn(object, ['a', 'b']); + * // => true * - * _.isArrayLikeObject(_.noop); + * _.hasIn(object, 'b'); * // => false */ -function isArrayLikeObject(value) { - return isObjectLike(value) && isArrayLike(value); +function hasIn(object, path) { + return object != null && hasPath(object, path, baseHasIn); } +module.exports = hasIn; + +},{"./_baseHasIn":25,"./_hasPath":50}],91:[function(require,module,exports){ /** - * Checks if `value` is classified as a `Function` object. + * This method returns the first argument it receives. * - * @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`. + * @static + * @since 0.1.0 + * @memberOf _ + * @category Util + * @param {*} value Any value. + * @returns {*} Returns `value`. * @example * - * _.isFunction(_); - * // => true + * var object = { 'a': 1 }; * - * _.isFunction(/abc/); - * // => false + * console.log(_.identity(object) === object); + * // => true */ -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; +function identity(value) { + return value; } +module.exports = identity; + +},{}],92:[function(require,module,exports){ +var baseIndexOf = require('./_baseIndexOf'), + isArrayLike = require('./isArrayLike'), + isString = require('./isString'), + toInteger = require('./toInteger'), + values = require('./values'); + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max; + /** - * 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). + * Checks if `value` is in `collection`. If `collection` is a string, it's + * checked for a substring of `value`, otherwise + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * is used for equality comparisons. If `fromIndex` is negative, it's used as + * the offset from the end of `collection`. * * @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`. + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {boolean} Returns `true` if `value` is found, else `false`. * @example * - * _.isLength(3); + * _.includes([1, 2, 3], 1); * // => true * - * _.isLength(Number.MIN_VALUE); + * _.includes([1, 2, 3], 1, 2); * // => false * - * _.isLength(Infinity); - * // => false + * _.includes({ 'a': 1, 'b': 2 }, 1); + * // => true * - * _.isLength('3'); - * // => false + * _.includes('abcd', 'bc'); + * // => true */ -function isLength(value) { - return typeof value == 'number' && - value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; +function includes(collection, value, fromIndex, guard) { + collection = isArrayLike(collection) ? collection : values(collection); + fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0; + + var length = collection.length; + if (fromIndex < 0) { + fromIndex = nativeMax(length + fromIndex, 0); + } + return isString(collection) + ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1) + : (!!length && baseIndexOf(collection, value, fromIndex) > -1); } +module.exports = includes; + +},{"./_baseIndexOf":26,"./isArrayLike":95,"./isString":101,"./toInteger":109,"./values":112}],93:[function(require,module,exports){ +var baseIsArguments = require('./_baseIsArguments'), + isObjectLike = require('./isObjectLike'); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** Built-in value references. */ +var propertyIsEnumerable = objectProto.propertyIsEnumerable; + /** - * 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('')`) + * Checks if `value` is likely an `arguments` object. * * @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`. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. * @example * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(_.noop); + * _.isArguments(function() { return arguments; }()); * // => true * - * _.isObject(null); + * _.isArguments([1, 2, 3]); * // => false */ -function isObject(value) { - var type = typeof value; - return !!value && (type == 'object' || type == 'function'); -} +var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && + !propertyIsEnumerable.call(value, 'callee'); +}; +module.exports = isArguments; + +},{"./_baseIsArguments":27,"./isObjectLike":100}],94:[function(require,module,exports){ /** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". + * Checks if `value` is classified as an `Array` object. * * @static * @memberOf _ - * @since 4.0.0 + * @since 0.1.0 * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. * @example * - * _.isObjectLike({}); + * _.isArray([1, 2, 3]); * // => true * - * _.isObjectLike([1, 2, 3]); - * // => true + * _.isArray(document.body.children); + * // => false * - * _.isObjectLike(_.noop); + * _.isArray('abc'); * // => false * - * _.isObjectLike(null); + * _.isArray(_.noop); * // => false */ -function isObjectLike(value) { - return !!value && typeof value == 'object'; -} +var isArray = Array.isArray; + +module.exports = isArray; + +},{}],95:[function(require,module,exports){ +var isFunction = require('./isFunction'), + isLength = require('./isLength'); /** - * Creates an array of the own enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. See the - * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * for more details. + * 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 - * @since 0.1.0 * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. * @example * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keys(new Foo); - * // => ['a', 'b'] (iteration order is not guaranteed) + * _.isArrayLike([1, 2, 3]); + * // => true * - * _.keys('hi'); - * // => ['0', '1'] - */ -function keys(object) { - return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); -} - -module.exports = keys; - -},{}],11:[function(require,module,exports){ -(function (global){ -/** - * lodash (Custom Build) - * Build: `lodash modularize exports="npm" -o ./` - * Copyright jQuery Foundation and other contributors - * Released under MIT license - * Based on Underscore.js 1.8.3 - * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors - */ - -/** Used as references for various `Number` constants. */ -var INFINITY = 1 / 0, - MAX_SAFE_INTEGER = 9007199254740991; - -/** `Object#toString` result references. */ -var argsTag = '[object Arguments]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - symbolTag = '[object Symbol]'; - -/** 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')(); - -/** - * A faster alternative to `Function#apply`, this function invokes `func` - * with the `this` binding of `thisArg` and the arguments of `args`. + * _.isArrayLike(document.body.children); + * // => true * - * @private - * @param {Function} func The function to invoke. - * @param {*} thisArg The `this` binding of `func`. - * @param {Array} args The arguments to invoke `func` with. - * @returns {*} Returns the result of `func`. - */ -function apply(func, thisArg, args) { - switch (args.length) { - case 0: return func.call(thisArg); - case 1: return func.call(thisArg, args[0]); - case 2: return func.call(thisArg, args[0], args[1]); - case 3: return func.call(thisArg, args[0], args[1], args[2]); - } - return func.apply(thisArg, args); -} - -/** - * A specialized version of `_.map` for arrays without support for iteratee - * shorthands. + * _.isArrayLike('abc'); + * // => true * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. + * _.isArrayLike(_.noop); + * // => false */ -function arrayMap(array, iteratee) { - var index = -1, - length = array ? array.length : 0, - result = Array(length); - - while (++index < length) { - result[index] = iteratee(array[index], index, array); - } - return result; +function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); } -/** - * Appends the elements of `values` to `array`. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to append. - * @returns {Array} Returns `array`. - */ -function arrayPush(array, values) { - var index = -1, - length = values.length, - offset = array.length; +module.exports = isArrayLike; - while (++index < length) { - array[offset + index] = values[index]; - } - return array; -} +},{"./isFunction":97,"./isLength":98}],96:[function(require,module,exports){ +var root = require('./_root'), + stubFalse = require('./stubFalse'); -/** Used for built-in method references. */ -var objectProto = Object.prototype; +/** Detect free variable `exports`. */ +var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; +/** Detect free variable `module`. */ +var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; -/** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ -var objectToString = objectProto.toString; +/** Detect the popular CommonJS extension `module.exports`. */ +var moduleExports = freeModule && freeModule.exports === freeExports; /** Built-in value references. */ -var Symbol = root.Symbol, - propertyIsEnumerable = objectProto.propertyIsEnumerable, - spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined; +var Buffer = moduleExports ? root.Buffer : undefined; /* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeMax = Math.max; +var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; /** - * The base implementation of `_.flatten` with support for restricting flattening. + * Checks if `value` is a buffer. * - * @private - * @param {Array} array The array to flatten. - * @param {number} depth The maximum recursion depth. - * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. - * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. - * @param {Array} [result=[]] The initial result value. - * @returns {Array} Returns the new flattened array. + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false */ -function baseFlatten(array, depth, predicate, isStrict, result) { - var index = -1, - length = array.length; +var isBuffer = nativeIsBuffer || stubFalse; - predicate || (predicate = isFlattenable); - result || (result = []); +module.exports = isBuffer; - while (++index < length) { - var value = array[index]; - if (depth > 0 && predicate(value)) { - if (depth > 1) { - // Recursively flatten arrays (susceptible to call stack limits). - baseFlatten(value, depth - 1, predicate, isStrict, result); - } else { - arrayPush(result, value); - } - } else if (!isStrict) { - result[result.length] = value; - } - } - return result; -} +},{"./_root":79,"./stubFalse":107}],97:[function(require,module,exports){ +var baseGetTag = require('./_baseGetTag'), + isObject = require('./isObject'); + +/** `Object#toString` result references. */ +var asyncTag = '[object AsyncFunction]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + proxyTag = '[object Proxy]'; /** - * The base implementation of `_.pick` without support for individual - * property identifiers. + * Checks if `value` is classified as a `Function` object. * - * @private - * @param {Object} object The source object. - * @param {string[]} props The property identifiers to pick. - * @returns {Object} Returns the new 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 basePick(object, props) { - object = Object(object); - return basePickBy(object, props, function(value, key) { - return key in object; - }); +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; } +module.exports = isFunction; + +},{"./_baseGetTag":24,"./isObject":99}],98:[function(require,module,exports){ +/** Used as references for various `Number` constants. */ +var MAX_SAFE_INTEGER = 9007199254740991; + /** - * The base implementation of `_.pickBy` without support for iteratee shorthands. + * Checks if `value` is a valid array-like length. * - * @private - * @param {Object} object The source object. - * @param {string[]} props The property identifiers to pick from. - * @param {Function} predicate The function invoked per property. - * @returns {Object} Returns the new object. + * **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 basePickBy(object, props, predicate) { - var index = -1, - length = props.length, - result = {}; - - while (++index < length) { - var key = props[index], - value = object[key]; - - if (predicate(value, key)) { - result[key] = value; - } - } - return result; +function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; } +module.exports = isLength; + +},{}],99:[function(require,module,exports){ /** - * The base implementation of `_.rest` which doesn't validate or coerce arguments. + * 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('')`) * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @returns {Function} Returns the new function. + * @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 baseRest(func, start) { - start = nativeMax(start === undefined ? (func.length - 1) : start, 0); - return function() { - var args = arguments, - index = -1, - length = nativeMax(args.length - start, 0), - array = Array(length); - - while (++index < length) { - array[index] = args[start + index]; - } - index = -1; - var otherArgs = Array(start + 1); - while (++index < start) { - otherArgs[index] = args[index]; - } - otherArgs[start] = array; - return apply(func, this, otherArgs); - }; +function isObject(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); } +module.exports = isObject; + +},{}],100:[function(require,module,exports){ /** - * Checks if `value` is a flattenable `arguments` object or array. + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". * - * @private + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. + * @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 isFlattenable(value) { - return isArray(value) || isArguments(value) || - !!(spreadableSymbol && value && value[spreadableSymbol]); +function isObjectLike(value) { + return value != null && typeof value == 'object'; } +module.exports = isObjectLike; + +},{}],101:[function(require,module,exports){ +var baseGetTag = require('./_baseGetTag'), + isArray = require('./isArray'), + isObjectLike = require('./isObjectLike'); + +/** `Object#toString` result references. */ +var stringTag = '[object String]'; + /** - * Converts `value` to a string key if it's not a string or symbol. + * Checks if `value` is classified as a `String` primitive or object. * - * @private - * @param {*} value The value to inspect. - * @returns {string|symbol} Returns the key. + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false */ -function toKey(value) { - if (typeof value == 'string' || isSymbol(value)) { - return value; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +function isString(value) { + return typeof value == 'string' || + (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); } +module.exports = isString; + +},{"./_baseGetTag":24,"./isArray":94,"./isObjectLike":100}],102:[function(require,module,exports){ +var baseGetTag = require('./_baseGetTag'), + isObjectLike = require('./isObjectLike'); + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + /** - * Checks if `value` is likely an `arguments` object. + * Checks if `value` is classified as a `Symbol` primitive or object. * * @static * @memberOf _ - * @since 0.1.0 + * @since 4.0.0 * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - * else `false`. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. * @example * - * _.isArguments(function() { return arguments; }()); + * _.isSymbol(Symbol.iterator); * // => true * - * _.isArguments([1, 2, 3]); + * _.isSymbol('abc'); * // => false */ -function isArguments(value) { - // Safari 8.1 makes `arguments.callee` enumerable in strict mode. - return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && - (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); } +module.exports = isSymbol; + +},{"./_baseGetTag":24,"./isObjectLike":100}],103:[function(require,module,exports){ +var baseIsTypedArray = require('./_baseIsTypedArray'), + baseUnary = require('./_baseUnary'), + nodeUtil = require('./_nodeUtil'); + +/* Node.js helper references. */ +var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; + /** - * Checks if `value` is classified as an `Array` object. + * Checks if `value` is classified as a typed array. * * @static * @memberOf _ - * @since 0.1.0 + * @since 3.0.0 * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. * @example * - * _.isArray([1, 2, 3]); + * _.isTypedArray(new Uint8Array); * // => true * - * _.isArray(document.body.children); + * _.isTypedArray([]); * // => false + */ +var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + +module.exports = isTypedArray; + +},{"./_baseIsTypedArray":30,"./_baseUnary":39,"./_nodeUtil":75}],104:[function(require,module,exports){ +var arrayLikeKeys = require('./_arrayLikeKeys'), + baseKeys = require('./_baseKeys'), + isArrayLike = require('./isArrayLike'); + +/** + * Creates an array of the own enumerable property names of `object`. * - * _.isArray('abc'); - * // => false + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. * - * _.isArray(_.noop); - * // => false + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] */ -var isArray = Array.isArray; +function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); +} + +module.exports = keys; + +},{"./_arrayLikeKeys":15,"./_baseKeys":31,"./isArrayLike":95}],105:[function(require,module,exports){ +var MapCache = require('./_MapCache'); + +/** Error message constants. */ +var FUNC_ERROR_TEXT = 'Expected a function'; /** - * 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`. + * 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 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @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 * - * _.isArrayLike([1, 2, 3]); - * // => true + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; * - * _.isArrayLike(document.body.children); - * // => true + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] * - * _.isArrayLike('abc'); - * // => true + * values(other); + * // => [3, 4] * - * _.isArrayLike(_.noop); - * // => false + * 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 isArrayLike(value) { - return value != null && isLength(value.length) && !isFunction(value); +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; + +module.exports = memoize; + +},{"./_MapCache":12}],106:[function(require,module,exports){ +var basePick = require('./_basePick'), + flatRest = require('./_flatRest'); + /** - * This method is like `_.isArrayLike` except that it also checks if `value` - * is an object. + * Creates an object composed of the picked `object` properties. * * @static + * @since 0.1.0 * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array-like object, - * else `false`. + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new object. * @example * - * _.isArrayLikeObject([1, 2, 3]); - * // => true - * - * _.isArrayLikeObject(document.body.children); - * // => true - * - * _.isArrayLikeObject('abc'); - * // => false + * var object = { 'a': 1, 'b': '2', 'c': 3 }; * - * _.isArrayLikeObject(_.noop); - * // => false + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } */ -function isArrayLikeObject(value) { - return isObjectLike(value) && isArrayLike(value); -} +var pick = flatRest(function(object, paths) { + return object == null ? {} : basePick(object, paths); +}); + +module.exports = pick; +},{"./_basePick":32,"./_flatRest":44}],107:[function(require,module,exports){ /** - * Checks if `value` is classified as a `Function` object. + * This method returns `false`. * * @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`. + * @since 4.13.0 + * @category Util + * @returns {boolean} Returns `false`. * @example * - * _.isFunction(_); - * // => true - * - * _.isFunction(/abc/); - * // => false + * _.times(2, _.stubFalse); + * // => [false, 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; +function stubFalse() { + return false; } +module.exports = stubFalse; + +},{}],108:[function(require,module,exports){ +var toNumber = require('./toNumber'); + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0, + MAX_INTEGER = 1.7976931348623157e+308; + /** - * 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). + * Converts `value` to a finite number. * * @static * @memberOf _ - * @since 4.0.0 + * @since 4.12.0 * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @param {*} value The value to convert. + * @returns {number} Returns the converted number. * @example * - * _.isLength(3); - * // => true + * _.toFinite(3.2); + * // => 3.2 * - * _.isLength(Number.MIN_VALUE); - * // => false + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 * - * _.isLength(Infinity); - * // => false + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 * - * _.isLength('3'); - * // => false + * _.toFinite('3.2'); + * // => 3.2 */ -function isLength(value) { - return typeof value == 'number' && - value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; +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; } +module.exports = toFinite; + +},{"./toNumber":110}],109:[function(require,module,exports){ +var toFinite = require('./toFinite'); + /** - * 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('')`) + * 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 0.1.0 + * @since 4.0.0 * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. * @example * - * _.isObject({}); - * // => true + * _.toInteger(3.2); + * // => 3 * - * _.isObject([1, 2, 3]); - * // => true + * _.toInteger(Number.MIN_VALUE); + * // => 0 * - * _.isObject(_.noop); - * // => true + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 * - * _.isObject(null); - * // => false + * _.toInteger('3.2'); + * // => 3 */ -function isObject(value) { - var type = typeof value; - return !!value && (type == 'object' || type == 'function'); +function toInteger(value) { + var result = toFinite(value), + remainder = result % 1; + + return result === result ? (remainder ? result - remainder : result) : 0; } +module.exports = toInteger; + +},{"./toFinite":108}],110:[function(require,module,exports){ +var baseTrim = require('./_baseTrim'), + isObject = require('./isObject'), + isSymbol = require('./isSymbol'); + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** 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 octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + /** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". + * Converts `value` to a number. * * @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`. + * @param {*} value The value to process. + * @returns {number} Returns the number. * @example * - * _.isObjectLike({}); - * // => true + * _.toNumber(3.2); + * // => 3.2 * - * _.isObjectLike([1, 2, 3]); - * // => true + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 * - * _.isObjectLike(_.noop); - * // => false + * _.toNumber(Infinity); + * // => Infinity * - * _.isObjectLike(null); - * // => false + * _.toNumber('3.2'); + * // => 3.2 */ -function isObjectLike(value) { - return !!value && typeof value == 'object'; +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); } +module.exports = toNumber; + +},{"./_baseTrim":38,"./isObject":99,"./isSymbol":102}],111:[function(require,module,exports){ +var baseToString = require('./_baseToString'); + /** - * Checks if `value` is classified as a `Symbol` primitive or object. + * 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 check. - * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. * @example * - * _.isSymbol(Symbol.iterator); - * // => true + * _.toString(null); + * // => '' * - * _.isSymbol('abc'); - * // => false + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' */ -function isSymbol(value) { - return typeof value == 'symbol' || - (isObjectLike(value) && objectToString.call(value) == symbolTag); +function toString(value) { + return value == null ? '' : baseToString(value); } +module.exports = toString; + +},{"./_baseToString":37}],112:[function(require,module,exports){ +var baseValues = require('./_baseValues'), + keys = require('./keys'); + /** - * Creates an object composed of the picked `object` properties. + * Creates an array of the own enumerable string keyed property values of `object`. + * + * **Note:** Non-object values are coerced to objects. * * @static * @since 0.1.0 * @memberOf _ * @category Object - * @param {Object} object The source object. - * @param {...(string|string[])} [props] The property identifiers to pick. - * @returns {Object} Returns the new object. + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. * @example * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * function Foo() { + * this.a = 1; + * this.b = 2; + * } * - * _.pick(object, ['a', 'c']); - * // => { 'a': 1, 'c': 3 } + * Foo.prototype.c = 3; + * + * _.values(new Foo); + * // => [1, 2] (iteration order is not guaranteed) + * + * _.values('hi'); + * // => ['h', 'i'] */ -var pick = baseRest(function(object, props) { - return object == null ? {} : basePick(object, arrayMap(baseFlatten(props, 1), toKey)); -}); +function values(object) { + return object == null ? [] : baseValues(object, keys(object)); +} -module.exports = pick; +module.exports = values; -}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{}],12:[function(require,module,exports){ +},{"./_baseValues":40,"./keys":104}],113:[function(require,module,exports){ /** * Copyright 2016 IBM Corp. All Rights Reserved. * @@ -18634,7 +19872,7 @@ module.exports = { 'ko': require('./ko') }; -},{"./en":13,"./es":14,"./ja":16,"./ko":17}],13:[function(require,module,exports){ +},{"./en":114,"./es":115,"./ja":117,"./ko":118}],114:[function(require,module,exports){ 'use strict'; /** * Copyright 2016 IBM Corp. All Rights Reserved. @@ -18656,7 +19894,7 @@ module.exports = { module.exports = require('../../../locales/v2/en.json'); -},{"../../../locales/v2/en.json":1}],14:[function(require,module,exports){ +},{"../../../locales/v2/en.json":1}],115:[function(require,module,exports){ 'use strict'; /** * Copyright 2016 IBM Corp. All Rights Reserved. @@ -18678,7 +19916,7 @@ module.exports = require('../../../locales/v2/en.json'); module.exports = require('../../../locales/v2/es.json'); -},{"../../../locales/v2/es.json":2}],15:[function(require,module,exports){ +},{"../../../locales/v2/es.json":2}],116:[function(require,module,exports){ /** * Copyright 2016 IBM Corp. All Rights Reserved. * @@ -18701,8 +19939,8 @@ var _createClass = function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var includes = require('lodash.includes'); -var keys = require('lodash.keys'); +var includes = require('lodash/includes'); +var keys = require('lodash/keys'); var dictionaries = require('./dictionaries'); var I18nData = function () { @@ -18778,7 +20016,7 @@ var I18nData = function () { module.exports = I18nData; -},{"./dictionaries":12,"lodash.includes":9,"lodash.keys":10}],16:[function(require,module,exports){ +},{"./dictionaries":113,"lodash/includes":92,"lodash/keys":104}],117:[function(require,module,exports){ 'use strict'; /** * Copyright 2016 IBM Corp. All Rights Reserved. @@ -18800,7 +20038,7 @@ module.exports = I18nData; module.exports = require('../../../locales/v2/ja.json'); -},{"../../../locales/v2/ja.json":3}],17:[function(require,module,exports){ +},{"../../../locales/v2/ja.json":3}],118:[function(require,module,exports){ 'use strict'; /** * Copyright 2016 IBM Corp. All Rights Reserved. @@ -18822,9 +20060,9 @@ module.exports = require('../../../locales/v2/ja.json'); module.exports = require('../../../locales/v2/ko.json'); -},{"../../../locales/v2/ko.json":4}],18:[function(require,module,exports){ -arguments[4][12][0].apply(exports,arguments) -},{"./en":19,"./es":20,"./ja":22,"./ko":23,"dup":12}],19:[function(require,module,exports){ +},{"../../../locales/v2/ko.json":4}],119:[function(require,module,exports){ +arguments[4][113][0].apply(exports,arguments) +},{"./en":120,"./es":121,"./ja":123,"./ko":124,"dup":113}],120:[function(require,module,exports){ 'use strict'; /** * Copyright 2016 IBM Corp. All Rights Reserved. @@ -18846,7 +20084,7 @@ arguments[4][12][0].apply(exports,arguments) module.exports = require('../../../locales/v3/en.json'); -},{"../../../locales/v3/en.json":5}],20:[function(require,module,exports){ +},{"../../../locales/v3/en.json":5}],121:[function(require,module,exports){ 'use strict'; /** * Copyright 2016 IBM Corp. All Rights Reserved. @@ -18868,7 +20106,7 @@ module.exports = require('../../../locales/v3/en.json'); module.exports = require('../../../locales/v3/es.json'); -},{"../../../locales/v3/es.json":6}],21:[function(require,module,exports){ +},{"../../../locales/v3/es.json":6}],122:[function(require,module,exports){ /** * Copyright 2016 IBM Corp. All Rights Reserved. * @@ -18891,8 +20129,8 @@ var _createClass = function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var includes = require('lodash.includes'); -var keys = require('lodash.keys'); +var includes = require('lodash/includes'); +var keys = require('lodash/keys'); var dictionaries = require('./dictionaries'); var I18nData = function () { @@ -18968,7 +20206,7 @@ var I18nData = function () { module.exports = I18nData; -},{"./dictionaries":18,"lodash.includes":9,"lodash.keys":10}],22:[function(require,module,exports){ +},{"./dictionaries":119,"lodash/includes":92,"lodash/keys":104}],123:[function(require,module,exports){ 'use strict'; /** * Copyright 2016 IBM Corp. All Rights Reserved. @@ -18990,7 +20228,7 @@ module.exports = I18nData; module.exports = require('../../../locales/v3/ja.json'); -},{"../../../locales/v3/ja.json":7}],23:[function(require,module,exports){ +},{"../../../locales/v3/ja.json":7}],124:[function(require,module,exports){ 'use strict'; /** * Copyright 2016 IBM Corp. All Rights Reserved. @@ -19012,7 +20250,7 @@ module.exports = require('../../../locales/v3/ja.json'); module.exports = require('../../../locales/v3/ko.json'); -},{"../../../locales/v3/ko.json":8}],24:[function(require,module,exports){ +},{"../../../locales/v3/ko.json":8}],125:[function(require,module,exports){ /** * Copyright 2015 IBM Corp. All Rights Reserved. * @@ -19039,7 +20277,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var pick = require('lodash.pick'); +var pick = require('lodash/pick'); var I18nDataV2 = require('./i18n/v2'); var I18nDataV3 = require('./i18n/v3'); var PersonalityProfileV2 = require('./profiles/v2/index'); @@ -19073,7 +20311,7 @@ var TextSummary = function (_TextSummaryImpl) { module.exports = TextSummary; -},{"./i18n/v2":15,"./i18n/v3":21,"./profiles/v2/index":25,"./profiles/v3/index":26,"./text-summary":27,"lodash.pick":11}],25:[function(require,module,exports){ +},{"./i18n/v2":116,"./i18n/v3":122,"./profiles/v2/index":126,"./profiles/v3/index":127,"./text-summary":128,"lodash/pick":106}],126:[function(require,module,exports){ /** * Copyright 2016 IBM Corp. All Rights Reserved. * @@ -19158,7 +20396,7 @@ var PersonalityProfile = function () { module.exports = PersonalityProfile; -},{}],26:[function(require,module,exports){ +},{}],127:[function(require,module,exports){ /** * Copyright 2016 IBM Corp. All Rights Reserved. * @@ -19241,7 +20479,7 @@ var PersonalityProfile = function () { module.exports = PersonalityProfile; -},{}],27:[function(require,module,exports){ +},{}],128:[function(require,module,exports){ /** * Copyright 2015 IBM Corp. All Rights Reserved. * @@ -19626,7 +20864,7 @@ var TextSummaryImpl = function () { module.exports = TextSummaryImpl; -},{"./utilities/comparators":28,"./utilities/format":29}],28:[function(require,module,exports){ +},{"./utilities/comparators":129,"./utilities/format":130}],129:[function(require,module,exports){ "use strict"; /** @@ -19678,7 +20916,7 @@ module.exports = { compareByValue: compareByValue }; -},{}],29:[function(require,module,exports){ +},{}],130:[function(require,module,exports){ 'use strict'; /** @@ -19728,5 +20966,5 @@ function format(subject) { module.exports = format; -},{}]},{},[24])(24) +},{}]},{},[125])(125) }); \ No newline at end of file diff --git a/lib/i18n/v2/index.js b/lib/i18n/v2/index.js index a098c6c..98be98a 100644 --- a/lib/i18n/v2/index.js +++ b/lib/i18n/v2/index.js @@ -20,8 +20,8 @@ var _createClass = function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var includes = require('lodash.includes'); -var keys = require('lodash.keys'); +var includes = require('lodash/includes'); +var keys = require('lodash/keys'); var dictionaries = require('./dictionaries'); var I18nData = function () { diff --git a/lib/i18n/v3/index.js b/lib/i18n/v3/index.js index 471bb4a..d413750 100644 --- a/lib/i18n/v3/index.js +++ b/lib/i18n/v3/index.js @@ -20,8 +20,8 @@ var _createClass = function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var includes = require('lodash.includes'); -var keys = require('lodash.keys'); +var includes = require('lodash/includes'); +var keys = require('lodash/keys'); var dictionaries = require('./dictionaries'); var I18nData = function () { diff --git a/lib/index-v2.js b/lib/index-v2.js index a887e20..2a3ca42 100644 --- a/lib/index-v2.js +++ b/lib/index-v2.js @@ -24,7 +24,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var pick = require('lodash.pick'); +var pick = require('lodash/pick'); var I18nDataV2 = require('./i18n/v2'); var PersonalityProfileV2 = require('./profiles/v2/index'); var TextSummaryImpl = require('./text-summary'); diff --git a/lib/index-v3.js b/lib/index-v3.js index 4acd8a4..d70c2a8 100644 --- a/lib/index-v3.js +++ b/lib/index-v3.js @@ -24,7 +24,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var pick = require('lodash.pick'); +var pick = require('lodash/pick'); var I18nDataV3 = require('./i18n/v3'); var PersonalityProfileV3 = require('./profiles/v3/index'); var TextSummaryImpl = require('./text-summary'); diff --git a/lib/index.js b/lib/index.js index 4f3afe3..5a8b533 100644 --- a/lib/index.js +++ b/lib/index.js @@ -24,7 +24,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var pick = require('lodash.pick'); +var pick = require('lodash/pick'); var I18nDataV2 = require('./i18n/v2'); var I18nDataV3 = require('./i18n/v3'); var PersonalityProfileV2 = require('./profiles/v2/index'); diff --git a/package-lock.json b/package-lock.json index 84ed730..ce42c83 100644 --- a/package-lock.json +++ b/package-lock.json @@ -3822,10 +3822,9 @@ } }, "lodash": { - "version": "4.17.5", - "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.5.tgz", - "integrity": "sha512-svL3uiZf1RwhH+cWrfZn3A4+U58wbP0tGVTLQPbjplZxZ8ROD9VLuNgsRniTlLe7OlSqR79RUehXgpBW/s0IQw==", - "dev": true + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==" }, "lodash._baseassign": { "version": "3.2.0", @@ -3885,11 +3884,6 @@ "lodash._isiterateecall": "^3.0.0" } }, - "lodash.includes": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz", - "integrity": "sha1-YLuYqHy5I8aMoeUTJUgzFISfVT8=" - }, "lodash.isarguments": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz", @@ -3902,22 +3896,12 @@ "integrity": "sha1-eeTriMNqgSKvhvhEqpvNhRtfu1U=", "dev": true }, - "lodash.keys": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-4.2.0.tgz", - "integrity": "sha1-oIYCrBLk+4P5H8H7ejYKTZujUgU=" - }, "lodash.memoize": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-3.0.4.tgz", "integrity": "sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=", "dev": true }, - "lodash.pick": { - "version": "4.4.0", - "resolved": "https://registry.npmjs.org/lodash.pick/-/lodash.pick-4.4.0.tgz", - "integrity": "sha1-UvBWEP/53tQiYRRB7R/BI6AwAbM=" - }, "longest": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/longest/-/longest-1.0.1.tgz", diff --git a/package.json b/package.json index e23fe61..cee74e6 100644 --- a/package.json +++ b/package.json @@ -27,9 +27,7 @@ "ibm watson" ], "dependencies": { - "lodash.includes": "^4.3.0", - "lodash.keys": "^4.2.0", - "lodash.pick": "^4.4.0" + "lodash": "^4.17.21" }, "devDependencies": { "babel-preset-es2015": "^6.22.0", diff --git a/src/i18n/v2/index.js b/src/i18n/v2/index.js index 1c70af8..24e195b 100644 --- a/src/i18n/v2/index.js +++ b/src/i18n/v2/index.js @@ -16,8 +16,8 @@ 'use strict'; -const includes = require('lodash.includes'); -const keys = require('lodash.keys'); +const includes = require('lodash/includes'); +const keys = require('lodash/keys'); const dictionaries = require('./dictionaries'); class I18nData { diff --git a/src/i18n/v3/index.js b/src/i18n/v3/index.js index 6d1531e..739bd13 100644 --- a/src/i18n/v3/index.js +++ b/src/i18n/v3/index.js @@ -16,8 +16,8 @@ 'use strict'; -const includes = require('lodash.includes'); -const keys = require('lodash.keys'); +const includes = require('lodash/includes'); +const keys = require('lodash/keys'); const dictionaries = require('./dictionaries'); class I18nData { diff --git a/src/index-v2.js b/src/index-v2.js index 9d66ef1..0efc57f 100644 --- a/src/index-v2.js +++ b/src/index-v2.js @@ -16,7 +16,7 @@ 'use strict'; -const pick = require('lodash.pick'); +const pick = require('lodash/pick'); const I18nDataV2 = require('./i18n/v2'); const PersonalityProfileV2 = require('./profiles/v2/index'); const TextSummaryImpl = require('./text-summary'); diff --git a/src/index-v3.js b/src/index-v3.js index ec23c28..ef6ced5 100644 --- a/src/index-v3.js +++ b/src/index-v3.js @@ -16,7 +16,7 @@ 'use strict'; -const pick = require('lodash.pick'); +const pick = require('lodash/pick'); const I18nDataV3 = require('./i18n/v3'); const PersonalityProfileV3 = require('./profiles/v3/index'); const TextSummaryImpl = require('./text-summary'); diff --git a/src/index.js b/src/index.js index 9d4df21..4de8094 100644 --- a/src/index.js +++ b/src/index.js @@ -16,7 +16,7 @@ 'use strict'; -const pick = require('lodash.pick'); +const pick = require('lodash/pick'); const I18nDataV2 = require('./i18n/v2'); const I18nDataV3 = require('./i18n/v3'); const PersonalityProfileV2 = require('./profiles/v2/index');