@rsbuild/core 1.0.0-alpha.2 → 1.0.0-alpha.3

package/compiled/webpack-merge/index.js

@@ -0,0 +1,1239 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 248:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+/**
+ * Module dependenices
+ */
+
+const clone = __nccwpck_require__(572);
+const typeOf = __nccwpck_require__(279);
+const isPlainObject = __nccwpck_require__(814);
+
+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;
+}
+
+/**
+ * Expose `cloneDeep`
+ */
+
+module.exports = cloneDeep;
+
+
+/***/ }),
+
+/***/ 376:
+/***/ ((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
+  }
+
+  // safely ensure that the key is
+  // an integer.
+  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]'
+      )
+
+      // do not write over falsey, non-undefined values if overwrite is false
+      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])
+      }
+    }
+
+    // unflatten again for 'messy objects'
+    recipient[key1] = unflatten(target[key], opts)
+  })
+
+  return result
+}
+
+
+/***/ }),
+
+/***/ 814:
+/***/ ((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__(949);
+
+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;
+
+  // If has modified constructor
+  ctor = o.constructor;
+  if (typeof ctor !== 'function') return false;
+
+  // If has modified prototype
+  prot = ctor.prototype;
+  if (isObjectObject(prot) === false) return false;
+
+  // If constructor does not have an Object-specific method
+  if (prot.hasOwnProperty('isPrototypeOf') === false) {
+    return false;
+  }
+
+  // Most likely a plain Object
+  return true;
+};
+
+
+/***/ }),
+
+/***/ 949:
+/***/ ((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;
+};
+
+
+/***/ }),
+
+/***/ 279:
+/***/ ((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';
+
+    // Set, Map, WeakSet, WeakMap
+    case 'WeakMap': return 'weakmap';
+    case 'WeakSet': return 'weakset';
+    case 'Map': return 'map';
+    case 'Set': return 'set';
+
+    // 8-bit typed arrays
+    case 'Int8Array': return 'int8array';
+    case 'Uint8Array': return 'uint8array';
+    case 'Uint8ClampedArray': return 'uint8clampedarray';
+
+    // 16-bit typed arrays
+    case 'Int16Array': return 'int16array';
+    case 'Uint16Array': return 'uint16array';
+
+    // 32-bit typed arrays
+    case 'Int32Array': return 'int32array';
+    case 'Uint32Array': return 'uint32array';
+    case 'Float32Array': return 'float32array';
+    case 'Float64Array': return 'float64array';
+  }
+
+  if (isGeneratorObj(val)) {
+    return 'generator';
+  }
+
+  // Non-plain objects
+  type = toString.call(val);
+  switch (type) {
+    case '[object Object]': return 'object';
+    // iterators
+    case '[object Map Iterator]': return 'mapiterator';
+    case '[object Set Iterator]': return 'setiterator';
+    case '[object String Iterator]': return 'stringiterator';
+    case '[object Array Iterator]': return 'arrayiterator';
+  }
+
+  // other
+  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;
+}
+
+/**
+ * If you need to support Safari 5-7 (8-10 yr-old browser),
+ * take a look at https://github.com/feross/is-buffer
+ */
+
+function isBuffer(val) {
+  if (val.constructor && typeof val.constructor.isBuffer === 'function') {
+    return val.constructor.isBuffer(val);
+  }
+  return false;
+}
+
+
+/***/ }),
+
+/***/ 572:
+/***/ ((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__(279);
+
+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)) : {};
+}
+
+/**
+ * Expose `clone`
+ */
+
+module.exports = clone;
+
+
+/***/ }),
+
+/***/ 32:
+/***/ (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: 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) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = 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__(859));
+var merge_with_1 = __importDefault(__nccwpck_require__(344));
+var join_arrays_1 = __importDefault(__nccwpck_require__(709));
+var unique_1 = __importDefault(__nccwpck_require__(237));
+exports.unique = unique_1["default"];
+var types_1 = __nccwpck_require__(495);
+exports.CustomizeRule = types_1.CustomizeRule;
+var utils_1 = __nccwpck_require__(565);
+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)));
+}
+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 (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 merge_with_1["default"](firstConfiguration, join_arrays_1["default"](options));
+            }
+            return firstConfiguration;
+        }
+        return merge_with_1["default"]([firstConfiguration].concat(configurations), 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 wildcard_1["default"](rule, key); }) || "";
+        if (matchedRule) {
+            switch (rules[matchedRule]) {
+                case types_1.CustomizeRule.Prepend:
+                    return __spreadArray(__spreadArray([], __read(b)), __read(a));
+                case types_1.CustomizeRule.Replace:
+                    return b;
+                case types_1.CustomizeRule.Append:
+                default:
+                    return __spreadArray(__spreadArray([], __read(a)), __read(b));
+            }
+        }
+    };
+}
+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 (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 (!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 utils_1.isSameCondition(ao[rule], o[rule]); });
+            if (matches) {
+                bAllMatches.push(o);
+            }
+            return matches;
+        });
+        if (!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 (!utils_1.isPlainObject(v) || !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)), __read(val)) : 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 merge_with_1["default"]([b, a], join_arrays_1["default"]());
+            case types_1.CustomizeRule.Replace:
+                return b;
+            case types_1.CustomizeRule.Append:
+                return merge_with_1["default"]([a, b], join_arrays_1["default"]());
+        }
+    };
+}
+exports.customizeObject = customizeObject;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 709:
+/***/ (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: 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) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var clone_deep_1 = __importDefault(__nccwpck_require__(248));
+var merge_with_1 = __importDefault(__nccwpck_require__(344));
+var utils_1 = __nccwpck_require__(565);
+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 ? key + "." + k : k;
+        if (utils_1.isFunction(a) && 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))), b.apply(void 0, __spreadArray([], __read(args))), k);
+            };
+        }
+        if (isArray(a) && isArray(b)) {
+            var customResult = customizeArray && customizeArray(a, b, newKey);
+            return customResult || __spreadArray(__spreadArray([], __read(a)), __read(b));
+        }
+        if (utils_1.isRegex(b)) {
+            return b;
+        }
+        if (utils_1.isPlainObject(a) && utils_1.isPlainObject(b)) {
+            var customResult = customizeObject && customizeObject(a, b, newKey);
+            return (customResult ||
+                merge_with_1["default"]([a, b], joinArrays({
+                    customizeArray: customizeArray,
+                    customizeObject: customizeObject,
+                    key: newKey
+                })));
+        }
+        if (utils_1.isPlainObject(b)) {
+            return clone_deep_1["default"](b);
+        }
+        if (isArray(b)) {
+            return __spreadArray([], __read(b));
+        }
+        return b;
+    };
+}
+exports["default"] = joinArrays;
+//# sourceMappingURL=join-arrays.js.map
+
+/***/ }),
+
+/***/ 344:
+/***/ (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: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+exports.__esModule = 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
+
+/***/ }),
+
+/***/ 495:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+exports.__esModule = 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 || (exports.CustomizeRule = {}));
+//# sourceMappingURL=types.js.map
+
+/***/ }),
+
+/***/ 237:
+/***/ (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: 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) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+exports.__esModule = 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)), __read(b)).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
+
+/***/ }),
+
+/***/ 565:
+/***/ (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: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+exports.__esModule = true;
+exports.isSameCondition = exports.isUndefined = exports.isPlainObject = exports.isFunction = exports.isRegex = void 0;
+var flat_1 = __nccwpck_require__(376);
+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(flat_1.flatten(a));
+    var entriesB = Object.entries(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
+
+/***/ }),
+
+/***/ 859:
+/***/ ((module) => {
+
+"use strict";
+/* jshint node: true */
+
+
+var REGEXP_PARTS = /(\*|\?)/g;
+
+/**
+  # wildcard
+
+  Very simple wildcard matching, which is designed to provide the same
+  functionality that is found in the
+  [eve](https://github.com/adobe-webplatform/eve) eventing library.
+
+  ## Usage
+
+  It works with strings:
+
+  <<< examples/strings.js
+
+  Arrays:
+
+  <<< examples/arrays.js
+
+  Objects (matching against keys):
+
+  <<< examples/objects.js
+
+  ## Alternative Implementations
+
+  - <https://github.com/isaacs/node-glob>
+
+    Great for full file-based wildcard matching.
+
+  - <https://github.com/sindresorhus/matcher>
+
+     A well cared for and loved JS wildcard matcher.
+**/
+
+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;
+        }
+      }
+
+      // If matches, then return the component parts
+      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) {
+  // in the event that we have been provided a part that is not just a wildcard
+  // then turn this into a regular expression for matching purposes
+  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;
+};
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __nccwpck_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		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 the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat */
+/******/ 	
+/******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __nccwpck_require__(32);
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
+/******/ })()
+;