source: node_modules/deep-extend/lib/deep-extend.js

/*!
 * @description Recursive object extending
 * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
 * @license MIT
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2013-2018 Viacheslav Lotsmanov
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

'use strict';

function isSpecificValue(val) {
        return (
                val instanceof Buffer
                || val instanceof Date
                || val instanceof RegExp
        ) ? true : false;
}

function cloneSpecificValue(val) {
        if (val instanceof Buffer) {
                var x = Buffer.alloc
                        ? Buffer.alloc(val.length)
                        : new Buffer(val.length);
                val.copy(x);
                return x;
        } else if (val instanceof Date) {
                return new Date(val.getTime());
        } else if (val instanceof RegExp) {
                return new RegExp(val);
        } else {
                throw new Error('Unexpected situation');
        }
}

/**
 * Recursive cloning array.
 */
function deepCloneArray(arr) {
        var clone = [];
        arr.forEach(function (item, index) {
                if (typeof item === 'object' && item !== null) {
                        if (Array.isArray(item)) {
                                clone[index] = deepCloneArray(item);
                        } else if (isSpecificValue(item)) {
                                clone[index] = cloneSpecificValue(item);
                        } else {
                                clone[index] = deepExtend({}, item);
                        }
                } else {
                        clone[index] = item;
                }
        });
        return clone;
}

function safeGetProperty(object, property) {
        return property === '__proto__' ? undefined : object[property];
}

/**
 * Extening object that entered in first argument.
 *
 * Returns extended object or false if have no target object or incorrect type.
 *
 * If you wish to clone source object (without modify it), just use empty new
 * object as first argument, like this:
 *   deepExtend({}, yourObj_1, [yourObj_N]);
 */
var deepExtend = module.exports = function (/*obj_1, [obj_2], [obj_N]*/) {
        if (arguments.length < 1 || typeof arguments[0] !== 'object') {
                return false;
        }

        if (arguments.length < 2) {
                return arguments[0];
        }

        var target = arguments[0];

        // convert arguments to array and cut off target object
        var args = Array.prototype.slice.call(arguments, 1);

        var val, src, clone;

        args.forEach(function (obj) {
                // skip argument if isn't an object, is null, or is an array
                if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
                        return;
                }

                Object.keys(obj).forEach(function (key) {
                        src = safeGetProperty(target, key); // source value
                        val = safeGetProperty(obj, key); // new value

                        // recursion prevention
                        if (val === target) {
                                return;

                        /**
                         * if new value isn't object then just overwrite by new value
                         * instead of extending.
                         */
                        } else if (typeof val !== 'object' || val === null) {
                                target[key] = val;
                                return;

                        // just clone arrays (and recursive clone objects inside)
                        } else if (Array.isArray(val)) {
                                target[key] = deepCloneArray(val);
                                return;

                        // custom cloning and overwrite for specific objects
                        } else if (isSpecificValue(val)) {
                                target[key] = cloneSpecificValue(val);
                                return;

                        // overwrite by new value if source isn't object or array
                        } else if (typeof src !== 'object' || src === null || Array.isArray(src)) {
                                target[key] = deepExtend({}, val);
                                return;

                        // source value and new value is objects both, extending...
                        } else {
                                target[key] = deepExtend(src, val);
                                return;
                        }
                });
        });

        return target;
};