Mix properties into target
359818
function mixin(target, properties) {
    Object.keys(properties).forEach(function(prop) {
      target[prop] = properties[prop];
    });
  }
483115
function setTargetsValue(targets, properties) {
  const animatables = getAnimatables(targets);
  animatables.forEach(animatable => {
    for (let property in properties) {
      const value = getFunctionValue(properties[property], animatable);
      const target = animatable.target;
      const valueUnit = getUnit(value);
      const originalValue = getOriginalTargetValue(target, property, valueUnit, animatable);
      const unit = valueUnit || getUnit(originalValue);
      const to = getRelativeValue(validateValue(value, unit), originalValue);
      const animType = getAnimationType(target, property);
      setProgressValue[animType](target, property, to, animatable.transforms, true);
    }
  });
}
1300795
function addTargetToContext(target, context) {
        context.target = target;

        var engine = context.engine;
        var name = target.name;

        if (engine.targets[name]) {
            switch (engine.options.namingConflict) {
                /* jshint ignore:start */
                case 'override':
                    engine.targets[name] = target;
                    context.targets.push(name);
                case 'ignore':
                    break;
                /* jshint ignore:end */
                default:
                    throw new Error('[ETPL_TARGET_EXISTS]' + name);
            }
        }
        else {
            engine.targets[name] = target;
            context.targets.push(name);
        }
    }
580734
function mixConfig(target, source) {
        var prop, value;

        for (prop in source) {
            if (source.hasOwnProperty(prop)) {
                //If the value of the property is a plain object, then
                //allow a one-level-deep mixing of it.
                value = source[prop];
                if (typeof value === 'object' && value &&
                    !lang.isArray(value) && !lang.isFunction(value) &&
                    !lang.isRegExp(value)) {
                    if (!target[prop]) {
                        target[prop] = {};
                    }
                    lang.mixin(target[prop], source[prop], true);
                } else {
                    target[prop] = source[prop];
                }
            }
        }
    }
1131764
function mixin(inObj/*, inProps, inMoreProps, ...*/) {
    var obj = inObj || {};
    for (var i = 1; i < arguments.length; i++) {
      var p = arguments[i];
      try {
        for (var n in p) {
          copyProperty(n, p, obj);
        }
      } catch(x) {
      }
    }
    return obj;
  }
330073
public static void copyProperties(Object source, Object target, boolean ignoreCase) {
		BeanCopier.create(source, target, CopyOptions.create().setIgnoreCase(ignoreCase)).copy();
	}
123717
function(target, type, properties) {
			if(_.type(target) === 'string' || _.type(target) === 'array') {
				var elements = _.type(target) === 'string'? $$(target) : target;
				
				elements.forEach(function(element) {
					_.event.fire(element, type, properties);
				});
			}
			else if (document.createEvent) {
				var evt = document.createEvent("HTMLEvents");
		
				evt.initEvent(type, true, true );
				evt.custom = true;
		
				if(properties) {
					_.attach(evt, properties);
				}
		
				target.dispatchEvent(evt);
			}
		}
381188
function() {
  var mix = {};
  [].forEach.call(arguments, function(arg) {
    for (var name in arg) {
      if (arg.hasOwnProperty(name)) {
        mix[name] = arg[name];
      }
    }
  });
  return mix;
}
923783
function copyAugment (target, src, keys) {
  for (let i = 0, l = keys.length; i < l; i++) {
    const key = keys[i]
    def(target, key, src[key])
  }
}
851082
function mergeProperty(target, name, desc, enumerable) {

    if (desc.get || desc.set) {

        var d$0 = { configurable: true };
        if (desc.get) d$0.get = desc.get;
        if (desc.set) d$0.set = desc.set;
        desc = d$0;
    }

    desc.enumerable = enumerable;
    Object.defineProperty(target, name, desc);
}
1277088
function (target, property, value) {
    return perform(target, function (target) {
        return target.set(property, value);
    }, function (target) {
        target[property] = value;
        return value;
    });
}
1348783
function (target, source) {
        'use strict';
        var keys = Object.keys(source),
            len = keys.length,
            i = 0,
            prop,
            isA, isB;
        while (i < len) {
            prop = keys[i];
            isA = isObj(target[prop]);
            isB = isObj(source[prop]);
            if (isA && isB) {
                deepMerge(target[prop], source[prop]);
            } else if (!isA && isB) {
                target[prop] = JSON.parse(JSON.stringify(source[prop]));
            } else {
                target[prop] = source[prop];
            }
            i += 1;
        }
    }
