Initial commit: notification-elements-demo app

Interactive Angular 19 demo for @sda/notification-elements-ui with
6 sections: Bell & Feed, Notification Center, Inbox, Comments &
Threads, Mention Input, and Full-Featured layout. Includes mock
data, dark mode toggle, and real-time event log.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

node_modules/webpack-merge/dist/index.d.ts

@@ -0,0 +1,15 @@
+import unique from "./unique";
+import { CustomizeRule, CustomizeRuleString, ICustomizeOptions, Key } from "./types";
+declare function merge<Configuration extends object>(firstConfiguration: Configuration | Configuration[], ...configurations: Configuration[]): Configuration;
+declare function mergeWithCustomize<Configuration extends object>(options: ICustomizeOptions): (firstConfiguration: Configuration | Configuration[], ...configurations: Configuration[]) => Configuration;
+declare function customizeArray(rules: {
+    [s: string]: CustomizeRule | CustomizeRuleString;
+}): (a: any, b: any, key: Key) => any;
+type Rules = {
+    [s: string]: CustomizeRule | CustomizeRuleString | Rules;
+};
+declare function mergeWithRules(rules: Rules): (firstConfiguration: object | object[], ...configurations: object[]) => object;
+declare function customizeObject(rules: {
+    [s: string]: CustomizeRule | CustomizeRuleString;
+}): (a: any, b: any, key: Key) => any;
+export { customizeArray, customizeObject, CustomizeRule, merge, merge as default, mergeWithCustomize, mergeWithRules, unique, };

node_modules/webpack-merge/dist/index.js

@@ -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

node_modules/webpack-merge/dist/join-arrays.d.ts

@@ -0,0 +1,6 @@
+import { Customize, Key } from "./types";
+export default function joinArrays({ customizeArray, customizeObject, key, }?: {
+    customizeArray?: Customize;
+    customizeObject?: Customize;
+    key?: Key;
+}): (a: any, b: any, k: Key) => any;

node_modules/webpack-merge/dist/join-arrays.js

@@ -0,0 +1,78 @@
+"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 });
+var clone_deep_1 = __importDefault(require("clone-deep"));
+var merge_with_1 = __importDefault(require("./merge-with"));
+var utils_1 = require("./utils");
+var isArray = Array.isArray;
+function joinArrays(_a) {
+    var _b = _a === void 0 ? {} : _a, customizeArray = _b.customizeArray, customizeObject = _b.customizeObject, key = _b.key;
+    return function _joinArrays(a, b, k) {
+        var newKey = key ? "".concat(key, ".").concat(k) : k;
+        if ((0, utils_1.isFunction)(a) && (0, utils_1.isFunction)(b)) {
+            return function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return _joinArrays(a.apply(void 0, __spreadArray([], __read(args), false)), b.apply(void 0, __spreadArray([], __read(args), false)), k);
+            };
+        }
+        if (isArray(a) && isArray(b)) {
+            var customResult = customizeArray && customizeArray(a, b, newKey);
+            return customResult || __spreadArray(__spreadArray([], __read(a), false), __read(b), false);
+        }
+        if ((0, utils_1.isRegex)(b)) {
+            return b;
+        }
+        if ((0, utils_1.isPlainObject)(a) && (0, utils_1.isPlainObject)(b)) {
+            var customResult = customizeObject && customizeObject(a, b, newKey);
+            return (customResult ||
+                (0, merge_with_1.default)([a, b], joinArrays({
+                    customizeArray: customizeArray,
+                    customizeObject: customizeObject,
+                    key: newKey,
+                })));
+        }
+        if ((0, utils_1.isPlainObject)(b)) {
+            return (0, clone_deep_1.default)(b);
+            // The behavior of structuredClone differs from cloneDeep
+            // so it cannot work as a replacement for all cases although
+            // tests pass with it.
+            // return structuredClone(b);
+        }
+        if (isArray(b)) {
+            return __spreadArray([], __read(b), false);
+        }
+        return b;
+    };
+}
+exports.default = joinArrays;
+//# sourceMappingURL=join-arrays.js.map

