Mergician

https://jhildenbiddle.github.io/mergician
Admin
Mergician is a flexible and lightweight JavaScript utility for deep (recursive) cloning and merging...
Tokens:8,051
Snippets:60
Trust Score:8.3
Update:8 months ago
Show doc for...
Tokens:
Raw
### Mergician Installation (NPM)

Source: https://jhildenbiddle.github.io/mergician/index

Provides the command to install the Mergician package using npm. This is the standard method for adding the utility to a Node.js project or a project managed with npm.

```bash
npm install mergician
```

--------------------------------

### Default Object Merging with Mergician (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

Explains and demonstrates merging multiple objects using Mergician with its default options. The function creates a new merged object without altering the source objects. It shows examples of both cloning a single object and merging several objects.

```javascript
const obj1 = { a: 1 };
const obj2 = { b: [2, 2], c: { d: 2 } };
const obj3 = { b: [3, 3], c: { e: 3 } };

const clonedObj = mergician({}, obj1);
const mergedObj = mergician(obj1, obj2, obj3);

console.log(clonedObj); // { a: 1 }
console.log(clonedObj === obj1); // false
console.log(mergedObj); // { a: 1, b: [3, 3], c: { d: 2, e: 3 } }
```

--------------------------------

### Advanced Object Merging with Custom Options (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

Illustrates advanced object merging using Mergician with custom options. This example shows how to skip specific keys, append arrays, deduplicate array items, and use a filter function to modify properties during the merge process. The result is a deeply merged object reflecting the specified configurations.

```javascript
import { mergician } from 'mergician';

const obj1 = { a: [1, 1], b: { c: 1, d: 1 } };
const obj2 = { a: [2, 2], b: { c: 2 } };
const obj3 = { e: 3 };

const mergedObj = mergician({
  skipKeys: ['d'],
  appendArrays: true,
  dedupArrays: true,
  filter({ depth, key, srcObj, srcVal, targetObj, targetVal }) {
    if (key === 'e') {
      targetObj['hello'] = 'world';
      return false;
    }
  }
})(obj1, obj2, obj3);

// Result
console.log(mergedObj); // { a: [1, 2], b: { c: 2 }, hello: 'world' }
```

--------------------------------

### Pre-process Properties with beforeEach() in JavaScript

Source: https://jhildenbiddle.github.io/mergician/index

The `beforeEach()` callback in Mergician is executed before a property is merged, allowing inspection and modification. Returning a value replaces the original source value. Returning a property descriptor object defines the property using `Object.defineProperty()`. If no value is returned, the original source value is used. This example normalizes non-zero 'falsy' values to `false`.

```javascript
const obj1 = { a: null };
const obj2 = { b: undefined };
const obj3 = { c: { d: '', e: 0 } };

const mergedObj = mergician({
  // Normalize non-zero "falsy" values to be false
  beforeEach({ depth, key, srcObj, srcVal, targetObj, targetVal }) {
    if (srcVal !== 0 && !Boolean(srcVal)) {
      return false;
    }
  }
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: false, b: false, c: { d: false, e: 0 } }
```

--------------------------------

### Custom Object Merging with Mergician Options (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

Details how to use Mergician with custom options to control the merging behavior. This involves creating a configured merge function by passing an options object to `mergician()`, which is then used to merge subsequent objects. Examples include skipping keys and customizing array handling.

```javascript
const obj1 = { a: 1 };
const obj2 = { b: [2, 2], c: { d: 2 } };
const obj3 = { b: [3, 3], c: { e: 3 } };

const clonedObj = mergician({
  skipKeys: ['c']
})({}, obj2);

const mergedObj = mergician({
  appendArrays: true,
  dedupArrays: true
})(obj1, obj2, obj3);

console.log(clonedObj); // { b: [2, 2] };
console.log(mergedObj); // { a: 1, b: [2, 3], c: { d: 2, e: 3 } }
```

--------------------------------

### Post-process Merged Properties with afterEach() in JavaScript

Source: https://jhildenbiddle.github.io/mergician/index

