| /** |
| * lodash (Custom Build) <https://lodash.com/> |
| * Build: `lodash modularize exports="npm" -o ./` |
| * Copyright jQuery Foundation and other contributors <https://jquery.org/> |
| * Released under MIT license <https://lodash.com/license> |
| * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE> |
| * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| */ |
| |
| /** Used as references for various `Number` constants. */ |
| var MAX_SAFE_INTEGER = 9007199254740991; |
| |
| /** `Object#toString` result references. */ |
| var argsTag = '[object Arguments]', |
| funcTag = '[object Function]', |
| genTag = '[object GeneratorFunction]'; |
| |
| /** Used to detect unsigned integer values. */ |
| var reIsUint = /^(?:0|[1-9]\d*)$/; |
| |
| /** |
| * A faster alternative to `Function#apply`, this function invokes `func` |
| * with the `this` binding of `thisArg` and the arguments of `args`. |
| * |
| * @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); |
| } |
| |
| /** |
| * 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; |
| } |
| |
| /** |
| * Creates a unary function that invokes `func` with its argument transformed. |
| * |
| * @private |
| * @param {Function} func The function to wrap. |
| * @param {Function} transform The argument transform. |
| * @returns {Function} Returns the new function. |
| */ |
| function overArg(func, transform) { |
| return function(arg) { |
| return func(transform(arg)); |
| }; |
| } |
| |
| /** 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 objectToString = objectProto.toString; |
| |
| /** Built-in value references. */ |
| var propertyIsEnumerable = objectProto.propertyIsEnumerable; |
| |
| /* Built-in method references for those with the same name as other `lodash` methods. */ |
| var nativeKeys = overArg(Object.keys, Object), |
| nativeMax = Math.max; |
| |
| /** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */ |
| var nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf'); |
| |
| /** |
| * Creates an array of the enumerable property names of the array-like `value`. |
| * |
| * @private |
| * @param {*} value The value to query. |
| * @param {boolean} inherited Specify returning inherited property names. |
| * @returns {Array} Returns the array of property names. |
| */ |
| 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); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Assigns `value` to `key` of `object` if the existing value is not equivalent |
| * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) |
| * for equality comparisons. |
| * |
| * @private |
| * @param {Object} object The object to modify. |
| * @param {string} key The key of the property to assign. |
| * @param {*} value The value to assign. |
| */ |
| function assignValue(object, key, value) { |
| var objValue = object[key]; |
| if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || |
| (value === undefined && !(key in object))) { |
| object[key] = value; |
| } |
| } |
| |
| /** |
| * 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; |
| } |
| |
| /** |
| * The base implementation of `_.rest` which doesn't validate or coerce arguments. |
| * |
| * @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. |
| */ |
| 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); |
| }; |
| } |
| |
| /** |
| * Copies properties of `source` to `object`. |
| * |
| * @private |
| * @param {Object} source The object to copy properties from. |
| * @param {Array} props The property identifiers to copy. |
| * @param {Object} [object={}] The object to copy properties to. |
| * @param {Function} [customizer] The function to customize copied values. |
| * @returns {Object} Returns `object`. |
| */ |
| function copyObject(source, props, object, customizer) { |
| object || (object = {}); |
| |
| var index = -1, |
| length = props.length; |
| |
| while (++index < length) { |
| var key = props[index]; |
| |
| var newValue = customizer |
| ? customizer(object[key], source[key], key, object, source) |
| : undefined; |
| |
| assignValue(object, key, newValue === undefined ? source[key] : newValue); |
| } |
| return object; |
| } |
| |
| /** |
| * Creates a function like `_.assign`. |
| * |
| * @private |
| * @param {Function} assigner The function to assign values. |
| * @returns {Function} Returns the new assigner function. |
| */ |
| function createAssigner(assigner) { |
| return baseRest(function(object, sources) { |
| var index = -1, |
| length = sources.length, |
| customizer = length > 1 ? sources[length - 1] : undefined, |
| guard = length > 2 ? sources[2] : undefined; |
| |
| customizer = (assigner.length > 3 && typeof customizer == 'function') |
| ? (length--, customizer) |
| : undefined; |
| |
| if (guard && isIterateeCall(sources[0], sources[1], guard)) { |
| customizer = length < 3 ? undefined : customizer; |
| length = 1; |
| } |
| object = Object(object); |
| while (++index < length) { |
| var source = sources[index]; |
| if (source) { |
| assigner(object, source, index, customizer); |
| } |
| } |
| return object; |
| }); |
| } |
| |
| /** |
| * Checks if `value` is a valid array-like index. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. |
| * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. |
| */ |
| function isIndex(value, length) { |
| length = length == null ? MAX_SAFE_INTEGER : length; |
| return !!length && |
| (typeof value == 'number' || reIsUint.test(value)) && |
| (value > -1 && value % 1 == 0 && value < length); |
| } |
| |
| /** |
| * Checks if the given arguments are from an iteratee call. |
| * |
| * @private |
| * @param {*} value The potential iteratee value argument. |
| * @param {*} index The potential iteratee index or key argument. |
| * @param {*} object The potential iteratee object argument. |
| * @returns {boolean} Returns `true` if the arguments are from an iteratee call, |
| * else `false`. |
| */ |
| function isIterateeCall(value, index, object) { |
| if (!isObject(object)) { |
| return false; |
| } |
| var type = typeof index; |
| if (type == 'number' |
| ? (isArrayLike(object) && isIndex(index, object.length)) |
| : (type == 'string' && index in object) |
| ) { |
| return eq(object[index], value); |
| } |
| return false; |
| } |
| |
| /** |
| * Checks if `value` is likely a prototype object. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. |
| */ |
| function isPrototype(value) { |
| var Ctor = value && value.constructor, |
| proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; |
| |
| return value === proto; |
| } |
| |
| /** |
| * Performs a |
| * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) |
| * comparison between two values to determine if they are equivalent. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
| * @example |
| * |
| * var object = { 'a': 1 }; |
| * var other = { 'a': 1 }; |
| * |
| * _.eq(object, object); |
| * // => true |
| * |
| * _.eq(object, other); |
| * // => false |
| * |
| * _.eq('a', 'a'); |
| * // => true |
| * |
| * _.eq('a', Object('a')); |
| * // => false |
| * |
| * _.eq(NaN, NaN); |
| * // => true |
| */ |
| function eq(value, other) { |
| return value === other || (value !== value && other !== other); |
| } |
| |
| /** |
| * Checks if `value` is 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 |
| * |
| * _.isArguments(function() { return arguments; }()); |
| * // => true |
| * |
| * _.isArguments([1, 2, 3]); |
| * // => 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); |
| } |
| |
| /** |
| * Checks if `value` is classified as an `Array` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an array, else `false`. |
| * @example |
| * |
| * _.isArray([1, 2, 3]); |
| * // => true |
| * |
| * _.isArray(document.body.children); |
| * // => false |
| * |
| * _.isArray('abc'); |
| * // => false |
| * |
| * _.isArray(_.noop); |
| * // => false |
| */ |
| var isArray = Array.isArray; |
| |
| /** |
| * Checks if `value` is array-like. A value is considered array-like if it's |
| * not a function and has a `value.length` that's an integer greater than or |
| * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is array-like, else `false`. |
| * @example |
| * |
| * _.isArrayLike([1, 2, 3]); |
| * // => true |
| * |
| * _.isArrayLike(document.body.children); |
| * // => true |
| * |
| * _.isArrayLike('abc'); |
| * // => true |
| * |
| * _.isArrayLike(_.noop); |
| * // => false |
| */ |
| function isArrayLike(value) { |
| return value != null && isLength(value.length) && !isFunction(value); |
| } |
| |
| /** |
| * 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 |
| * |
| * _.isArrayLikeObject(document.body.children); |
| * // => true |
| * |
| * _.isArrayLikeObject('abc'); |
| * // => false |
| * |
| * _.isArrayLikeObject(_.noop); |
| * // => false |
| */ |
| function isArrayLikeObject(value) { |
| return isObjectLike(value) && isArrayLike(value); |
| } |
| |
| /** |
| * Checks if `value` is classified as a `Function` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a function, else `false`. |
| * @example |
| * |
| * _.isFunction(_); |
| * // => true |
| * |
| * _.isFunction(/abc/); |
| * // => false |
| */ |
| function isFunction(value) { |
| // The use of `Object#toString` avoids issues with the `typeof` operator |
| // in Safari 8-9 which returns 'object' for typed array and other constructors. |
| var tag = isObject(value) ? objectToString.call(value) : ''; |
| return tag == funcTag || tag == genTag; |
| } |
| |
| /** |
| * Checks if `value` is a valid array-like length. |
| * |
| * **Note:** This method is loosely based on |
| * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. |
| * @example |
| * |
| * _.isLength(3); |
| * // => true |
| * |
| * _.isLength(Number.MIN_VALUE); |
| * // => false |
| * |
| * _.isLength(Infinity); |
| * // => false |
| * |
| * _.isLength('3'); |
| * // => false |
| */ |
| function isLength(value) { |
| return typeof value == 'number' && |
| value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; |
| } |
| |
| /** |
| * Checks if `value` is the |
| * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) |
| * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an object, else `false`. |
| * @example |
| * |
| * _.isObject({}); |
| * // => true |
| * |
| * _.isObject([1, 2, 3]); |
| * // => true |
| * |
| * _.isObject(_.noop); |
| * // => true |
| * |
| * _.isObject(null); |
| * // => false |
| */ |
| function isObject(value) { |
| var type = typeof value; |
| return !!value && (type == 'object' || type == 'function'); |
| } |
| |
| /** |
| * Checks if `value` is object-like. A value is object-like if it's not `null` |
| * and has a `typeof` result of "object". |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is object-like, else `false`. |
| * @example |
| * |
| * _.isObjectLike({}); |
| * // => true |
| * |
| * _.isObjectLike([1, 2, 3]); |
| * // => true |
| * |
| * _.isObjectLike(_.noop); |
| * // => false |
| * |
| * _.isObjectLike(null); |
| * // => false |
| */ |
| function isObjectLike(value) { |
| return !!value && typeof value == 'object'; |
| } |
| |
| /** |
| * Assigns own enumerable string keyed properties of source objects to the |
| * destination object. Source objects are applied from left to right. |
| * Subsequent sources overwrite property assignments of previous sources. |
| * |
| * **Note:** This method mutates `object` and is loosely based on |
| * [`Object.assign`](https://mdn.io/Object/assign). |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.10.0 |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} [sources] The source objects. |
| * @returns {Object} Returns `object`. |
| * @see _.assignIn |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * } |
| * |
| * function Bar() { |
| * this.c = 3; |
| * } |
| * |
| * Foo.prototype.b = 2; |
| * Bar.prototype.d = 4; |
| * |
| * _.assign({ 'a': 0 }, new Foo, new Bar); |
| * // => { 'a': 1, 'c': 3 } |
| */ |
| var assign = createAssigner(function(object, source) { |
| if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) { |
| copyObject(source, keys(source), object); |
| return; |
| } |
| for (var key in source) { |
| if (hasOwnProperty.call(source, key)) { |
| assignValue(object, key, source[key]); |
| } |
| } |
| }); |
| |
| /** |
| * 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) |
| * |
| * _.keys('hi'); |
| * // => ['0', '1'] |
| */ |
| function keys(object) { |
| return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); |
| } |
| |
| module.exports = assign; |