Extend class prototype
@param {Object} source If source has a prototype, it will be used to extend current prototype.
@return {function()} Returns `this`.
423566
function extendClass(source){
      var proto = this.prototype;

      if (typeof source == 'function' && !isClass(source))
        source = source(this.superClass_.prototype, slice(proto));

      if (source.prototype)
        source = source.prototype;

      for (var key in source)
      {
        var value = source[key];
        var protoValue = proto[key];

        if (key == 'className' || key == 'extendConstructor_')
          this[key] = value;
        else
        {
          if (protoValue && protoValue.__extend__)
            proto[key] = protoValue.__extend__(value);
          else
          {
            proto[key] = value;
            ///** @cut */ if (value && !value.__extend__ && (value.constructor == Object || value.constructor == Array)){ consoleMethods.warn('!' + key); }
          }
        }
      }

      // for browsers that doesn't enum toString
      if (TOSTRING_BUG && source[key = 'toString'] !== toString)
        proto[key] = source[key];

      return this;
    }
55583
function afterExtends (klass, baseKlass, superFunc) {
    var newKlass = createNamedClass(klass.name, klass, baseKlass, superFunc);
    newKlass.prototype = createPrototype(klass, baseKlass, newKlass);
    
    return newKlass;
}
993777
function extend() {
  // copy reference to target object
  var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;
  // Handle a deep copy situation
  if (typeof target === "boolean") {
    deep = target;
    target = arguments[1] || {};
    // skip the boolean and the target
    i = 2;
  }
  // Handle case when target is a string or something (possible in deep copy)
  if (typeof target !== "object" && !typeof target === 'function')
    target = {};
  var isPlainObject = function(obj) {
    // Must be an Object.
    // Because of IE, we also have to check the presence of the constructor property.
    // Make sure that DOM nodes and window objects don't pass through, as well
    if (!obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval)
      return false;
    var has_own_constructor = hasOwnProperty.call(obj, "constructor");
    var has_is_property_of_method = hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf");
    // Not own constructor property must be Object
    if (obj.constructor && !has_own_constructor && !has_is_property_of_method)
      return false;
    // Own properties are enumerated firstly, so to speed up,
    // if last one is own, then all properties are own.
    var last_key;
    for (key in obj)
      last_key = key;
    return typeof last_key === "undefined" || hasOwnProperty.call(obj, last_key);
  };
  for (; i < length; i++) {
    // Only deal with non-null/undefined values
    if ((options = arguments[i]) !== null) {
      // Extend the base object
      for (name in options) {
        src = target[name];
        copy = options[name];
        // Prevent never-ending loop
        if (target === copy)
            continue;
        // Recurse if we're merging object literal values or arrays
        if (deep && copy && (isPlainObject(copy) || Array.isArray(copy))) {
          var clone = src && (isPlainObject(src) || Array.isArray(src)) ? src : Array.isArray(copy) ? [] : {};
          // Never move original objects, clone them
          target[name] = extend(deep, clone, copy);
        // Don't bring in undefined values
        } else if (typeof copy !== "undefined")
          target[name] = copy;
      }
    }
  }
  // Return the modified object
  return target;
}
645680
function clone(source) {
            if (!source || typeof source !== 'object') {
                return source;
            }

            var cloned = source;

            if (isArray(source)) {
                cloned = source.slice().map(clone);
            }
            else if (isObject(source) && 'isPrototypeOf' in source) {
                cloned = {};
                for (var key in source) {
                    if (hasOwnProperty.call(source, key)) {
                        cloned[key] = clone(source[key]);
                    }
                }
            }

            return cloned;
        }
1175184
function extendClass(extend){extend=extend.prototype;/**
         * ## merge
         *
         * combines two objects
         *
         * @param {Object} obj object to combine with extend
         *
         * @return {Obj} newly combined object
         */function merge(obj){for(var prop in obj){extend[prop]=obj[prop];}}for(var _len=arguments.length,objects=Array(_len>1?_len-1:0),_key=1;_key<_len;_key++){objects[_key-1]=arguments[_key];}for(var i=0,lenI=objects.length;i<lenI;i++){var obj=objects[i];merge(obj);}return extend;}
