Return a copy of the object, filtered to only have values for
the whitelisted keys.
@param  {Object} obj
@return {Object}
160641
function(obj) {
			var result = {};
			var keys = this.toArray(arguments, 1);
			Object.keys(obj).forEach(function(key) {
				if (~keys.indexOf(key)) {
					result[key] = obj[key];
				}
			});
			return result;
		}
1091746
function cloneObj(a,b) {
  Object.keys(b).forEach(function(k) {
    a[k] = b[k];
  });
  return a;
}
522519
function serializeObject(obj) {
  var seen = [];

  return JSON.stringify(obj, function(key, val) {
    val = toJsonReplacer(key, val);
    if (isObject(val)) {

      if (seen.indexOf(val) >= 0) return '...';

      seen.push(val);
    }
    return val;
  });
}
15064
function copy(target, obj) {
  if (isObject(obj)) {
    forIn(obj, function(value, key) {
      target[key] = value;
    });
  }
}
358719
function clone (obj, parent) {
  let cloned = new obj.constructor()

  for (let i of Object.keys(obj || {})) {
    let value = obj[i]
    if (i === 'parent' && typeof value === 'object') {
      if (parent) {
        cloned[i] = parent
      }
    } else if (i === 'source' || i === null) {
      cloned[i] = value
    } else if (value instanceof Array) {
      cloned[i] = value.map(x => clone(x, cloned))
    } else if (i !== '_autoprefixerPrefix' && i !== '_autoprefixerValues') {
      if (typeof value === 'object' && value !== null) {
        value = clone(value, cloned)
      }
      cloned[i] = value
    }
  }

  return cloned
}
1049999
function(obj){
    return _(obj).keys().sort().reduce(function(memo, key) {
        memo[key] = obj[key];
        return memo;
    }, {});
}
87281
function(obj, extObj) {
        this.each(extObj, function(value, key) {
            if (extObj.hasOwnProperty(key)) obj[key] = value
        })
        return obj
    }
1197574
function(obj) {
		const keys = Object.keys(obj).sort(function(key1, key2) {
			return key1 === 'id' ? false : key1 > key2;
		});
		return keys;
	}
124686
function raw(obj) {
  const result = {}
  for (const key in obj) {
    const value = obj[key]
    if (value !== null && value !== undefined) {
      result[key] = value.toString()
    }
  }
  return result
}
1114166
function deepCopy(obj) {
			var ret = {}, key, val;
			for (key in obj) {
				if (obj.hasOwnProperty(key)) {
					val = obj[key];
					if (typeof val === 'object' && val !== null) {
						ret[key] = deepCopy(val);
					} else {
						ret[key] = val;
					}
				}
			}
			return ret;
		}
303127
function(obj) {
		if (arguments.length < 2) throw new Error('cannot call _.get() without specifying at least one key');

		for (var i = 1; i < arguments.length; i++) {
			if (obj === undefined || obj === null) return;

			obj = obj[arguments[i]];
		}

		return obj;
	}
1223174
function (obj) {
        return _.cloneDeepWith(obj, function (value) {
            // falls back to default deepclone if object does not have explicit toJSON().
            if (value && _.isFunction(value.toJSON)) {
                return value.toJSON();
            }
        });
    }
730624
function pick(obj) {
  var copy = {};
  var keys = Array.prototype.concat.apply(Array.prototype, Array.prototype.slice.call(arguments, 1));
  forEach(keys, function(key) {
    if (key in obj) copy[key] = obj[key];
  });
  return copy;
}
3137
function get(obj, keyName) {
    if(obj == null || keyName == null) {
        return null;
    }
    if(keyName.indexOf('.') == -1) {
        return obj[keyName];
    }
    var keyNames = keyName.split('.');
    if(keyNames == null) {
        return null;
    }
    for(var i=0; i<keyNames.length; i++) {
        var res = obj[keyNames[i]];
        if(res == null) {
            return null;
        }
        obj = res;
    }
    return res;
}
1091979
function(obj, key) {
		var value;
		for (var i = 2; i < arguments.length; i++) {
			value = arguments[i];
			if (value !== undefined) {
				obj[key] = value;
				break;
			}
		}

		if (value === undefined) delete obj[key];

		return obj;
	}
732129
function specialObjectClone(obj, seen) {
	if (obj === undefined || obj === null) {
		return obj;
	}
	const type = typeof(obj);
	if (type === 'function') {
		return null;
	}
	if (type !== 'object') {
		return obj;
	}
	if (obj instanceof Error) {
		return obj;
	}
	if (obj instanceof Buffer) {
		return '[Buffer]';
	}
	if (obj instanceof RegExp) {
		return '/' + obj.source + '/';
	}
	let newobj = {};
	if (Array.isArray(obj)) {
		const maskFields = [ '--password', '-password' ];
		newobj = null;
		for (let i = 0, l = obj.length; i < l; ++i) {
			if (maskFields.indexOf(obj[i]) > -1 && obj[++i]) {
				if (newobj === null) {
					newobj = obj.slice(0);
				}
				newobj[i] = '[HIDDEN]';
			}
		}
		return newobj ? newobj : obj;
	}

	// we need to deal with circular references
	seen = seen || [];

	// clone so we don't mutate original object
	const keys = Object.keys(obj),
		length = keys.length;
	for (let c = 0; c < length; c++) {
		const key = keys[c];
		let value = obj[key];
		// if the object contains a password key, we want to
		// not log the actual password
		if (/^password[-_]?/.test(key)) {
			value = '[HIDDEN]';
		} else if (key === 'req' || key === 'res') {
			// Skip.
		} else if (typeof(value) === 'object') {
			if (seen.indexOf(value) !== -1) {
				value = '[Circular]';
			} else {
				seen.push(value);
				value = specialObjectClone(value, seen);
			}
		}
		newobj[key] = value;
	}
	return newobj;
}
693882
function(obj) {
        var arr = [];
        for (var prop in obj) {
            if (obj.hasOwnProperty(prop)) {
                arr.push(prop);
            }
        }
        return arr;
    }