Spaces:
Build error
Build error
; | |
var hasOwn = Object.prototype.hasOwnProperty; | |
var toStr = Object.prototype.toString; | |
var defineProperty = Object.defineProperty; | |
var gOPD = Object.getOwnPropertyDescriptor; | |
var isArray = function isArray(arr) { | |
if (typeof Array.isArray === 'function') { | |
return Array.isArray(arr); | |
} | |
return toStr.call(arr) === '[object Array]'; | |
}; | |
var isPlainObject = function isPlainObject(obj) { | |
if (!obj || toStr.call(obj) !== '[object Object]') { | |
return false; | |
} | |
var hasOwnConstructor = hasOwn.call(obj, 'constructor'); | |
var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); | |
// Not own constructor property must be Object | |
if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { | |
return false; | |
} | |
// Own properties are enumerated firstly, so to speed up, | |
// if last one is own, then all properties are own. | |
var key; | |
for (key in obj) { /**/ } | |
return typeof key === 'undefined' || hasOwn.call(obj, key); | |
}; | |
// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target | |
var setProperty = function setProperty(target, options) { | |
if (defineProperty && options.name === '__proto__') { | |
defineProperty(target, options.name, { | |
enumerable: true, | |
configurable: true, | |
value: options.newValue, | |
writable: true | |
}); | |
} else { | |
target[options.name] = options.newValue; | |
} | |
}; | |
// Return undefined instead of __proto__ if '__proto__' is not an own property | |
var getProperty = function getProperty(obj, name) { | |
if (name === '__proto__') { | |
if (!hasOwn.call(obj, name)) { | |
return void 0; | |
} else if (gOPD) { | |
// In early versions of node, obj['__proto__'] is buggy when obj has | |
// __proto__ as an own property. Object.getOwnPropertyDescriptor() works. | |
return gOPD(obj, name).value; | |
} | |
} | |
return obj[name]; | |
}; | |
module.exports = function extend() { | |
var options, name, src, copy, copyIsArray, clone; | |
var target = arguments[0]; | |
var i = 1; | |
var length = arguments.length; | |
var deep = false; | |
// Handle a deep copy situation | |
if (typeof target === 'boolean') { | |
deep = target; | |
target = arguments[1] || {}; | |
// skip the boolean and the target | |
i = 2; | |
} | |
if (target == null || (typeof target !== 'object' && typeof target !== 'function')) { | |
target = {}; | |
} | |
for (; i < length; ++i) { | |
options = arguments[i]; | |
// Only deal with non-null/undefined values | |
if (options != null) { | |
// Extend the base object | |
for (name in options) { | |
src = getProperty(target, name); | |
copy = getProperty(options, name); | |
// Prevent never-ending loop | |
if (target !== copy) { | |
// Recurse if we're merging plain objects or arrays | |
if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { | |
if (copyIsArray) { | |
copyIsArray = false; | |
clone = src && isArray(src) ? src : []; | |
} else { | |
clone = src && isPlainObject(src) ? src : {}; | |
} | |
// Never move original objects, clone them | |
setProperty(target, { name: name, newValue: extend(deep, clone, copy) }); | |
// Don't bring in undefined values | |
} else if (typeof copy !== 'undefined') { | |
setProperty(target, { name: name, newValue: copy }); | |
} | |
} | |
} | |
} | |
} | |
// Return the modified object | |
return target; | |
}; | |