The `afterEach()` callback in Mergician is invoked after a property has been merged, enabling post-merge inspection and modification. Returning a value sets the final merged value. Returning a property descriptor object defines the property using `Object.defineProperty()`. If no value is returned, the default merged value is retained. This example adds 1 to all numeric properties.

```javascript
const obj1 = { a: 1 };
const obj2 = { b: 2 };
const obj3 = { c: { d: 3, e: true } };

const mergedObj = mergician({
  // Add 1 to all numbers
  afterEach({ depth, key, mergeVal, srcObj, targetObj }) {
    if (typeof mergeVal === 'number') {
      return mergeVal + 1;
    }
  }
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: 2, b: 3, c: { d: 4, e: true } }
```

--------------------------------

### Filter Properties Conditionally with filter() in JavaScript

Source: https://jhildenbiddle.github.io/mergician/index

The `filter()` callback in Mergician allows you to conditionally merge or skip properties during an object merge. Returning a truthy value merges the property, while a falsy value skips it. If no value is returned, default merge logic applies. This example demonstrates skipping properties with non-zero 'falsy' values.

```javascript
const obj1 = { a: true };
const obj2 = { a: false, b: true };
const obj3 = { a: null, b: undefined, c: { d: 0, e: '' } };

const mergedObj = mergician({
  // Skip properties with non-zero "falsy" values
  filter({ depth, key, srcObj, srcVal, targetObj, targetVal }) {
    return Boolean(srcVal) || srcVal === 0;
  }
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: true, b: true, c: { d: 0 } }
```

--------------------------------

### Handle Circular References with onCircular() in JavaScript

Source: https://jhildenbiddle.github.io/mergician/index

The `onCircular()` callback in Mergician provides a mechanism to handle circular object references during the merge process. Returning a value replaces the circular reference. Returning a property descriptor object defines the property using `Object.defineProperty()`. If no value is returned, the default behavior for circular references is applied. This example replaces circular references with the string '[Circular]'.

```javascript
const circularObj = {
  a: 1,
  get b() {
    return this;
  }
};
const clonedObj = mergician({
  // Replace circular object reference with '[Circular]' string
  onCircular({ depth, key, srcObj, srcVal, targetObj, targetVal }) {
    return '[Circular]';
  }
})({}, circularObj);

console.log(clonedObj); // { a: 1, b: '[Circular]' }
```

--------------------------------

### Loading Mergician from CDN (ES Module)

Source: https://jhildenbiddle.github.io/mergician/index

Illustrates how to load the Mergician library from a CDN using ES module syntax. It specifies a version lock to ensure stability and prevent breaking changes from future releases.

```javascript
import { mergician } from 'https://cdn.jsdelivr.net/npm/mergician@2';
```

--------------------------------

### Importing Mergician (ES Module)

Source: https://jhildenbiddle.github.io/mergician/index

Shows how to import the Mergician function using ES module syntax. This is suitable for modern JavaScript environments that support ES modules.

```javascript
import { mergician } from 'mergician';
```

--------------------------------

### Importing Mergician (CommonJS)

Source: https://jhildenbiddle.github.io/mergician/index

Demonstrates how to import the Mergician function using CommonJS module syntax. This is typically used in Node.js environments.

```javascript
const { mergician } = require('mergician');
```

--------------------------------

### Create Named Custom Merge Function with Mergician

Source: https://jhildenbiddle.github.io/mergician/index

Demonstrates how to create a reusable custom merge function by passing an options object to mergician. The returned function inherits the default options, simplifying repeated merge operations with consistent settings.

```javascript
const obj1 = { a: 1 };
const obj2 = { b: [2, 2], c: { d: 2 } };
const obj3 = { b: [3, 3], c: { e: 3 } };

const customMerge = mergician({
  appendArrays: true,
  dedupArrays: true
});

const clonedObj = customMerge({}, obj2);
const mergedObj1 = customMerge(obj1, obj2, obj3);
const mergedObj2 = customMerge({
  skipKeys: ['c']
})(obj1, obj2, obj3);

console.log(clonedObj); // { b: [2], c: { d: 2 } }
console.log(mergedObj1); // { a: 1, b: [2, 3], c: { d: 2, e: 3 } }
console.log(mergedObj2); // { a: 1, b: [2, 3] }
```

--------------------------------

### beforeEach() Callback

Source: https://jhildenbiddle.github.io/mergician/index

The beforeEach callback allows inspection and modification of properties before they are merged. Returned values will be used as the new value to merge.

```APIDOC
## beforeEach()

### Description
Callback used for inspecting/modifying properties before merge. If a value is returned, that value will be used as the new value to merge. If an `Object` with the shape of a property descriptor is returned, the object will be used to define the property using `Object.defineProperty()`. If no value is returned, the unmodified `srcVal` will be used.

### Method
Callback Function

### Parameters
#### Arguments
- **data** (object) - Object containing merge data:
  - **depth** (number) - The nesting level of the key being processed
  - **key** (string) - The object key being processed
  - **srcObj** (object) - The object containing the source value
  - **srcVal** (any) - The source object’s property value
  - **targetObj** (object) - The new merged object
  - **targetVal** (any) - The new merged object’s current property value

### Request Example
```javascript
const obj1 = { a: null };
const obj2 = { b: undefined };
const obj3 = { c: { d: '', e: 0 } };

const mergedObj = mergician({
  // Normalize non-zero "falsy" values to be false
  beforeEach({ depth, key, srcObj, srcVal, targetObj, targetVal }) {
    if (srcVal !== 0 && !Boolean(srcVal)) {
      return false;
    }
  }
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: false, b: false, c: { d: false, e: 0 } }
```

### Response
- **(Implicit)** Returns the new value to merge, a property descriptor object, or undefined to use the unmodified `srcVal`.
```

--------------------------------

### Basic Object Cloning with Mergician (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

Demonstrates how to perform a basic deep clone of a JavaScript object using Mergician with default options. The function returns a new object, ensuring the original object remains unmodified. It verifies that the cloned object and its nested properties are distinct from the original.

```javascript
import { mergician } from 'mergician';

const obj1 = { a: [1, 1], b: { c: 1, d: 1 } };
const clonedObj = mergician({}, obj1);

// Results
console.log(clonedObj); // { a: [1, 1], b: { c: 1, d: 1 } }
console.log(clonedObj === obj1); // false
console.log(clonedObj.a === obj1.a); // false
console.log(clonedObj.b === obj1.b); // false
```

--------------------------------

### Merge with invokeGetters Option in Mergician

Source: https://jhildenbiddle.github.io/mergician/index

Demonstrates the `invokeGetters` option in Mergician, which enables the merging of values returned by getter methods. When true, getters are invoked, and their return values are included in the merge; otherwise, getters are treated as properties.

```javascript
const obj1 = {
  a: 1,
  get b() {
    return this.a + 1;
  }
};
const clonedObj1 = mergician({}, obj1);
const clonedObj2 = mergician({
  invokeGetters: true
})({}, obj1);

console.log(obj1); // { a: 1, b: [Getter] }
console.log(clonedObj1); // { a: 1, b: [Getter] }
console.log(clonedObj2); // { a: 1, b: 2 }
```

--------------------------------

### Merge with skipKeys Option in Mergician

Source: https://jhildenbiddle.github.io/mergician/index

Shows how to use the `skipKeys` option in Mergician to exclude specific keys from the merge process. All keys not listed in `skipKeys` are merged, affecting both top-level and nested keys.

```javascript
const obj1 = { a: 1 };
const obj2 = { b: { c: 2 } };
const obj3 = { b: { d: 3 } };

const mergedObj = mergician({
  skipKeys: ['c']
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: 1, b: { d: 3 } }
```

--------------------------------

### afterEach() Callback

Source: https://jhildenbiddle.github.io/mergician/index

The afterEach callback allows inspection and modification of properties after they have been merged. Returned values will be used as the final merged value.

```APIDOC
## afterEach()

### Description
Callback used for inspecting/modifying properties after merge. If a value is returned, that value will be used as the new merged value. If an `Object` with the shape of a property descriptor is returned, the object will be used to define the property using `Object.defineProperty()`. If no value is returned, the unmodified `mergeVal` will be used.

### Method
Callback Function

### Parameters
#### Arguments
- **data** (object) - Object containing merge data:
  - **depth** (number) - The nesting level of the key being processed
  - **key** (string) - The object key being processed
  - **mergeVal** (any) - The new merged value
  - **srcObj** (object) - The object containing the source value
  - **targetObj** (object) - The new merged object

### Request Example
```javascript
const obj1 = { a: 1 };
const obj2 = { b: 2 };
const obj3 = { c: { d: 3, e: true } };

const mergedObj = mergician({
  // Add 1 to all numbers
  afterEach({ depth, key, mergeVal, srcObj, targetObj }) {
    if (typeof mergeVal === 'number') {
      return mergeVal + 1;
    }
  }
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: 2, b: 3, c: { d: 4, e: true } }
```

### Response
- **(Implicit)** Returns the new merged value, a property descriptor object, or undefined to use the unmodified `mergeVal`.
```

--------------------------------

### Merge with skipUniversalKeys Option in Mergician

Source: https://jhildenbiddle.github.io/mergician/index

Illustrates the `skipUniversalKeys` option in Mergician, which skips keys present in all objects and merges only unique or common keys. Nested comparisons are performed at the same depth and under the same parent key.

```javascript
const obj1 = { a: 1 };
const obj2 = { a: 2, b: { c: 2 } };
const obj3 = { a: 3, b: { c: 3, d: 3 }, e: 3 };

const mergedObj = mergician({
  skipUniversalKeys: true
})(obj1, obj2, obj3);

console.log(mergedObj); // { b: { d: 3 }, e: 3 }
```

--------------------------------

### Hoist Custom Prototype Properties (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

The `hoistProto` option merges custom prototype properties as direct properties of the new merged object. This allows methods and properties defined on the prototype to be directly accessible on the merged object. The default is `false`.

```javascript
class Person {
  constructor(name) {
    this.name = name; // <= Own property
  }

  greeting() {
    // <= Prototype property
    return `My name is ${this.name}.`;
  }
}

const John = new Person('John');

console.log(John.greeting()); // My name is John.
console.log(John.hasOwnProperty('greeting')); // false
console.log(Object.getPrototypeOf(John).hasOwnProperty('greeting')); // true

const cloneObj = mergician({
  hoistProto: true
})({}, John);

console.log(cloneObj.greeting()); // My name is John.
console.log(John.hasOwnProperty('greeting')); // true
console.log(Object.getPrototypeOf(John).hasOwnProperty('greeting')); // false
```

--------------------------------

### Merge with onlyCommonKeys Option in Mergician

Source: https://jhildenbiddle.github.io/mergician/index

Demonstrates the `onlyCommonKeys` option in Mergician, which merges only keys present in multiple objects. For nested objects, key comparisons are made at the same depth and under the same parent key.

```javascript
const obj1 = { a: 1 };
const obj2 = { a: 2, b: { c: 2 } };
const obj3 = { a: 3, b: { c: 3, d: 3 }, e: 3 };

const mergedObj = mergician({
  onlyCommonKeys: true
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: 3, b: { c: 3 } }
```

--------------------------------

### filter() Callback

Source: https://jhildenbiddle.github.io/mergician/index

The filter callback allows conditional merging or skipping of properties based on a truthy or falsy return value.

```APIDOC
## filter()

### Description
Callback used to conditionally merge or skip a property. Return a “truthy“ value to merge or a “falsy“ value to skip. If no value is returned, merging/skipping will proceed based on other option values (`onlyKeys`, `skipKeys`, etc.).

### Method
Callback Function

### Parameters
#### Arguments
- **data** (object) - Object containing merge data:
  - **depth** (number) - The nesting level of the key being processed
  - **key** (string) - The object key being processed
  - **srcObj** (object) - The object containing the source value
  - **srcVal** (any) - The source object’s property value
  - **targetObj** (object) - The new merged object
  - **targetVal** (any) - The new merged object’s current property value

### Request Example
```javascript
const obj1 = { a: true };
const obj2 = { a: false, b: true };
const obj3 = { a: null, b: undefined, c: { d: 0, e: '' } };

const mergedObj = mergician({
  // Skip properties with non-zero "falsy" values
  filter({ depth, key, srcObj, srcVal, targetObj, targetVal }) {
    return Boolean(srcVal) || srcVal === 0;
  }
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: true, b: true, c: { d: 0 } }
```

### Response
- **(Implicit)** Returns a truthy value to merge, a falsy value to skip, or undefined to use default behavior.
```

--------------------------------

### Merge with onlyKeys Option in Mergician

Source: https://jhildenbiddle.github.io/mergician/index

Illustrates the use of the `onlyKeys` option in Mergician to specify an exclusive list of keys to be merged. Keys not present in the `onlyKeys` array are skipped, applying to both top-level and nested keys.

```javascript
const obj1 = { a: 1 };
const obj2 = { b: { c: 2 } };
const obj3 = { b: { d: 3 } };

const mergedObj = mergician({
  onlyKeys: ['a', 'b', 'c']
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: 1, b: { c: 2 } }
```

--------------------------------

### Prepend Arrays During Merge (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

The `prependArrays` option merges array values by adding them to the beginning of existing arrays. Nested arrays remain unmodified. The default value for this option is `false`.

```javascript
const obj1 = { a: [1, 1] };
const obj2 = { a: [2, 2] };
const obj3 = { a: [3, 3] };

const mergedObj = mergician({
  prependArrays: true
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: [3, 3, 2, 2, 1, 1] }
```

--------------------------------

### Merge with onlyUniversalKeys Option in Mergician

Source: https://jhildenbiddle.github.io/mergician/index

Explains the `onlyUniversalKeys` option in Mergician, used to merge only keys that exist in all provided objects. This comparison is applied recursively to nested objects based on keys at the same depth and parent.

```javascript
const obj1 = { a: 1 };
const obj2 = { a: 2, b: { c: 2 } };
const obj3 = { a: 3, b: { c: 3, d: 3 }, e: 3 };

const mergedObj = mergician({
  onlyUniversalKeys: true
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: 3 }
```

--------------------------------

### onCircular() Callback

Source: https://jhildenbiddle.github.io/mergician/index

The onCircular callback handles circular object references during the merge process. Returned values will be used as the new value to merge.

```APIDOC
## onCircular()

### Description
Callback used for handling circular object references during merge. If a value is returned, that value will be used as the new value to merge. If an `Object` with the shape of a property descriptor is returned, the object will be used to define the property using `Object.defineProperty()`. If no value is returned, the unmodified `srcVal` will be used.

### Method
Callback Function

### Parameters
#### Arguments
- **data** (object) - Object containing merge data:
  - **depth** (number) - The nesting level of the key being processed
  - **key** (string) - The object key being processed
  - **srcObj** (object) - The object containing the source value
  - **srcVal** (any) - The source object’s property value
  - **targetObj** (object) - The new merged object
  - **targetVal** (any) - The new merged object’s current property value

### Request Example
```javascript
const circularObj = {
  a: 1,
  get b() {
    return this;
  }
};
const clonedObj = mergician({
  // Replace circular object reference with '[Circular]' string
  onCircular({ depth, key, srcObj, srcVal, targetObj, targetVal }) {
    return '[Circular]';
  }
})({}, circularObj);

console.log(clonedObj); // { a: 1, b: '[Circular]' }
```

### Response
- **(Implicit)** Returns the new value to merge, a property descriptor object, or undefined to use the unmodified `srcVal`.
```

--------------------------------

### Merge with skipCommonKeys Option in Mergician

Source: https://jhildenbiddle.github.io/mergician/index

Details the `skipCommonKeys` option in Mergician, which skips keys found in multiple objects and merges only unique keys. For nested structures, uniqueness is determined by keys at the same depth and parent.

```javascript
const obj1 = { a: 1 };
const obj2 = { a: 2, b: { c: 2 } };
const obj3 = { a: 3, b: { c: 3, d: 3 }, e: 3 };

const mergedObj = mergician({
  skipCommonKeys: true
})(obj1, obj2, obj3);

console.log(mergedObj); // { e: 3 }
```

--------------------------------

### Skip Setter Methods During Merge (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

The `skipSetters` option prevents merge operations from processing 'setter' methods. These methods are still accessible to callbacks for direct use or replacement. By default, setters are not skipped.

```javascript
const obj1 = {
    firstname: 'John',
    lastname: 'Smith',
    set fullname() {
        return this.fullname = `${this.firstname} ${this.lastname}`;
    }
};
const clonedObj = mergician({
    skipSetters: true
})({}, obj1);

console.log(obj1);      // { firstname: 'John', lastname: 'Smith', fullname: [Setter] }
console.log(clonedObj); // { firstname: 'John', lastname: 'Smith' }
```

--------------------------------

### Skip Prototype Property Merging (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

The `skipProto` option prevents the merging of custom prototype properties. When enabled, properties defined on the prototype chain will not be copied to the new merged object. The default behavior is `false`.

```javascript
class Person {
  constructor(name) {
    this.name = name; // <= Own property
  }

  greeting() {
    // <= Prototype property
    return `My name is ${this.name}.`;
  }
}

const John = new Person('John');

console.log(John); // { name: 'John' };
console.log(John.greeting()); // My name is John.
console.log(Object.getPrototypeOf(John).hasOwnProperty('greeting')); // true

const cloneObj = mergician({
  skipProto: true
})({}, John);

console.log(cloneObj); // { name: 'John' };
console.log(cloneObj.greeting()); // undefined
console.log(Object.getPrototypeOf(John).hasOwnProperty('greeting')); // false
```

--------------------------------

### Hoist Enumerable Prototype Properties (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

The `hoistEnumerable` option merges enumerable prototype properties as direct properties of the new merged object. This effectively brings properties from the prototype chain into the object itself. The default value is `false`.

```javascript
const obj = { a: 1 };

console.log(obj); // { a: 1 }
console.log(Object.getPrototypeOf(obj)); // { b: 2 }

const clonedObj = mergician({
  hoistEnumerable: true
})({}, obj);

console.log(clonedObj); // { a: 1, b: 2 }
console.log(Object.getPrototypeOf(clonedObj)); // {}
```

--------------------------------

### Append Arrays During Merge (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

The `appendArrays` option merges array values by appending them to the end of existing arrays. This option does not modify nested arrays. The default behavior is `false`.

```javascript
const obj1 = { a: [1, 1] };
const obj2 = { a: [2, 2] };
const obj3 = { a: [3, 3] };

const mergedObj = mergician({
  appendArrays: true
})(obj1, obj2, obj3);

console.log(mergedObj); // { a: [1, 1, 2, 2, 3, 3] }
```

--------------------------------

### Deduplicate Arrays During Merge (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

The `dedupArrays` option removes duplicate values from merged arrays. This option does not affect nested arrays. The default is `false`. It can be used in conjunction with `appendArrays` for sorted, unique arrays.

```javascript
const obj1 = { a: [1, 1] };
const obj2 = { a: [2, 2] };
const obj3 = { a: [3, 3] };

const clonedObj = mergician({
  dedupArrays: true
})({}, obj1);
const mergedObj = mergician({
  appendArrays: true,
  dedupArrays: true
})(obj1, obj2, obj3);

console.log(clonedObj); // { a: [1] }
console.log(mergedObj); // { a: [1, 2, 3] }
```

--------------------------------

### Sort Arrays During Merge (JavaScript)

Source: https://jhildenbiddle.github.io/mergician/index

The `sortArrays` option sorts array values in the merged object. When `true`, it uses the default `Array.prototype.sort()` comparison. A custom comparison function can be provided for specific sorting logic, such as natural or descending order. Nested arrays are not affected.

```javascript
const obj1 = { a: [1, 4] };
const obj2 = { a: [2, 5] };
const obj3 = { a: [3, 6] };

const mergedAscending = mergician({
  appendArrays: true,
  sortArrays: true
})(obj1, obj2, obj3);
const mergedDescending = mergician({
  appendArrays: true,
  sortArrays(a, b) {
    return b - a;
  }
})(obj1, obj2, obj3);

console.log(mergedAscending); // { a: [1, 2, 3, 4, 5, 6] }
console.log(mergedDescending); // { a: [6, 5, 4, 3, 2, 1] }
```
Tokens:
Raw