node_modules/webpack-merge/dist/join-arrays.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-arrays.js","sourceRoot":"","sources":["../src/join-arrays.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0DAAmC;AAEnC,4DAAqC;AACrC,iCAA6D;AAE7D,IAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;AAE9B,SAAwB,UAAU,CAAC,EAQ7B;QAR6B,qBAQ/B,EAAE,KAAA,EAPJ,cAAc,oBAAA,EACd,eAAe,qBAAA,EACf,GAAG,SAAA;IAMH,OAAO,SAAS,WAAW,CAAC,CAAM,EAAE,CAAM,EAAE,CAAM;QAChD,IAAM,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,UAAG,GAAG,cAAI,CAAC,CAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAEvC,IAAI,IAAA,kBAAU,EAAC,CAAC,CAAC,IAAI,IAAA,kBAAU,EAAC,CAAC,CAAC,EAAE;YAClC,OAAO;gBAAC,cAAc;qBAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;oBAAd,yBAAc;;gBAAK,OAAA,WAAW,CAAC,CAAC,wCAAI,IAAI,YAAG,CAAC,wCAAI,IAAI,YAAG,CAAC,CAAC;YAAtC,CAAsC,CAAC;SACnE;QAED,IAAI,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE;YAC5B,IAAM,YAAY,GAAG,cAAc,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;YAEpE,OAAO,YAAY,2CAAQ,CAAC,kBAAK,CAAC,SAAC,CAAC;SACrC;QAED,IAAI,IAAA,eAAO,EAAC,CAAC,CAAC,EAAE;YACd,OAAO,CAAC,CAAC;SACV;QAED,IAAI,IAAA,qBAAa,EAAC,CAAC,CAAC,IAAI,IAAA,qBAAa,EAAC,CAAC,CAAC,EAAE;YACxC,IAAM,YAAY,GAAG,eAAe,IAAI,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;YAEtE,OAAO,CACL,YAAY;gBACZ,IAAA,oBAAS,EACP,CAAC,CAAC,EAAE,CAAC,CAAC,EACN,UAAU,CAAC;oBACT,cAAc,gBAAA;oBACd,eAAe,iBAAA;oBACf,GAAG,EAAE,MAAM;iBACZ,CAAC,CACH,CACF,CAAC;SACH;QAED,IAAI,IAAA,qBAAa,EAAC,CAAC,CAAC,EAAE;YACpB,OAAO,IAAA,oBAAS,EAAC,CAAC,CAAC,CAAC;YAEpB,yDAAyD;YACzD,4DAA4D;YAC5D,sBAAsB;YACtB,6BAA6B;SAC9B;QAED,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE;YACd,gCAAW,CAAC,UAAE;SACf;QAED,OAAO,CAAC,CAAC;IACX,CAAC,CAAC;AACJ,CAAC;AAzDD,6BAyDC"}

node_modules/webpack-merge/dist/merge-with.d.ts

@@ -0,0 +1,2 @@
+declare function mergeWith(objects: object[], customizer: any): object;
+export default mergeWith;

node_modules/webpack-merge/dist/merge-with.js

@@ -0,0 +1,38 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function mergeWith(objects, customizer) {
+    var _a = __read(objects), first = _a[0], rest = _a.slice(1);
+    var ret = first;
+    rest.forEach(function (a) {
+        ret = mergeTo(ret, a, customizer);
+    });
+    return ret;
+}
+function mergeTo(a, b, customizer) {
+    var ret = {};
+    Object.keys(a)
+        .concat(Object.keys(b))
+        .forEach(function (k) {
+        var v = customizer(a[k], b[k], k);
+        ret[k] = typeof v === "undefined" ? a[k] : v;
+    });
+    return ret;
+}
+exports.default = mergeWith;
+//# sourceMappingURL=merge-with.js.map

node_modules/webpack-merge/dist/merge-with.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-with.js","sourceRoot":"","sources":["../src/merge-with.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,SAAS,SAAS,CAAC,OAAiB,EAAE,UAAU;IACxC,IAAA,KAAA,OAAmB,OAAO,CAAA,EAAzB,KAAK,QAAA,EAAK,IAAI,cAAW,CAAC;IACjC,IAAI,GAAG,GAAG,KAAK,CAAC;IAEhB,IAAI,CAAC,OAAO,CAAC,UAAC,CAAC;QACb,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;IAEH,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU;IAC/B,IAAM,GAAG,GAAG,EAAE,CAAC;IAEf,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;SACX,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACtB,OAAO,CAAC,UAAC,CAAC;QACT,IAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAEpC,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;IAEL,OAAO,GAAG,CAAC;AACb,CAAC;AAED,kBAAe,SAAS,CAAC"}

