## Heads up!

[Please update][update] to version 1.0.1 or later, a critical bug was fixed in that version.

## Behavior

- This follows the same behavior as [Object.assign()][assign], and thus _does not_ deep clone values.
- The first argument is the "target" object.
- To shallow clone, pass an empty object as the first argument.
- One or more additional ("source") objects may be passed. 
- When multiple objects are passed, properties in _later_ objects will overwrite same-named properties in _earlier_ objects. Thus, properties in the target object will be overwritten by same-named properties in other objects.
- Only enumerable and own properties are copied. 
- String and Symbol properties are copied.
- Sparse arguments are skipped, so this does not throw on `null` or `undefined` source values.
- Like [Object.assign()][assign], `[[Get]]` is used on source objects and `[[Set]]` is used on the target, so it will invoke getters and setters. Therefore it assigns properties versus just copying or defining new properties. _Note that this should not be used for merging new properties into a prototype if the merge sources contain getters and you do not want `[[Get]]` to be used on the getters. For copying property definitions and their enumerability into prototypes `Object.getOwnPropertyDescriptor()` and `Object.defineProperty()` should be used instead._

## Usage

```js
const assign = require('{%= name %}');

const config = {
  admin: true,
  author: {
    name: { first: 'Joe' }
  }
};

const locals = {
  admin: false,
  author: {
    name: { last: 'Smith' },
    username: 'joesmith'
  }
};

console.log(assign(config, locals));
// {
//   admin: false,
//   author: {
//     name: { first: 'Joe', last: 'Smith' },
//     username: 'joesmith'
//   }
// }
```

[assign]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign