@wener/utils 1.1.51 → 1.1.53

package/lib/objects/merge/merge.test.js

@@ -0,0 +1,1397 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    }
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function () {
+        var self = this, args = arguments;
+        return new Promise(function (resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [
+                        op[0] & 2,
+                        t.value
+                    ];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { assert, describe, test } from "vitest";
+import { isPlainObject } from "../../langs/isPlainObject.js";
+import { merge } from "./merge.js";
+describe("custom-array-merge", function () {
+    test("custom merge array", function () {
+        var mergeFunctionCalled = false;
+        function overwriteMerge(_target, source, options) {
+            mergeFunctionCalled = true;
+            assert.equal(options.arrayMerge, overwriteMerge);
+            return source;
+        }
+        var destination = {
+            someArray: [
+                1,
+                2
+            ],
+            someObject: {
+                what: "yes"
+            }
+        };
+        var source = {
+            someArray: [
+                1,
+                2,
+                3
+            ]
+        };
+        var actual = merge(destination, source, {
+            arrayMerge: overwriteMerge
+        });
+        var expected = {
+            someArray: [
+                1,
+                2,
+                3
+            ],
+            someObject: {
+                what: "yes"
+            }
+        };
+        assert.isTrue(mergeFunctionCalled);
+        assert.deepEqual(actual, expected);
+    });
+    test("merge top-level arrays", function () {
+        function overwriteMerge(_a, b) {
+            return b;
+        }
+        var actual = merge([
+            1,
+            2
+        ], [
+            1,
+            2
+        ], {
+            arrayMerge: overwriteMerge
+        });
+        var expected = [
+            1,
+            2
+        ];
+        assert.deepEqual(actual, expected);
+    });
+    test("cloner function is available for merge functions to use", function () {
+        var customMergeWasCalled = false;
+        function cloneMerge(target, source, options) {
+            customMergeWasCalled = true;
+            assert.isTrue(!!options.cloneUnlessOtherwiseSpecified, "cloner function is available");
+            return target.concat(source).map(function (element) {
+                return options.cloneUnlessOtherwiseSpecified(element, options);
+            });
+        }
+        var src = {
+            key1: [
+                "one",
+                "three"
+            ],
+            key2: [
+                "four"
+            ]
+        };
+        var target = {
+            key1: [
+                "one",
+                "two"
+            ]
+        };
+        var expected = {
+            key1: [
+                "one",
+                "two",
+                "one",
+                "three"
+            ],
+            key2: [
+                "four"
+            ]
+        };
+        assert.deepEqual(merge(target, src, {
+            arrayMerge: cloneMerge
+        }), expected);
+        assert.isTrue(customMergeWasCalled);
+        assert.isTrue(Array.isArray(merge(target, src).key1));
+        assert.isTrue(Array.isArray(merge(target, src).key2));
+    });
+});
+describe("custom-is-mergeable-object", function () {
+    test("isMergeableObject function copying object over object", function () {
+        var isMergeableObject = function isMergeableObject(object) {
+            return object && (typeof object === "undefined" ? "undefined" : _type_of(object)) === "object" && object.isMergeable !== false;
+        };
+        var src = {
+            key: {
+                isMergeable: false
+            },
+            baz: "yes"
+        };
+        var target = {
+            key: {
+                foo: "wat"
+            },
+            baz: "whatever"
+        };
+        var res = merge(target, src, {
+            isMergeableObject: isMergeableObject
+        });
+        assert.deepEqual(res, {
+            key: {
+                isMergeable: false
+            },
+            baz: "yes"
+        });
+        assert.equal(res.key, src.key, "Object has the same identity and was not cloned");
+    });
+    test("isMergeableObject function copying object over nothing", function () {
+        var isMergeableObject = function isMergeableObject(object) {
+            return object && (typeof object === "undefined" ? "undefined" : _type_of(object)) === "object" && object.isMergeable !== false;
+        };
+        var src = {
+            key: {
+                isMergeable: false,
+                foo: "bar"
+            },
+            baz: "yes"
+        };
+        var target = {
+            baz: "whatever"
+        };
+        var res = merge(target, src, {
+            isMergeableObject: isMergeableObject
+        });
+        assert.deepEqual(res, {
+            key: {
+                isMergeable: false,
+                foo: "bar"
+            },
+            baz: "yes"
+        });
+        assert.equal(res.key, src.key, "Object has the same identity and was not cloned");
+    });
+    test("example from readme", function () {
+        var SuperSpecial = function SuperSpecial() {
+            "use strict";
+            _class_call_check(this, SuperSpecial);
+            _define_property(this, "special", "oh yeah man totally");
+        };
+        var instantiatedSpecialObject = new SuperSpecial();
+        var target = {
+            someProperty: {
+                cool: "oh for sure"
+            }
+        };
+        var source = {
+            someProperty: instantiatedSpecialObject
+        };
+        var defaultOutput = merge(target, source);
+        assert.equal(defaultOutput.someProperty.cool, "oh for sure");
+        assert.equal(defaultOutput.someProperty.special, "oh yeah man totally");
+        assert.equal(_instanceof(defaultOutput.someProperty, SuperSpecial), false);
+        var customMergeOutput = merge(target, source, {
+            isMergeableObject: isPlainObject
+        });
+        assert.equal(customMergeOutput.someProperty.cool, undefined);
+        assert.equal(customMergeOutput.someProperty.special, "oh yeah man totally");
+        assert.equal(_instanceof(customMergeOutput.someProperty, SuperSpecial), true);
+    });
+});
+describe("merge-all", function () {
+    test("throw error if first argument is not an array", function () {
+        assert.throws(merge.all.bind(null, {
+            example: true
+        }, {
+            another: "2"
+        }), Error);
+    });
+    test("return an empty object if first argument is an array with no elements", function () {
+        assert.deepEqual(merge.all([]), {});
+    });
+    test("Work just fine if first argument is an array with least than two elements", function () {
+        var actual = merge.all([
+            {
+                example: true
+            }
+        ]);
+        var expected = {
+            example: true
+        };
+        assert.deepEqual(actual, expected);
+    });
+    test("execute correctly if options object were not passed", function () {
+        var arrayToMerge = [
+            {
+                example: true
+            },
+            {
+                another: "123"
+            }
+        ];
+        assert.doesNotThrow(merge.all.bind(null, arrayToMerge));
+    });
+    test("execute correctly if options object were passed", function () {
+        var arrayToMerge = [
+            {
+                example: true
+            },
+            {
+                another: "123"
+            }
+        ];
+        assert.doesNotThrow(merge.all.bind(null, arrayToMerge, {
+            clone: true
+        }));
+    });
+    test("invoke merge on every item in array should result with all props", function () {
+        var firstObject = {
+            first: true
+        };
+        var secondObject = {
+            second: false
+        };
+        var thirdObject = {
+            third: 123
+        };
+        var fourthObject = {
+            fourth: "some string"
+        };
+        var mergedObject = merge.all([
+            firstObject,
+            secondObject,
+            thirdObject,
+            fourthObject
+        ]);
+        assert.isTrue(mergedObject.first === true);
+        assert.isTrue(mergedObject.second === false);
+        assert.isTrue(mergedObject.third === 123);
+        assert.isTrue(mergedObject.fourth === "some string");
+    });
+    test("invoke merge on every item in array with clone should clone all elements", function () {
+        var firstObject = {
+            a: {
+                d: 123
+            }
+        };
+        var secondObject = {
+            b: {
+                e: true
+            }
+        };
+        var thirdObject = {
+            c: {
+                f: "string"
+            }
+        };
+        var mergedWithClone = merge.all([
+            firstObject,
+            secondObject,
+            thirdObject
+        ], {
+            clone: true
+        });
+        assert.notEqual(mergedWithClone.a, firstObject.a);
+        assert.notEqual(mergedWithClone.b, secondObject.b);
+        assert.notEqual(mergedWithClone.c, thirdObject.c);
+    });
+    test("invoke merge on every item in array clone=false should not clone all elements", function () {
+        var firstObject = {
+            a: {
+                d: 123
+            }
+        };
+        var secondObject = {
+            b: {
+                e: true
+            }
+        };
+        var thirdObject = {
+            c: {
+                f: "string"
+            }
+        };
+        var mergedWithoutClone = merge.all([
+            firstObject,
+            secondObject,
+            thirdObject
+        ], {
+            clone: false
+        });
+        assert.equal(mergedWithoutClone.a, firstObject.a);
+        assert.equal(mergedWithoutClone.b, secondObject.b);
+        assert.equal(mergedWithoutClone.c, thirdObject.c);
+    });
+    test("invoke merge on every item in array without clone should clone all elements", function () {
+        var firstObject = {
+            a: {
+                d: 123
+            }
+        };
+        var secondObject = {
+            b: {
+                e: true
+            }
+        };
+        var thirdObject = {
+            c: {
+                f: "string"
+            }
+        };
+        var mergedWithoutClone = merge.all([
+            firstObject,
+            secondObject,
+            thirdObject
+        ]);
+        assert.notEqual(mergedWithoutClone.a, firstObject.a);
+        assert.notEqual(mergedWithoutClone.b, secondObject.b);
+        assert.notEqual(mergedWithoutClone.c, thirdObject.c);
+    });
+});
+describe("merge", function () {
+    test("add keys in target that do not exist at the root", function () {
+        var src = {
+            key1: "value1",
+            key2: "value2"
+        };
+        var target = {};
+        var res = merge(target, src);
+        assert.deepEqual(target, {}, "merge should be immutable");
+        assert.deepEqual(res, src);
+    });
+    test("merge existing simple keys in target at the roots", function () {
+        var src = {
+            key1: "changed",
+            key2: "value2"
+        };
+        var target = {
+            key1: "value1",
+            key3: "value3"
+        };
+        var expected = {
+            key1: "changed",
+            key2: "value2",
+            key3: "value3"
+        };
+        assert.deepEqual(target, {
+            key1: "value1",
+            key3: "value3"
+        });
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("merge nested objects into target", function () {
+        var src = {
+            key1: {
+                subkey1: "changed",
+                subkey3: "added"
+            }
+        };
+        var target = {
+            key1: {
+                subkey1: "value1",
+                subkey2: "value2"
+            }
+        };
+        var expected = {
+            key1: {
+                subkey1: "changed",
+                subkey2: "value2",
+                subkey3: "added"
+            }
+        };
+        assert.deepEqual(target, {
+            key1: {
+                subkey1: "value1",
+                subkey2: "value2"
+            }
+        });
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("replace simple key with nested object in target", function () {
+        var src = {
+            key1: {
+                subkey1: "subvalue1",
+                subkey2: "subvalue2"
+            }
+        };
+        var target = {
+            key1: "value1",
+            key2: "value2"
+        };
+        var expected = {
+            key1: {
+                subkey1: "subvalue1",
+                subkey2: "subvalue2"
+            },
+            key2: "value2"
+        };
+        assert.deepEqual(target, {
+            key1: "value1",
+            key2: "value2"
+        });
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("should add nested object in target", function () {
+        var src = {
+            b: {
+                c: {}
+            }
+        };
+        var target = {
+            a: {}
+        };
+        var expected = {
+            a: {},
+            b: {
+                c: {}
+            }
+        };
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("should clone source and target", function () {
+        var src = {
+            b: {
+                c: "foo"
+            }
+        };
+        var target = {
+            a: {
+                d: "bar"
+            }
+        };
+        var expected = {
+            a: {
+                d: "bar"
+            },
+            b: {
+                c: "foo"
+            }
+        };
+        var merged = merge(target, src, {
+            clone: true
+        });
+        assert.deepEqual(merged, expected);
+        assert.notEqual(merged.a, target.a);
+        assert.notEqual(merged.b, src.b);
+    });
+    test("should clone source and target", function () {
+        var src = {
+            b: {
+                c: "foo"
+            }
+        };
+        var target = {
+            a: {
+                d: "bar"
+            }
+        };
+        var merged = merge(target, src);
+        assert.notEqual(merged.a, target.a);
+        assert.notEqual(merged.b, src.b);
+    });
+    test("should replace object with simple key in target", function () {
+        var src = {
+            key1: "value1"
+        };
+        var target = {
+            key1: {
+                subkey1: "subvalue1",
+                subkey2: "subvalue2"
+            },
+            key2: "value2"
+        };
+        var expected = {
+            key1: "value1",
+            key2: "value2"
+        };
+        assert.deepEqual(target, {
+            key1: {
+                subkey1: "subvalue1",
+                subkey2: "subvalue2"
+            },
+            key2: "value2"
+        });
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("should replace objects with arrays", function () {
+        var target = {
+            key1: {
+                subkey: "one"
+            }
+        };
+        var src = {
+            key1: [
+                "subkey"
+            ]
+        };
+        var expected = {
+            key1: [
+                "subkey"
+            ]
+        };
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("should replace arrays with objects", function () {
+        var target = {
+            key1: [
+                "subkey"
+            ]
+        };
+        var src = {
+            key1: {
+                subkey: "one"
+            }
+        };
+        var expected = {
+            key1: {
+                subkey: "one"
+            }
+        };
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("should replace dates with arrays", function () {
+        var target = {
+            key1: new Date()
+        };
+        var src = {
+            key1: [
+                "subkey"
+            ]
+        };
+        var expected = {
+            key1: [
+                "subkey"
+            ]
+        };
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("should replace null with arrays", function () {
+        var target = {
+            key1: null
+        };
+        var src = {
+            key1: [
+                "subkey"
+            ]
+        };
+        var expected = {
+            key1: [
+                "subkey"
+            ]
+        };
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("should work on simple array", function () {
+        var src = [
+            "one",
+            "three"
+        ];
+        var target = [
+            "one",
+            "two"
+        ];
+        var expected = [
+            "one",
+            "two",
+            "one",
+            "three"
+        ];
+        assert.deepEqual(merge(target, src), expected);
+        assert.isTrue(Array.isArray(merge(target, src)));
+    });
+    test("should work on another simple array", function () {
+        var target = [
+            "a1",
+            "a2",
+            "c1",
+            "f1",
+            "p1"
+        ];
+        var src = [
+            "t1",
+            "s1",
+            "c2",
+            "r1",
+            "p2",
+            "p3"
+        ];
+        var expected = [
+            "a1",
+            "a2",
+            "c1",
+            "f1",
+            "p1",
+            "t1",
+            "s1",
+            "c2",
+            "r1",
+            "p2",
+            "p3"
+        ];
+        assert.deepEqual(target, [
+            "a1",
+            "a2",
+            "c1",
+            "f1",
+            "p1"
+        ]);
+        assert.deepEqual(merge(target, src), expected);
+        assert.isTrue(Array.isArray(merge(target, src)));
+    });
+    test("should work on array properties", function () {
+        var src = {
+            key1: [
+                "one",
+                "three"
+            ],
+            key2: [
+                "four"
+            ]
+        };
+        var target = {
+            key1: [
+                "one",
+                "two"
+            ]
+        };
+        var expected = {
+            key1: [
+                "one",
+                "two",
+                "one",
+                "three"
+            ],
+            key2: [
+                "four"
+            ]
+        };
+        assert.deepEqual(merge(target, src), expected);
+        assert.isTrue(Array.isArray(merge(target, src).key1));
+        assert.isTrue(Array.isArray(merge(target, src).key2));
+    });
+    test("should work on array properties with clone option", function () {
+        var src = {
+            key1: [
+                "one",
+                "three"
+            ],
+            key2: [
+                "four"
+            ]
+        };
+        var target = {
+            key1: [
+                "one",
+                "two"
+            ]
+        };
+        assert.deepEqual(target, {
+            key1: [
+                "one",
+                "two"
+            ]
+        });
+        var merged = merge(target, src, {
+            clone: true
+        });
+        assert.notEqual(merged.key1, src.key1);
+        assert.notEqual(merged.key1, target.key1);
+        assert.notEqual(merged.key2, src.key2);
+    });
+    test("should work on array of objects", function () {
+        var src = [
+            {
+                key1: [
+                    "one",
+                    "three"
+                ],
+                key2: [
+                    "one"
+                ]
+            },
+            {
+                key3: [
+                    "five"
+                ]
+            }
+        ];
+        var target = [
+            {
+                key1: [
+                    "one",
+                    "two"
+                ]
+            },
+            {
+                key3: [
+                    "four"
+                ]
+            }
+        ];
+        var expected = [
+            {
+                key1: [
+                    "one",
+                    "two"
+                ]
+            },
+            {
+                key3: [
+                    "four"
+                ]
+            },
+            {
+                key1: [
+                    "one",
+                    "three"
+                ],
+                key2: [
+                    "one"
+                ]
+            },
+            {
+                key3: [
+                    "five"
+                ]
+            }
+        ];
+        assert.deepEqual(merge(target, src), expected);
+        assert.isTrue(Array.isArray(merge(target, src)), "result should be an array");
+        assert.isTrue(Array.isArray(merge(target, src)[0].key1), "subkey should be an array too");
+    });
+    test("should work on array of objects with clone option", function () {
+        var src = [
+            {
+                key1: [
+                    "one",
+                    "three"
+                ],
+                key2: [
+                    "one"
+                ]
+            },
+            {
+                key3: [
+                    "five"
+                ]
+            }
+        ];
+        var target = [
+            {
+                key1: [
+                    "one",
+                    "two"
+                ]
+            },
+            {
+                key3: [
+                    "four"
+                ]
+            }
+        ];
+        var expected = [
+            {
+                key1: [
+                    "one",
+                    "two"
+                ]
+            },
+            {
+                key3: [
+                    "four"
+                ]
+            },
+            {
+                key1: [
+                    "one",
+                    "three"
+                ],
+                key2: [
+                    "one"
+                ]
+            },
+            {
+                key3: [
+                    "five"
+                ]
+            }
+        ];
+        var merged = merge(target, src, {
+            clone: true
+        });
+        assert.deepEqual(merged, expected);
+        assert.isTrue(Array.isArray(merge(target, src)), "result should be an array");
+        assert.isTrue(Array.isArray(merge(target, src)[0].key1), "subkey should be an array too");
+        assert.notEqual(merged[0].key1, src[0].key1);
+        assert.notEqual(merged[0].key1, target[0].key1);
+        assert.notEqual(merged[0].key2, src[0].key2);
+        assert.notEqual(merged[1].key3, src[1].key3);
+        assert.notEqual(merged[1].key3, target[1].key3);
+    });
+    test("should treat regular expressions like primitive values", function () {
+        var target = {
+            key1: /abc/
+        };
+        var src = {
+            key1: /efg/
+        };
+        var expected = {
+            key1: /efg/
+        };
+        assert.deepEqual(merge(target, src), expected);
+        assert.deepEqual(merge(target, src).key1.test("efg"), true);
+    });
+    test("should treat regular expressions like primitive values and should not" + " clone even with clone option", function () {
+        var target = {
+            key1: /abc/
+        };
+        var src = {
+            key1: /efg/
+        };
+        var output = merge(target, src, {
+            clone: true
+        });
+        assert.equal(output.key1, src.key1);
+    });
+    test("should treat dates like primitives", function () {
+        var monday = new Date("2016-09-27T01:08:12.761Z");
+        var tuesday = new Date("2016-09-28T01:18:12.761Z");
+        var target = {
+            key: monday
+        };
+        var source = {
+            key: tuesday
+        };
+        var expected = {
+            key: tuesday
+        };
+        var actual = merge(target, source);
+        assert.deepEqual(actual, expected);
+        assert.equal(actual.key.valueOf(), tuesday.valueOf());
+    });
+    test("should treat dates like primitives and should not clone even with clone" + " option", function () {
+        var monday = new Date("2016-09-27T01:08:12.761Z");
+        var tuesday = new Date("2016-09-28T01:18:12.761Z");
+        var target = {
+            key: monday
+        };
+        var source = {
+            key: tuesday
+        };
+        var actual = merge(target, source, {
+            clone: true
+        });
+        assert.equal(actual.key, tuesday);
+    });
+    test("should work on array with null in it", function () {
+        var target = [];
+        var src = [
+            null
+        ];
+        var expected = [
+            null
+        ];
+        assert.deepEqual(merge(target, src), expected);
+    });
+    test("should clone array's element if it is object", function () {
+        var a = {
+            key: "yup"
+        };
+        var target = [];
+        var source = [
+            a
+        ];
+        var output = merge(target, source, {
+            clone: true
+        });
+        assert.notEqual(output[0], a);
+        assert.equal(output[0].key, "yup");
+    });
+    test("should clone an array property when there is no target array", function () {
+        var someObject = {};
+        var target = {};
+        var source = {
+            ary: [
+                someObject
+            ]
+        };
+        var output = merge(target, source, {
+            clone: true
+        });
+        assert.deepEqual(output, {
+            ary: [
+                {}
+            ]
+        });
+        assert.notEqual(output.ary[0], someObject);
+    });
+    test("should overwrite values when property is initialised but undefined", function () {
+        var target1 = {
+            value: []
+        };
+        var target2 = {
+            value: null
+        };
+        var target3 = {
+            value: 2
+        };
+        var src = {
+            value: undefined
+        };
+        function hasUndefinedProperty(o) {
+            assert.isTrue(o.hasOwnProperty("value"));
+            assert.equal(_type_of(o.value), "undefined");
+        }
+        hasUndefinedProperty(merge(target1, src));
+        hasUndefinedProperty(merge(target2, src));
+        hasUndefinedProperty(merge(target3, src));
+    });
+    test("dates should copy correctly in an array", function () {
+        var monday = new Date("2016-09-27T01:08:12.761Z");
+        var tuesday = new Date("2016-09-28T01:18:12.761Z");
+        var target = [
+            monday,
+            "dude"
+        ];
+        var source = [
+            tuesday,
+            "lol"
+        ];
+        var expected = [
+            monday,
+            "dude",
+            tuesday,
+            "lol"
+        ];
+        var actual = merge(target, source);
+        assert.deepEqual(actual, expected);
+    });
+    test("should handle custom merge functions", function () {
+        var target = {
+            letters: [
+                "a",
+                "b"
+            ],
+            people: {
+                first: "Alex",
+                second: "Bert"
+            }
+        };
+        var source = {
+            letters: [
+                "c"
+            ],
+            people: {
+                first: "Smith",
+                second: "Bertson",
+                third: "Car"
+            }
+        };
+        var mergePeople = function (target, source) {
+            var keys = new Set(Object.keys(target).concat(Object.keys(source)));
+            var destination = {};
+            keys.forEach(function (key) {
+                if (key in target && key in source) {
+                    destination[key] = "".concat(target[key], "-").concat(source[key]);
+                }
+                else if (key in target) {
+                    destination[key] = target[key];
+                }
+                else {
+                    destination[key] = source[key];
+                }
+            });
+            return destination;
+        };
+        var options = {
+            customMerge: function (key) {
+                if (key === "people") {
+                    return mergePeople;
+                }
+                return merge;
+            }
+        };
+        var expected = {
+            letters: [
+                "a",
+                "b",
+                "c"
+            ],
+            people: {
+                first: "Alex-Smith",
+                second: "Bert-Bertson",
+                third: "Car"
+            }
+        };
+        var actual = merge(target, source, options);
+        assert.deepEqual(actual, expected);
+    });
+    test("should handle custom merge functions", function () {
+        var target = {
+            letters: [
+                "a",
+                "b"
+            ],
+            people: {
+                first: "Alex",
+                second: "Bert"
+            }
+        };
+        var source = {
+            letters: [
+                "c"
+            ],
+            people: {
+                first: "Smith",
+                second: "Bertson",
+                third: "Car"
+            }
+        };
+        var mergeLetters = function () {
+            return "merged letters";
+        };
+        var options = {
+            customMerge: function (key) {
+                if (key === "letters") {
+                    return mergeLetters;
+                }
+                return;
+            }
+        };
+        var expected = {
+            letters: "merged letters",
+            people: {
+                first: "Smith",
+                second: "Bertson",
+                third: "Car"
+            }
+        };
+        var actual = merge(target, source, options);
+        assert.deepEqual(actual, expected);
+    });
+    test("should merge correctly if custom merge is not a valid function", function () {
+        var target = {
+            letters: [
+                "a",
+                "b"
+            ],
+            people: {
+                first: "Alex",
+                second: "Bert"
+            }
+        };
+        var source = {
+            letters: [
+                "c"
+            ],
+            people: {
+                first: "Smith",
+                second: "Bertson",
+                third: "Car"
+            }
+        };
+        var options = {
+            customMerge: function () {
+                return false;
+            }
+        };
+        var expected = {
+            letters: [
+                "a",
+                "b",
+                "c"
+            ],
+            people: {
+                first: "Smith",
+                second: "Bertson",
+                third: "Car"
+            }
+        };
+        var actual = merge(target, source, options);
+        assert.deepEqual(actual, expected);
+    });
+    test("copy symbol keys in target that do not exist on the target", function () {
+        var mySymbol = Symbol();
+        var src = _define_property({}, mySymbol, "value1");
+        var target = {};
+        var res = merge(target, src);
+        assert.equal(res[mySymbol], "value1");
+        assert.deepEqual(Object.getOwnPropertySymbols(res), Object.getOwnPropertySymbols(src));
+    });
+    test("copy symbol keys in target that do exist on the target", function () {
+        var mySymbol = Symbol();
+        var src = _define_property({}, mySymbol, "value1");
+        var target = _define_property({}, mySymbol, "wat");
+        var res = merge(target, src);
+        assert.equal(res[mySymbol], "value1");
+    });
+    test("Falsey properties should be mergeable", function () {
+        var uniqueValue = {};
+        var target = {
+            wat: false
+        };
+        var source = {
+            wat: false
+        };
+        var customMergeWasCalled = false;
+        var result = merge(target, source, {
+            isMergeableObject: function isMergeableObject() {
+                return true;
+            },
+            customMerge: function customMerge() {
+                return function () {
+                    customMergeWasCalled = true;
+                    return uniqueValue;
+                };
+            }
+        });
+        assert.equal(result.wat, uniqueValue);
+        assert.isTrue(customMergeWasCalled, "custom merge function was called");
+    });
+});
+describe("prototype-poisoning", function () {
+    return _async_to_generator(function () {
+        var isMergeableObject;
+        return _ts_generator(this, function (_state) {
+            switch (_state.label) {
+                case 0:
+                    return [
+                        4,
+                        import("./isMergeableObject.js")
+                    ];
+                case 1:
+                    isMergeableObject = _state.sent().isMergeableObject;
+                    test("merging objects with own __proto__", function () {
+                        var user = {};
+                        var malicious = JSON.parse("{ \"__proto__\": { \"admin\": true } }");
+                        var mergedObject = merge(user, malicious);
+                        assert.isFalse(!!mergedObject.__proto__.admin, "non-plain properties should not be merged");
+                        assert.isFalse(!!mergedObject.admin, "the destination should have an unmodified prototype");
+                    });
+                    test("merging objects with plain and non-plain properties", function () {
+                        var plainSymbolKey = Symbol("plainSymbolKey");
+                        var parent = {
+                            parentKey: "should be undefined"
+                        };
+                        var target = Object.create(parent);
+                        target.plainKey = "should be replaced";
+                        target[plainSymbolKey] = "should also be replaced";
+                        var source = _define_property({
+                            parentKey: "foo",
+                            plainKey: "bar",
+                            newKey: "baz"
+                        }, plainSymbolKey, "qux");
+                        var mergedObject = merge(target, source);
+                        assert.equal(undefined, mergedObject.parentKey, "inherited properties of target should be removed, not merged or ignored");
+                        assert.equal("bar", mergedObject.plainKey, "enumerable own properties of target should be merged");
+                        assert.equal("baz", mergedObject.newKey, "properties not yet on target should be merged");
+                        assert.equal("qux", mergedObject[plainSymbolKey], "enumerable own symbol properties of target should be merged");
+                    });
+                    // the following cases come from the thread here: https://github.com/TehShrike/deepmerge/pull/164
+                    test("merging strings works with a custom string merge", function () {
+                        var target = {
+                            name: "Alexander"
+                        };
+                        var source = {
+                            name: "Hamilton"
+                        };
+                        function customMerge(key) {
+                            if (key === "name") {
+                                return function (target, source) {
+                                    return target[0] + ". " + source.substring(0, 3);
+                                };
+                            }
+                            else {
+                                return merge;
+                            }
+                        }
+                        function mergeable(target) {
+                            return isMergeableObject(target) || typeof target === "string" && target.length > 1;
+                        }
+                        assert.equal("A. Ham", merge(target, source, {
+                            customMerge: customMerge,
+                            isMergeableObject: mergeable
+                        }).name);
+                    });
+                    test("merging objects with null prototype", function () {
+                        var target = Object.create(null);
+                        var source = Object.create(null);
+                        target.wheels = 4;
+                        target.trunk = {
+                            toolbox: [
+                                "hammer"
+                            ]
+                        };
+                        source.trunk = {
+                            toolbox: [
+                                "wrench"
+                            ]
+                        };
+                        source.engine = "v8";
+                        var expected = {
+                            wheels: 4,
+                            engine: "v8",
+                            trunk: {
+                                toolbox: [
+                                    "hammer",
+                                    "wrench"
+                                ]
+                            }
+                        };
+                        assert.deepEqual(expected, merge(target, source));
+                    });
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});