node_modules/webpack-merge/dist/types.d.ts

@@ -0,0 +1,14 @@
+export type Key = string;
+export type Customize = (a: any, b: any, key: Key) => any;
+export interface ICustomizeOptions {
+    customizeArray?: Customize;
+    customizeObject?: Customize;
+}
+export declare enum CustomizeRule {
+    Match = "match",
+    Merge = "merge",
+    Append = "append",
+    Prepend = "prepend",
+    Replace = "replace"
+}
+export type CustomizeRuleString = "match" | "merge" | "append" | "prepend" | "replace";

node_modules/webpack-merge/dist/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomizeRule = void 0;
+var CustomizeRule;
+(function (CustomizeRule) {
+    CustomizeRule["Match"] = "match";
+    CustomizeRule["Merge"] = "merge";
+    CustomizeRule["Append"] = "append";
+    CustomizeRule["Prepend"] = "prepend";
+    CustomizeRule["Replace"] = "replace";
+})(CustomizeRule || (exports.CustomizeRule = CustomizeRule = {}));
+//# sourceMappingURL=types.js.map

node_modules/webpack-merge/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AASA,IAAY,aAMX;AAND,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,gCAAe,CAAA;IACf,kCAAiB,CAAA;IACjB,oCAAmB,CAAA;IACnB,oCAAmB,CAAA;AACrB,CAAC,EANW,aAAa,6BAAb,aAAa,QAMxB"}

node_modules/webpack-merge/dist/unique.d.ts

@@ -0,0 +1,2 @@
+declare function mergeUnique(key: string, uniques: string[], getter: (a: object) => string): (a: [], b: [], k: string) => false | any[];
+export default mergeUnique;

node_modules/webpack-merge/dist/unique.js

@@ -0,0 +1,49 @@
+"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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function mergeUnique(key, uniques, getter) {
+    var uniquesSet = new Set(uniques);
+    return function (a, b, k) {
+        return k === key &&
+            Array.from(__spreadArray(__spreadArray([], __read(a), false), __read(b), false).map(function (it) { return ({ key: getter(it), value: it }); })
+                .map(function (_a) {
+                var key = _a.key, value = _a.value;
+                return ({
+                    key: uniquesSet.has(key) ? key : value,
+                    value: value,
+                });
+            })
+                .reduce(function (m, _a) {
+                var key = _a.key, value = _a.value;
+                m.delete(key); // This is required to preserve backward compatible order of elements after a merge.
+                return m.set(key, value);
+            }, new Map())
+                .values());
+    };
+}
+exports.default = mergeUnique;
+//# sourceMappingURL=unique.js.map

node_modules/webpack-merge/dist/unique.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.js","sourceRoot":"","sources":["../src/unique.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,WAAW,CAClB,GAAW,EACX,OAAiB,EACjB,MAA6B;IAE7B,IAAI,UAAU,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;IAClC,OAAO,UAAC,CAAK,EAAE,CAAK,EAAE,CAAS;QAC7B,OAAA,CAAC,KAAK,GAAG;YACT,KAAK,CAAC,IAAI,CACR,uCAAI,CAAC,kBAAK,CAAC,UACR,GAAG,CAAC,UAAC,EAAU,IAAK,OAAA,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,EAAhC,CAAgC,CAAC;iBACrD,GAAG,CAAC,UAAC,EAAc;oBAAZ,GAAG,SAAA,EAAE,KAAK,WAAA;gBAAO,OAAA,CAAC;oBACxB,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK;oBACtC,KAAK,EAAE,KAAK;iBACb,CAAC;YAHuB,CAGvB,CAAC;iBACF,MAAM,CAAC,UAAC,CAAC,EAAE,EAAc;oBAAZ,GAAG,SAAA,EAAE,KAAK,WAAA;gBACtB,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,oFAAoF;gBACnG,OAAO,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAC3B,CAAC,EAAE,IAAI,GAAG,EAAY,CAAC;iBACtB,MAAM,EAAE,CACZ;IAbD,CAaC,CAAC;AACN,CAAC;AAED,kBAAe,WAAW,CAAC"}

