@rsbuild/core 1.6.10 → 1.6.12-canary-63b4dae2-20251204065915

package/compiled/webpack-merge/index.js

@@ -0,0 +1,1200 @@
+(() => {
+  var __webpack_modules__ = {
+    520: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      "use strict";
+      const clone = __nccwpck_require__(377);
+      const typeOf = __nccwpck_require__(778);
+      const isPlainObject = __nccwpck_require__(967);
+      function cloneDeep(val, instanceClone) {
+        switch (typeOf(val)) {
+          case "object":
+            return cloneObjectDeep(val, instanceClone);
+          case "array":
+            return cloneArrayDeep(val, instanceClone);
+          default: {
+            return clone(val);
+          }
+        }
+      }
+      function cloneObjectDeep(val, instanceClone) {
+        if (typeof instanceClone === "function") {
+          return instanceClone(val);
+        }
+        if (instanceClone || isPlainObject(val)) {
+          const res = new val.constructor();
+          for (let key in val) {
+            res[key] = cloneDeep(val[key], instanceClone);
+          }
+          return res;
+        }
+        return val;
+      }
+      function cloneArrayDeep(val, instanceClone) {
+        const res = new val.constructor(val.length);
+        for (let i = 0; i < val.length; i++) {
+          res[i] = cloneDeep(val[i], instanceClone);
+        }
+        return res;
+      }
+      module.exports = cloneDeep;
+    },
+    790: (module) => {
+      module.exports = flatten;
+      flatten.flatten = flatten;
+      flatten.unflatten = unflatten;
+      function isBuffer(obj) {
+        return (
+          obj &&
+          obj.constructor &&
+          typeof obj.constructor.isBuffer === "function" &&
+          obj.constructor.isBuffer(obj)
+        );
+      }
+      function keyIdentity(key) {
+        return key;
+      }
+      function flatten(target, opts) {
+        opts = opts || {};
+        const delimiter = opts.delimiter || ".";
+        const maxDepth = opts.maxDepth;
+        const transformKey = opts.transformKey || keyIdentity;
+        const output = {};
+        function step(object, prev, currentDepth) {
+          currentDepth = currentDepth || 1;
+          Object.keys(object).forEach(function (key) {
+            const value = object[key];
+            const isarray = opts.safe && Array.isArray(value);
+            const type = Object.prototype.toString.call(value);
+            const isbuffer = isBuffer(value);
+            const isobject =
+              type === "[object Object]" || type === "[object Array]";
+            const newKey = prev
+              ? prev + delimiter + transformKey(key)
+              : transformKey(key);
+            if (
+              !isarray &&
+              !isbuffer &&
+              isobject &&
+              Object.keys(value).length &&
+              (!opts.maxDepth || currentDepth < maxDepth)
+            ) {
+              return step(value, newKey, currentDepth + 1);
+            }
+            output[newKey] = value;
+          });
+        }
+        step(target);
+        return output;
+      }
+      function unflatten(target, opts) {
+        opts = opts || {};
+        const delimiter = opts.delimiter || ".";
+        const overwrite = opts.overwrite || false;
+        const transformKey = opts.transformKey || keyIdentity;
+        const result = {};
+        const isbuffer = isBuffer(target);
+        if (
+          isbuffer ||
+          Object.prototype.toString.call(target) !== "[object Object]"
+        ) {
+          return target;
+        }
+        function getkey(key) {
+          const parsedKey = Number(key);
+          return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object
+            ? key
+            : parsedKey;
+        }
+        function addKeys(keyPrefix, recipient, target) {
+          return Object.keys(target).reduce(function (result, key) {
+            result[keyPrefix + delimiter + key] = target[key];
+            return result;
+          }, recipient);
+        }
+        function isEmpty(val) {
+          const type = Object.prototype.toString.call(val);
+          const isArray = type === "[object Array]";
+          const isObject = type === "[object Object]";
+          if (!val) {
+            return true;
+          } else if (isArray) {
+            return !val.length;
+          } else if (isObject) {
+            return !Object.keys(val).length;
+          }
+        }
+        target = Object.keys(target).reduce(function (result, key) {
+          const type = Object.prototype.toString.call(target[key]);
+          const isObject =
+            type === "[object Object]" || type === "[object Array]";
+          if (!isObject || isEmpty(target[key])) {
+            result[key] = target[key];
+            return result;
+          } else {
+            return addKeys(key, result, flatten(target[key], opts));
+          }
+        }, {});
+        Object.keys(target).forEach(function (key) {
+          const split = key.split(delimiter).map(transformKey);
+          let key1 = getkey(split.shift());
+          let key2 = getkey(split[0]);
+          let recipient = result;
+          while (key2 !== undefined) {
+            if (key1 === "__proto__") {
+              return;
+            }
+            const type = Object.prototype.toString.call(recipient[key1]);
+            const isobject =
+              type === "[object Object]" || type === "[object Array]";
+            if (
+              !overwrite &&
+              !isobject &&
+              typeof recipient[key1] !== "undefined"
+            ) {
+              return;
+            }
+            if (
+              (overwrite && !isobject) ||
+              (!overwrite && recipient[key1] == null)
+            ) {
+              recipient[key1] =
+                typeof key2 === "number" && !opts.object ? [] : {};
+            }
+            recipient = recipient[key1];
+            if (split.length > 0) {
+              key1 = getkey(split.shift());
+              key2 = getkey(split[0]);
+            }
+          }
+          recipient[key1] = unflatten(target[key], opts);
+        });
+        return result;
+      }
+    },
+    967: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      "use strict";
+      /*!
+       * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+       *
+       * Copyright (c) 2014-2017, Jon Schlinkert.
+       * Released under the MIT License.
+       */ var isObject = __nccwpck_require__(281);
+      function isObjectObject(o) {
+        return (
+          isObject(o) === true &&
+          Object.prototype.toString.call(o) === "[object Object]"
+        );
+      }
+      module.exports = function isPlainObject(o) {
+        var ctor, prot;
+        if (isObjectObject(o) === false) return false;
+        ctor = o.constructor;
+        if (typeof ctor !== "function") return false;
+        prot = ctor.prototype;
+        if (isObjectObject(prot) === false) return false;
+        if (prot.hasOwnProperty("isPrototypeOf") === false) {
+          return false;
+        }
+        return true;
+      };
+    },
+    281: (module) => {
+      "use strict";
+      /*!
+       * isobject <https://github.com/jonschlinkert/isobject>
+       *
+       * Copyright (c) 2014-2017, Jon Schlinkert.
+       * Released under the MIT License.
+       */ module.exports = function isObject(val) {
+        return (
+          val != null && typeof val === "object" && Array.isArray(val) === false
+        );
+      };
+    },
+    778: (module) => {
+      var toString = Object.prototype.toString;
+      module.exports = function kindOf(val) {
+        if (val === void 0) return "undefined";
+        if (val === null) return "null";
+        var type = typeof val;
+        if (type === "boolean") return "boolean";
+        if (type === "string") return "string";
+        if (type === "number") return "number";
+        if (type === "symbol") return "symbol";
+        if (type === "function") {
+          return isGeneratorFn(val) ? "generatorfunction" : "function";
+        }
+        if (isArray(val)) return "array";
+        if (isBuffer(val)) return "buffer";
+        if (isArguments(val)) return "arguments";
+        if (isDate(val)) return "date";
+        if (isError(val)) return "error";
+        if (isRegexp(val)) return "regexp";
+        switch (ctorName(val)) {
+          case "Symbol":
+            return "symbol";
+          case "Promise":
+            return "promise";
+          case "WeakMap":
+            return "weakmap";
+          case "WeakSet":
+            return "weakset";
+          case "Map":
+            return "map";
+          case "Set":
+            return "set";
+          case "Int8Array":
+            return "int8array";
+          case "Uint8Array":
+            return "uint8array";
+          case "Uint8ClampedArray":
+            return "uint8clampedarray";
+          case "Int16Array":
+            return "int16array";
+          case "Uint16Array":
+            return "uint16array";
+          case "Int32Array":
+            return "int32array";
+          case "Uint32Array":
+            return "uint32array";
+          case "Float32Array":
+            return "float32array";
+          case "Float64Array":
+            return "float64array";
+        }
+        if (isGeneratorObj(val)) {
+          return "generator";
+        }
+        type = toString.call(val);
+        switch (type) {
+          case "[object Object]":
+            return "object";
+          case "[object Map Iterator]":
+            return "mapiterator";
+          case "[object Set Iterator]":
+            return "setiterator";
+          case "[object String Iterator]":
+            return "stringiterator";
+          case "[object Array Iterator]":
+            return "arrayiterator";
+        }
+        return type.slice(8, -1).toLowerCase().replace(/\s/g, "");
+      };
+      function ctorName(val) {
+        return typeof val.constructor === "function"
+          ? val.constructor.name
+          : null;
+      }
+      function isArray(val) {
+        if (Array.isArray) return Array.isArray(val);
+        return val instanceof Array;
+      }
+      function isError(val) {
+        return (
+          val instanceof Error ||
+          (typeof val.message === "string" &&
+            val.constructor &&
+            typeof val.constructor.stackTraceLimit === "number")
+        );
+      }
+      function isDate(val) {
+        if (val instanceof Date) return true;
+        return (
+          typeof val.toDateString === "function" &&
+          typeof val.getDate === "function" &&
+          typeof val.setDate === "function"
+        );
+      }
+      function isRegexp(val) {
+        if (val instanceof RegExp) return true;
+        return (
+          typeof val.flags === "string" &&
+          typeof val.ignoreCase === "boolean" &&
+          typeof val.multiline === "boolean" &&
+          typeof val.global === "boolean"
+        );
+      }
+      function isGeneratorFn(name, val) {
+        return ctorName(name) === "GeneratorFunction";
+      }
+      function isGeneratorObj(val) {
+        return (
+          typeof val.throw === "function" &&
+          typeof val.return === "function" &&
+          typeof val.next === "function"
+        );
+      }
+      function isArguments(val) {
+        try {
+          if (
+            typeof val.length === "number" &&
+            typeof val.callee === "function"
+          ) {
+            return true;
+          }
+        } catch (err) {
+          if (err.message.indexOf("callee") !== -1) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function isBuffer(val) {
+        if (val.constructor && typeof val.constructor.isBuffer === "function") {
+          return val.constructor.isBuffer(val);
+        }
+        return false;
+      }
+    },
+    377: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      "use strict";
+      /*!
+       * shallow-clone <https://github.com/jonschlinkert/shallow-clone>
+       *
+       * Copyright (c) 2015-present, Jon Schlinkert.
+       * Released under the MIT License.
+       */ const valueOf = Symbol.prototype.valueOf;
+      const typeOf = __nccwpck_require__(778);
+      function clone(val, deep) {
+        switch (typeOf(val)) {
+          case "array":
+            return val.slice();
+          case "object":
+            return Object.assign({}, val);
+          case "date":
+            return new val.constructor(Number(val));
+          case "map":
+            return new Map(val);
+          case "set":
+            return new Set(val);
+          case "buffer":
+            return cloneBuffer(val);
+          case "symbol":
+            return cloneSymbol(val);
+          case "arraybuffer":
+            return cloneArrayBuffer(val);
+          case "float32array":
+          case "float64array":
+          case "int16array":
+          case "int32array":
+          case "int8array":
+          case "uint16array":
+          case "uint32array":
+          case "uint8clampedarray":
+          case "uint8array":
+            return cloneTypedArray(val);
+          case "regexp":
+            return cloneRegExp(val);
+          case "error":
+            return Object.create(val);
+          default: {
+            return val;
+          }
+        }
+      }
+      function cloneRegExp(val) {
+        const flags =
+          val.flags !== void 0 ? val.flags : /\w+$/.exec(val) || void 0;
+        const re = new val.constructor(val.source, flags);
+        re.lastIndex = val.lastIndex;
+        return re;
+      }
+      function cloneArrayBuffer(val) {
+        const res = new val.constructor(val.byteLength);
+        new Uint8Array(res).set(new Uint8Array(val));
+        return res;
+      }
+      function cloneTypedArray(val, deep) {
+        return new val.constructor(val.buffer, val.byteOffset, val.length);
+      }
+      function cloneBuffer(val) {
+        const len = val.length;
+        const buf = Buffer.allocUnsafe
+          ? Buffer.allocUnsafe(len)
+          : Buffer.from(len);
+        val.copy(buf);
+        return buf;
+      }
+      function cloneSymbol(val) {
+        return valueOf ? Object(valueOf.call(val)) : {};
+      }
+      module.exports = clone;
+    },
+    153: function (__unused_webpack_module, exports, __nccwpck_require__) {
+      "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 };
+          } 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(__nccwpck_require__(838));
+      var merge_with_1 = __importDefault(__nccwpck_require__(498));
+      var join_arrays_1 = __importDefault(__nccwpck_require__(168));
+      var unique_1 = __importDefault(__nccwpck_require__(62));
+      exports.unique = unique_1.default;
+      var types_1 = __nccwpck_require__(160);
+      Object.defineProperty(exports, "CustomizeRule", {
+        enumerable: true,
+        get: function () {
+          return types_1.CustomizeRule;
+        },
+      });
+      var utils_1 = __nccwpck_require__(452);
+      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");
+          }
+          if (firstConfiguration.then) {
+            throw new TypeError("Promises are not supported");
+          }
+          if (!firstConfiguration) {
+            return {};
+          }
+          if (configurations.length === 0) {
+            if (Array.isArray(firstConfiguration)) {
+              if (firstConfiguration.length === 0) {
+                return {};
+              }
+              if (firstConfiguration.some(utils_1.isUndefined)) {
+                throw new TypeError("Merging undefined is not supported");
+              }
+              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, a, b });
+            }
+            if (typeof currentRule === "string") {
+              return mergeIndividualRule({ currentRule, a, 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");
+                }
+                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];
+                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;
+        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;
+    },
+    168: function (__unused_webpack_module, exports, __nccwpck_require__) {
+      "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 };
+          } 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(__nccwpck_require__(520));
+      var merge_with_1 = __importDefault(__nccwpck_require__(498));
+      var utils_1 = __nccwpck_require__(452);
+      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, customizeObject, key: newKey }),
+              )
+            );
+          }
+          if ((0, utils_1.isPlainObject)(b)) {
+            return (0, clone_deep_1.default)(b);
+          }
+          if (isArray(b)) {
+            return __spreadArray([], __read(b), false);
+          }
+          return b;
+        };
+      }
+      exports["default"] = joinArrays;
+    },
+    498: function (__unused_webpack_module, exports) {
+      "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 };
+          } 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;
+    },
+    160: (__unused_webpack_module, exports) => {
+      "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 = {}));
+    },
+    62: function (__unused_webpack_module, exports) {
+      "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 };
+          } 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 };
+                })
+                .reduce(function (m, _a) {
+                  var key = _a.key,
+                    value = _a.value;
+                  m.delete(key);
+                  return m.set(key, value);
+                }, new Map())
+                .values(),
+            )
+          );
+        };
+      }
+      exports["default"] = mergeUnique;
+    },
+    452: function (__unused_webpack_module, exports, __nccwpck_require__) {
+      "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 };
+          } 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 = __nccwpck_require__(790);
+      function isRegex(o) {
+        return o instanceof RegExp;
+      }
+      exports.isRegex = isRegex;
+      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;
+      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;
+    },
+    838: (module) => {
+      "use strict";
+      var REGEXP_PARTS = /(\*|\?)/g;
+      function WildcardMatcher(text, separator) {
+        this.text = text = text || "";
+        this.hasWild = text.indexOf("*") >= 0;
+        this.separator = separator;
+        this.parts = text.split(separator).map(this.classifyPart.bind(this));
+      }
+      WildcardMatcher.prototype.match = function (input) {
+        var matches = true;
+        var parts = this.parts;
+        var ii;
+        var partsCount = parts.length;
+        var testParts;
+        if (typeof input == "string" || input instanceof String) {
+          if (!this.hasWild && this.text != input) {
+            matches = false;
+          } else {
+            testParts = (input || "").split(this.separator);
+            for (ii = 0; matches && ii < partsCount; ii++) {
+              if (parts[ii] === "*") {
+                continue;
+              } else if (ii < testParts.length) {
+                matches =
+                  parts[ii] instanceof RegExp
+                    ? parts[ii].test(testParts[ii])
+                    : parts[ii] === testParts[ii];
+              } else {
+                matches = false;
+              }
+            }
+            matches = matches && testParts;
+          }
+        } else if (typeof input.splice == "function") {
+          matches = [];
+          for (ii = input.length; ii--; ) {
+            if (this.match(input[ii])) {
+              matches[matches.length] = input[ii];
+            }
+          }
+        } else if (typeof input == "object") {
+          matches = {};
+          for (var key in input) {
+            if (this.match(key)) {
+              matches[key] = input[key];
+            }
+          }
+        }
+        return matches;
+      };
+      WildcardMatcher.prototype.classifyPart = function (part) {
+        if (part === "*") {
+          return part;
+        } else if (part.indexOf("*") >= 0 || part.indexOf("?") >= 0) {
+          return new RegExp(part.replace(REGEXP_PARTS, ".$1"));
+        }
+        return part;
+      };
+      module.exports = function (text, test, separator) {
+        var matcher = new WildcardMatcher(text, separator || /[\/\.]/);
+        if (typeof test != "undefined") {
+          return matcher.match(test);
+        }
+        return matcher;
+      };
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId].call(
+        module.exports,
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    return module.exports;
+  }
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = __nccwpck_require__(153);
+  module.exports = __webpack_exports__;
+})();