1148696
function extend(object, subject, ignoredKeys) {
    function copier(key, value) {
      if ( !ignoredKeys || !ignoredKeys.hasOwnProperty(key)) {    // no copy ignored keys
        object[key] = value;                                      // do copy
        if (iClass) { oPrototype[key] = value; }                  // class? copy to prototype as well
      }
    }

    if (isArray(subject)) {
      for (var len = subject.length; --len >= 0;) { extend(object, subject[len], ignoredKeys); }
    } else {
      ignoredKeys = ignoredKeys || { constructor: 1, $super: 1, prototype: 1, $superb: 1 };

      var iClass     = isClass(object),
          isSubClass = isClass(subject),
          oPrototype = object.prototype, supez, key, proto;

      // copy static properties and prototype.* to object
      if (isMap(subject)) { for (key in subject) copier(key, subject[key]); }

      if (isSubClass) {
        proto = subject.prototype;
        for (key in proto) { copier(key, proto[key]); }
      }

      // prototype properties
      if (iClass && isSubClass) { extend(oPrototype, subject.prototype, ignoredKeys); }
    }
  }
845985
function inherit (base) {
  if (typeof base === 'function') {
    return initClass(protoize.apply(null, arguments), [], 0);
  } else {
    return initClass(Object.create(base), arguments, 1);
  }
}
796165
function Extendable(errorClass) {

  /**
   * @constructor
   */
  function ExtendableClass() {
    errorClass.apply(this, arguments);
  }

  ExtendableClass.prototype = Object.create(errorClass.prototype);
  Object.setPrototypeOf ? Object.setPrototypeOf(ExtendableClass, errorClass) : ExtendableClass.__proto__ = errorClass;

  return ExtendableClass;
}
1249302
function extend(target, source) {
  var keys = Object.keys(source);
  for(var i = 0, len = keys.length; i < len; i++) {
    var key = keys[i];
    target[key] = source[key];
  }
  return target;
}
1004884
function extend(obj, extObj) {
        var a, b, i;
        if (arguments.length > 2) {
            for (a = 1, b = arguments.length; a < b; a += 1) {
                extend(obj, arguments[a]);
            }
        } else {
            for (i in extObj) {
                if (extObj.hasOwnProperty(i)) {
                    obj[i] = extObj[i];
                }
            }
        }
        return obj;
    }
305186
function extend(prototype, attributes) {
    var object = {};
    Object.keys(prototype).forEach(function(key) {
      object[key] = prototype[key];
    });
    Object.keys(attributes).forEach(function(key) {
      object[key] = attributes[key];
    });
    return object;
  }
1251050
function extend(a, b){
	var p, type;
	for(p in b) {
		type = typeof b[p];
		if(type !== "object" && type !== "function") {
			a[p] = b[p];
		}
	}
	return a;
}
1241213
function extend(object, properties) {
  object = object || { };
  const anotherObject = properties || { };

  for (const key in anotherObject) {
    const val = anotherObject[key];

    if (val || (val === '')) {
      object[key] = val;
    }
  }
  return object;
}
294081
function _extend (target, source, deep) {
  for (let key in source) {
    if (deep) {
      if (isPlainObject(source[key])) {
        !isPlainObject(target[key]) && (target[key] = {})
      } else if (Array.isArray(source[key])) {
        !Array.isArray(target[key]) && (target[key] = [])
      } else {
        source[key] !== undefined && (target[key] = source[key])
        continue
      }
      _extend(target[key], source[key], deep)
    } else if (source[key] !== undefined) {
      target[key] = source[key]
    }
  }
}
265299
function extendThis() {
		var i, ni, objects, object, prop;
		objects = arguments;
		for (i = 0, ni = objects.length; i < ni; i++) {
			object = objects[i];
			for (prop in object) {
				this[prop] = object[prop];
			}
		}

		return this;
	}
320282
function extend() { var args
        args = [{}]
        args.push.apply(args, arguments)
        return nextend.apply(null, args)
    }
141198
function extend (target, source) {
	var a = Object.create(target);

	Object.keys(source).map(function (prop) {
		prop in a && (a[prop] = source[prop]);
	});
	
	return a;
}