767464
def _bind_target(self, target, ctx=None):
        

        result = target

        try:
            # get annotations from target if exists.
            local_annotations = get_local_property(
                target, Annotation.__ANNOTATIONS_KEY__, [], ctx=ctx
            )
        except TypeError:
            raise TypeError('target {0} must be hashable.'.format(target))

        # if local_annotations do not exist, put them in target
        if not local_annotations:
            put_properties(
                target,
                properties={Annotation.__ANNOTATIONS_KEY__: local_annotations},
                ctx=ctx
            )

        # insert self at first position
        local_annotations.insert(0, self)

        # add target to self targets
        if target not in self.targets:
            self.targets.append(target)

        return result
97589
function merge (target, source) {
  source = source || {};
  return Object.keys(source).reduce((targetKey, key) => {
    targetKey[key] = source[key];
    return target;
  }, target);
}
242114
function mixInto(fnClass, bDefaultValue) {
			// add the properties
			fnClass.getMetadata().addSpecialSetting("stashed", {type: "boolean", defaultValue: !!bDefaultValue});

			// mix the required methods into the target fnClass
			fnClass.prototype.setStashed = function(bStashed) {
				if (this.stashed === true && !bStashed) {
					if (this.sParentId) {
						var oControl = unstash(this, sap.ui.getCore().byId(this.sParentId));
						// we need to set the property to the stashed control
						oControl.stashed = false;
						return;
					}
				} else if (bStashed) {
					Log.warning("Cannot re-stash a control", this.getId());
				}
			};

			fnClass.prototype.getStashed = function() {
				return this.stashed;
			};

			var fnDestroy = fnClass.prototype.destroy;
			fnClass.prototype.destroy = function() {
				delete stashedControls[this.getId()];
				fnDestroy.apply(this, arguments);
			};

			fnClass.prototype._stash = function(sParentId, sParentAggregationName) {
				// for later unstash these parent infos have to be kept
				this.sParentId = sParentId;
				this.sParentAggregationName = sParentAggregationName;
				stashedControls[this.getId()] = this;
			};
		}
458435
function concatenation(concatConfig, concatTargets, compiler) {
  var sources, target = concatTargets.shift();
  if (target) {
    sources = concatConfig[target];
    if (!Array.isArray(sources)) sources = [sources];
    sources.forEach(function(item) {
      var file = app.fullPath(app.paths.public + item);
      var ext = assetUtil.getExt(file);
      compiler.getSource(item, target, 'concat');
    });
    compiler.exec(function(err, compiled) {
      if (err) {
        throw err;
      } else {
        var ext = assetUtil.getExt(target);
        switch (ext) {
          case 'css':
          case 'js':
            var source = compiled.join('\n\n');
            target = app.fullPath(app.paths.public + target);
            instance.writeFile(target, source);
            break;
          default:
            throw new Error("Asset Compiler: Extension not supported: " + target);
        }
        concatenation(concatConfig, concatTargets, compiler);
      }
    });
  } else {
    instance.config.concat = concatConfig; // Set new config once concatenation is done
    app.emit('asset_compiler_concat_complete'); // Runs even without targets to concat
  }
}
1191440
def _apply_properties(widget, properties={}):
    
    with widget.hold_sync():
        for key, value in properties.items():
            setattr(widget, key, value)