node_modules/webpack-merge/dist/utils.d.ts

@@ -0,0 +1,17 @@
+declare function isRegex(o: any): boolean;
+declare function isFunction(functionToCheck: any): any;
+declare function isPlainObject(a: any): boolean;
+declare function isUndefined(a: any): boolean;
+/**
+ * According to Webpack docs, a "test" should be the following:
+ *
+ * - A string
+ * - A RegExp
+ * - A function
+ * - An array of conditions (may be nested)
+ * - An object of conditions (may be nested)
+ *
+ * https://webpack.js.org/configuration/module/#condition
+ */
+declare function isSameCondition(a: any, b: any): boolean;
+export { isRegex, isFunction, isPlainObject, isUndefined, isSameCondition };

node_modules/webpack-merge/dist/utils.js

@@ -0,0 +1,101 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameCondition = exports.isUndefined = exports.isPlainObject = exports.isFunction = exports.isRegex = void 0;
+var flat_1 = require("flat");
+function isRegex(o) {
+    return o instanceof RegExp;
+}
+exports.isRegex = isRegex;
+// https://stackoverflow.com/a/7356528/228885
+function isFunction(functionToCheck) {
+    return (functionToCheck && {}.toString.call(functionToCheck) === "[object Function]");
+}
+exports.isFunction = isFunction;
+function isPlainObject(a) {
+    if (a === null || Array.isArray(a)) {
+        return false;
+    }
+    return typeof a === "object";
+}
+exports.isPlainObject = isPlainObject;
+function isUndefined(a) {
+    return typeof a === "undefined";
+}
+exports.isUndefined = isUndefined;
+/**
+ * According to Webpack docs, a "test" should be the following:
+ *
+ * - A string
+ * - A RegExp
+ * - A function
+ * - An array of conditions (may be nested)
+ * - An object of conditions (may be nested)
+ *
+ * https://webpack.js.org/configuration/module/#condition
+ */
+function isSameCondition(a, b) {
+    var _a, _b;
+    if (!a || !b) {
+        return a === b;
+    }
+    if (typeof a === "string" ||
+        typeof b === "string" ||
+        isRegex(a) ||
+        isRegex(b) ||
+        isFunction(a) ||
+        isFunction(b)) {
+        return a.toString() === b.toString();
+    }
+    var entriesA = Object.entries((0, flat_1.flatten)(a));
+    var entriesB = Object.entries((0, flat_1.flatten)(b));
+    if (entriesA.length !== entriesB.length) {
+        return false;
+    }
+    for (var i = 0; i < entriesA.length; i++) {
+        entriesA[i][0] = entriesA[i][0].replace(/\b\d+\b/g, "[]");
+        entriesB[i][0] = entriesB[i][0].replace(/\b\d+\b/g, "[]");
+    }
+    function cmp(_a, _b) {
+        var _c = __read(_a, 2), k1 = _c[0], v1 = _c[1];
+        var _d = __read(_b, 2), k2 = _d[0], v2 = _d[1];
+        if (k1 < k2)
+            return -1;
+        if (k1 > k2)
+            return 1;
+        if (v1 < v2)
+            return -1;
+        if (v1 > v2)
+            return 1;
+        return 0;
+    }
+    entriesA.sort(cmp);
+    entriesB.sort(cmp);
+    if (entriesA.length !== entriesB.length) {
+        return false;
+    }
+    for (var i = 0; i < entriesA.length; i++) {
+        if (entriesA[i][0] !== entriesB[i][0] ||
+            ((_a = entriesA[i][1]) === null || _a === void 0 ? void 0 : _a.toString()) !== ((_b = entriesB[i][1]) === null || _b === void 0 ? void 0 : _b.toString())) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isSameCondition = isSameCondition;
+//# sourceMappingURL=utils.js.map

node_modules/webpack-merge/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}