Index: imaps-frontend/node_modules/webpack-merge/dist/index.js
===================================================================
--- imaps-frontend/node_modules/webpack-merge/dist/index.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack-merge/dist/index.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,258 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = exports.mergeWithRules = exports.mergeWithCustomize = exports.default = exports.merge = exports.CustomizeRule = exports.customizeObject = exports.customizeArray = void 0;
+var wildcard_1 = __importDefault(require("wildcard"));
+var merge_with_1 = __importDefault(require("./merge-with"));
+var join_arrays_1 = __importDefault(require("./join-arrays"));
+var unique_1 = __importDefault(require("./unique"));
+exports.unique = unique_1.default;
+var types_1 = require("./types");
+Object.defineProperty(exports, "CustomizeRule", { enumerable: true, get: function () { return types_1.CustomizeRule; } });
+var utils_1 = require("./utils");
+function merge(firstConfiguration) {
+    var configurations = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        configurations[_i - 1] = arguments[_i];
+    }
+    return mergeWithCustomize({}).apply(void 0, __spreadArray([firstConfiguration], __read(configurations), false));
+}
+exports.merge = merge;
+exports.default = merge;
+function mergeWithCustomize(options) {
+    return function mergeWithOptions(firstConfiguration) {
+        var configurations = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            configurations[_i - 1] = arguments[_i];
+        }
+        if ((0, utils_1.isUndefined)(firstConfiguration) || configurations.some(utils_1.isUndefined)) {
+            throw new TypeError("Merging undefined is not supported");
+        }
+        // @ts-ignore
+        if (firstConfiguration.then) {
+            throw new TypeError("Promises are not supported");
+        }
+        // No configuration at all
+        if (!firstConfiguration) {
+            return {};
+        }
+        if (configurations.length === 0) {
+            if (Array.isArray(firstConfiguration)) {
+                // Empty array
+                if (firstConfiguration.length === 0) {
+                    return {};
+                }
+                if (firstConfiguration.some(utils_1.isUndefined)) {
+                    throw new TypeError("Merging undefined is not supported");
+                }
+                // @ts-ignore
+                if (firstConfiguration[0].then) {
+                    throw new TypeError("Promises are not supported");
+                }
+                return (0, merge_with_1.default)(firstConfiguration, (0, join_arrays_1.default)(options));
+            }
+            return firstConfiguration;
+        }
+        return (0, merge_with_1.default)([firstConfiguration].concat(configurations), (0, join_arrays_1.default)(options));
+    };
+}
+exports.mergeWithCustomize = mergeWithCustomize;
+function customizeArray(rules) {
+    return function (a, b, key) {
+        var matchedRule = Object.keys(rules).find(function (rule) { return (0, wildcard_1.default)(rule, key); }) || "";
+        if (matchedRule) {
+            switch (rules[matchedRule]) {
+                case types_1.CustomizeRule.Prepend:
+                    return __spreadArray(__spreadArray([], __read(b), false), __read(a), false);
+                case types_1.CustomizeRule.Replace:
+                    return b;
+                case types_1.CustomizeRule.Append:
+                default:
+                    return __spreadArray(__spreadArray([], __read(a), false), __read(b), false);
+            }
+        }
+    };
+}
+exports.customizeArray = customizeArray;
+function mergeWithRules(rules) {
+    return mergeWithCustomize({
+        customizeArray: function (a, b, key) {
+            var currentRule = rules;
+            key.split(".").forEach(function (k) {
+                if (!currentRule) {
+                    return;
+                }
+                currentRule = currentRule[k];
+            });
+            if ((0, utils_1.isPlainObject)(currentRule)) {
+                return mergeWithRule({ currentRule: currentRule, a: a, b: b });
+            }
+            if (typeof currentRule === "string") {
+                return mergeIndividualRule({ currentRule: currentRule, a: a, b: b });
+            }
+            return undefined;
+        },
+    });
+}
+exports.mergeWithRules = mergeWithRules;
+var isArray = Array.isArray;
+function mergeWithRule(_a) {
+    var currentRule = _a.currentRule, a = _a.a, b = _a.b;
+    if (!isArray(a)) {
+        return a;
+    }
+    var bAllMatches = [];
+    var ret = a.map(function (ao) {
+        if (!(0, utils_1.isPlainObject)(currentRule)) {
+            return ao;
+        }
+        var ret = {};
+        var rulesToMatch = [];
+        var operations = {};
+        Object.entries(currentRule).forEach(function (_a) {
+            var _b = __read(_a, 2), k = _b[0], v = _b[1];
+            if (v === types_1.CustomizeRule.Match) {
+                rulesToMatch.push(k);
+            }
+            else {
+                operations[k] = v;
+            }
+        });
+        var bMatches = b.filter(function (o) {
+            var matches = rulesToMatch.every(function (rule) {
+                return (0, utils_1.isSameCondition)(ao[rule], o[rule]);
+            });
+            if (matches) {
+                bAllMatches.push(o);
+            }
+            return matches;
+        });
+        if (!(0, utils_1.isPlainObject)(ao)) {
+            return ao;
+        }
+        Object.entries(ao).forEach(function (_a) {
+            var _b = __read(_a, 2), k = _b[0], v = _b[1];
+            var rule = currentRule;
+            switch (currentRule[k]) {
+                case types_1.CustomizeRule.Match:
+                    ret[k] = v;
+                    Object.entries(rule).forEach(function (_a) {
+                        var _b = __read(_a, 2), k = _b[0], v = _b[1];
+                        if (v === types_1.CustomizeRule.Replace && bMatches.length > 0) {
+                            var val = last(bMatches)[k];
+                            if (typeof val !== "undefined") {
+                                ret[k] = val;
+                            }
+                        }
+                    });
+                    break;
+                case types_1.CustomizeRule.Append:
+                    if (!bMatches.length) {
+                        ret[k] = v;
+                        break;
+                    }
+                    var appendValue = last(bMatches)[k];
+                    if (!isArray(v) || !isArray(appendValue)) {
+                        throw new TypeError("Trying to append non-arrays");
+                    }
+                    ret[k] = v.concat(appendValue);
+                    break;
+                case types_1.CustomizeRule.Merge:
+                    if (!bMatches.length) {
+                        ret[k] = v;
+                        break;
+                    }
+                    var lastValue = last(bMatches)[k];
+                    if (!(0, utils_1.isPlainObject)(v) || !(0, utils_1.isPlainObject)(lastValue)) {
+                        throw new TypeError("Trying to merge non-objects");
+                    }
+                    // deep merge
+                    ret[k] = merge(v, lastValue);
+                    break;
+                case types_1.CustomizeRule.Prepend:
+                    if (!bMatches.length) {
+                        ret[k] = v;
+                        break;
+                    }
+                    var prependValue = last(bMatches)[k];
+                    if (!isArray(v) || !isArray(prependValue)) {
+                        throw new TypeError("Trying to prepend non-arrays");
+                    }
+                    ret[k] = prependValue.concat(v);
+                    break;
+                case types_1.CustomizeRule.Replace:
+                    ret[k] = bMatches.length > 0 ? last(bMatches)[k] : v;
+                    break;
+                default:
+                    var currentRule_1 = operations[k];
+                    // Use .flat(); starting from Node 12
+                    var b_1 = bMatches
+                        .map(function (o) { return o[k]; })
+                        .reduce(function (acc, val) {
+                        return isArray(acc) && isArray(val) ? __spreadArray(__spreadArray([], __read(acc), false), __read(val), false) : acc;
+                    }, []);
+                    ret[k] = mergeWithRule({ currentRule: currentRule_1, a: v, b: b_1 });
+                    break;
+            }
+        });
+        return ret;
+    });
+    return ret.concat(b.filter(function (o) { return !bAllMatches.includes(o); }));
+}
+function mergeIndividualRule(_a) {
+    var currentRule = _a.currentRule, a = _a.a, b = _a.b;
+    // What if there's no match?
+    switch (currentRule) {
+        case types_1.CustomizeRule.Append:
+            return a.concat(b);
+        case types_1.CustomizeRule.Prepend:
+            return b.concat(a);
+        case types_1.CustomizeRule.Replace:
+            return b;
+    }
+    return a;
+}
+function last(arr) {
+    return arr[arr.length - 1];
+}
+function customizeObject(rules) {
+    return function (a, b, key) {
+        switch (rules[key]) {
+            case types_1.CustomizeRule.Prepend:
+                return (0, merge_with_1.default)([b, a], (0, join_arrays_1.default)());
+            case types_1.CustomizeRule.Replace:
+                return b;
+            case types_1.CustomizeRule.Append:
+                return (0, merge_with_1.default)([a, b], (0, join_arrays_1.default)());
+        }
+    };
+}
+exports.customizeObject = customizeObject;
+//# sourceMappingURL=index.js.map
