@atom8n/n8n-editor-ui 2.2.0

package/dist/assets/merge-DhuTk1HM.js

@@ -0,0 +1,564 @@
+import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
+import { a as require__getNative, c as require_isObject, f as require__root, i as require_eq, l as require_isObjectLike, m as require_isArray, n as require__Map, p as require__freeGlobal, r as require__ListCache, s as require_isFunction, t as require__MapCache, u as require__baseGetTag } from "./_MapCache-CcdIl4Ae.js";
+var require__stackClear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ListCache$2 = require__ListCache();
+	function stackClear$1() {
+		this.__data__ = new ListCache$2();
+		this.size = 0;
+	}
+	module.exports = stackClear$1;
+}));
+var require__stackDelete = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function stackDelete$1(key) {
+		var data = this.__data__, result = data["delete"](key);
+		this.size = data.size;
+		return result;
+	}
+	module.exports = stackDelete$1;
+}));
+var require__stackGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function stackGet$1(key) {
+		return this.__data__.get(key);
+	}
+	module.exports = stackGet$1;
+}));
+var require__stackHas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function stackHas$1(key) {
+		return this.__data__.has(key);
+	}
+	module.exports = stackHas$1;
+}));
+var require__stackSet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ListCache$1 = require__ListCache(), Map = require__Map(), MapCache = require__MapCache();
+	var LARGE_ARRAY_SIZE = 200;
+	function stackSet$1(key, value) {
+		var data = this.__data__;
+		if (data instanceof ListCache$1) {
+			var pairs = data.__data__;
+			if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+				pairs.push([key, value]);
+				this.size = ++data.size;
+				return this;
+			}
+			data = this.__data__ = new MapCache(pairs);
+		}
+		data.set(key, value);
+		this.size = data.size;
+		return this;
+	}
+	module.exports = stackSet$1;
+}));
+var require__Stack = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ListCache = require__ListCache(), stackClear = require__stackClear(), stackDelete = require__stackDelete(), stackGet = require__stackGet(), stackHas = require__stackHas(), stackSet = require__stackSet();
+	function Stack$1(entries) {
+		this.size = (this.__data__ = new ListCache(entries)).size;
+	}
+	Stack$1.prototype.clear = stackClear;
+	Stack$1.prototype["delete"] = stackDelete;
+	Stack$1.prototype.get = stackGet;
+	Stack$1.prototype.has = stackHas;
+	Stack$1.prototype.set = stackSet;
+	module.exports = Stack$1;
+}));
+var require__Uint8Array = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require__root().Uint8Array;
+}));
+var require__baseTimes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function baseTimes$1(n, iteratee) {
+		var index = -1, result = Array(n);
+		while (++index < n) result[index] = iteratee(index);
+		return result;
+	}
+	module.exports = baseTimes$1;
+}));
+var require__baseIsArguments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag$2 = require__baseGetTag(), isObjectLike$4 = require_isObjectLike();
+	var argsTag$1 = "[object Arguments]";
+	function baseIsArguments$1(value) {
+		return isObjectLike$4(value) && baseGetTag$2(value) == argsTag$1;
+	}
+	module.exports = baseIsArguments$1;
+}));
+var require_isArguments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseIsArguments = require__baseIsArguments(), isObjectLike$3 = require_isObjectLike();
+	var objectProto$2 = Object.prototype;
+	var hasOwnProperty$4 = objectProto$2.hasOwnProperty;
+	var propertyIsEnumerable = objectProto$2.propertyIsEnumerable;
+	module.exports = baseIsArguments(function() {
+		return arguments;
+	}()) ? baseIsArguments : function(value) {
+		return isObjectLike$3(value) && hasOwnProperty$4.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+	};
+}));
+var require_stubFalse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function stubFalse$1() {
+		return false;
+	}
+	module.exports = stubFalse$1;
+}));
+var require_isBuffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var root$1 = require__root(), stubFalse = require_stubFalse();
+	var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+	var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module;
+	var Buffer$1 = freeModule$2 && freeModule$2.exports === freeExports$2 ? root$1.Buffer : void 0;
+	module.exports = (Buffer$1 ? Buffer$1.isBuffer : void 0) || stubFalse;
+}));
+var require__isIndex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var MAX_SAFE_INTEGER$1 = 9007199254740991;
+	var reIsUint = /^(?:0|[1-9]\d*)$/;
+	function isIndex$2(value, length) {
+		var type = typeof value;
+		length = length == null ? MAX_SAFE_INTEGER$1 : length;
+		return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+	}
+	module.exports = isIndex$2;
+}));
+var require_isLength = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var MAX_SAFE_INTEGER = 9007199254740991;
+	function isLength$2(value) {
+		return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+	module.exports = isLength$2;
+}));
+var require__baseIsTypedArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag$1 = require__baseGetTag(), isLength$1 = require_isLength(), isObjectLike$2 = require_isObjectLike();
+	var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag$1 = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", weakMapTag = "[object WeakMap]";
+	var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+	var typedArrayTags = {};
+	typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+	typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag$1] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+	function baseIsTypedArray$1(value) {
+		return isObjectLike$2(value) && isLength$1(value.length) && !!typedArrayTags[baseGetTag$1(value)];
+	}
+	module.exports = baseIsTypedArray$1;
+}));
+var require__baseUnary = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function baseUnary$1(func) {
+		return function(value) {
+			return func(value);
+		};
+	}
+	module.exports = baseUnary$1;
+}));
+var require__nodeUtil = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var freeGlobal = require__freeGlobal();
+	var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+	var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+	var freeProcess = freeModule$1 && freeModule$1.exports === freeExports$1 && freeGlobal.process;
+	module.exports = function() {
+		try {
+			var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
+			if (types) return types;
+			return freeProcess && freeProcess.binding && freeProcess.binding("util");
+		} catch (e) {}
+	}();
+}));
+var require_isTypedArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseIsTypedArray = require__baseIsTypedArray(), baseUnary = require__baseUnary(), nodeUtil = require__nodeUtil();
+	var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+	module.exports = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+}));
+var require__arrayLikeKeys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseTimes = require__baseTimes(), isArguments$1 = require_isArguments(), isArray$1 = require_isArray(), isBuffer$1 = require_isBuffer(), isIndex$1 = require__isIndex(), isTypedArray$1 = require_isTypedArray();
+	var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+	function arrayLikeKeys$1(value, inherited) {
+		var isArr = isArray$1(value), isArg = !isArr && isArguments$1(value), isBuff = !isArr && !isArg && isBuffer$1(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+		for (var key in value) if ((inherited || hasOwnProperty$3.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex$1(key, length)))) result.push(key);
+		return result;
+	}
+	module.exports = arrayLikeKeys$1;
+}));
+var require__isPrototype = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var objectProto$1 = Object.prototype;
+	function isPrototype$2(value) {
+		var Ctor = value && value.constructor;
+		return value === (typeof Ctor == "function" && Ctor.prototype || objectProto$1);
+	}
+	module.exports = isPrototype$2;
+}));
+var require__overArg = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function overArg(func, transform) {
+		return function(arg) {
+			return func(transform(arg));
+		};
+	}
+	module.exports = overArg;
+}));
+var require_isArrayLike = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isFunction$1 = require_isFunction(), isLength = require_isLength();
+	function isArrayLike$3(value) {
+		return value != null && isLength(value.length) && !isFunction$1(value);
+	}
+	module.exports = isArrayLike$3;
+}));
+var require__defineProperty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getNative = require__getNative();
+	module.exports = function() {
+		try {
+			var func = getNative(Object, "defineProperty");
+			func({}, "", {});
+			return func;
+		} catch (e) {}
+	}();
+}));
+var require__baseAssignValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var defineProperty$1 = require__defineProperty();
+	function baseAssignValue$3(object, key, value) {
+		if (key == "__proto__" && defineProperty$1) defineProperty$1(object, key, {
+			"configurable": true,
+			"enumerable": true,
+			"value": value,
+			"writable": true
+		});
+		else object[key] = value;
+	}
+	module.exports = baseAssignValue$3;
+}));
+var require__assignMergeValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseAssignValue$2 = require__baseAssignValue(), eq$2 = require_eq();
+	function assignMergeValue$2(object, key, value) {
+		if (value !== void 0 && !eq$2(object[key], value) || value === void 0 && !(key in object)) baseAssignValue$2(object, key, value);
+	}
+	module.exports = assignMergeValue$2;
+}));
+var require__createBaseFor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function createBaseFor(fromRight) {
+		return function(object, iteratee, keysFunc) {
+			var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+			while (length--) {
+				var key = props[fromRight ? length : ++index];
+				if (iteratee(iterable[key], key, iterable) === false) break;
+			}
+			return object;
+		};
+	}
+	module.exports = createBaseFor;
+}));
+var require__baseFor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require__createBaseFor()();
+}));
+var require__cloneBuffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var root = require__root();
+	var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+	var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+	var Buffer = freeModule && freeModule.exports === freeExports ? root.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+	function cloneBuffer$1(buffer, isDeep) {
+		if (isDeep) return buffer.slice();
+		var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+		buffer.copy(result);
+		return result;
+	}
+	module.exports = cloneBuffer$1;
+}));
+var require__cloneArrayBuffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Uint8Array = require__Uint8Array();
+	function cloneArrayBuffer$1(arrayBuffer) {
+		var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+		new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+		return result;
+	}
+	module.exports = cloneArrayBuffer$1;
+}));
+var require__cloneTypedArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var cloneArrayBuffer = require__cloneArrayBuffer();
+	function cloneTypedArray$1(typedArray, isDeep) {
+		var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+		return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+	}
+	module.exports = cloneTypedArray$1;
+}));
+var require__copyArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function copyArray$1(source, array) {
+		var index = -1, length = source.length;
+		array || (array = Array(length));
+		while (++index < length) array[index] = source[index];
+		return array;
+	}
+	module.exports = copyArray$1;
+}));
+var require__baseCreate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isObject$4 = require_isObject();
+	var objectCreate = Object.create;
+	module.exports = function() {
+		function object() {}
+		return function(proto) {
+			if (!isObject$4(proto)) return {};
+			if (objectCreate) return objectCreate(proto);
+			object.prototype = proto;
+			var result = new object();
+			object.prototype = void 0;
+			return result;
+		};
+	}();
+}));
+var require__getPrototype = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require__overArg()(Object.getPrototypeOf, Object);
+}));
+var require__initCloneObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseCreate = require__baseCreate(), getPrototype$1 = require__getPrototype(), isPrototype$1 = require__isPrototype();
+	function initCloneObject$1(object) {
+		return typeof object.constructor == "function" && !isPrototype$1(object) ? baseCreate(getPrototype$1(object)) : {};
+	}
+	module.exports = initCloneObject$1;
+}));
+var require_isArrayLikeObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArrayLike$2 = require_isArrayLike(), isObjectLike$1 = require_isObjectLike();
+	function isArrayLikeObject$1(value) {
+		return isObjectLike$1(value) && isArrayLike$2(value);
+	}
+	module.exports = isArrayLikeObject$1;
+}));
+var require_isPlainObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag = require__baseGetTag(), getPrototype = require__getPrototype(), isObjectLike = require_isObjectLike();
+	var objectTag = "[object Object]";
+	var funcProto = Function.prototype, objectProto = Object.prototype;
+	var funcToString = funcProto.toString;
+	var hasOwnProperty$2 = objectProto.hasOwnProperty;
+	var objectCtorString = funcToString.call(Object);
+	function isPlainObject$1(value) {
+		if (!isObjectLike(value) || baseGetTag(value) != objectTag) return false;
+		var proto = getPrototype(value);
+		if (proto === null) return true;
+		var Ctor = hasOwnProperty$2.call(proto, "constructor") && proto.constructor;
+		return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+	}
+	module.exports = isPlainObject$1;
+}));
+var require__safeGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function safeGet$2(object, key) {
+		if (key === "constructor" && typeof object[key] === "function") return;
+		if (key == "__proto__") return;
+		return object[key];
+	}
+	module.exports = safeGet$2;
+}));
+var require__assignValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseAssignValue$1 = require__baseAssignValue(), eq$1 = require_eq();
+	var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+	function assignValue$1(object, key, value) {
+		var objValue = object[key];
+		if (!(hasOwnProperty$1.call(object, key) && eq$1(objValue, value)) || value === void 0 && !(key in object)) baseAssignValue$1(object, key, value);
+	}
+	module.exports = assignValue$1;
+}));
+var require__copyObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assignValue = require__assignValue(), baseAssignValue = require__baseAssignValue();
+	function copyObject$1(source, props, object, customizer) {
+		var isNew = !object;
+		object || (object = {});
+		var index = -1, length = props.length;
+		while (++index < length) {
+			var key = props[index];
+			var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
+			if (newValue === void 0) newValue = source[key];
+			if (isNew) baseAssignValue(object, key, newValue);
+			else assignValue(object, key, newValue);
+		}
+		return object;
+	}
+	module.exports = copyObject$1;
+}));
+var require__nativeKeysIn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function nativeKeysIn$1(object) {
+		var result = [];
+		if (object != null) for (var key in Object(object)) result.push(key);
+		return result;
+	}
+	module.exports = nativeKeysIn$1;
+}));
+var require__baseKeysIn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isObject$3 = require_isObject(), isPrototype = require__isPrototype(), nativeKeysIn = require__nativeKeysIn();
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	function baseKeysIn$1(object) {
+		if (!isObject$3(object)) return nativeKeysIn(object);
+		var isProto = isPrototype(object), result = [];
+		for (var key in object) if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) result.push(key);
+		return result;
+	}
+	module.exports = baseKeysIn$1;
+}));
+var require_keysIn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var arrayLikeKeys = require__arrayLikeKeys(), baseKeysIn = require__baseKeysIn(), isArrayLike$1 = require_isArrayLike();
+	function keysIn$2(object) {
+		return isArrayLike$1(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+	}
+	module.exports = keysIn$2;
+}));
+var require_toPlainObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var copyObject = require__copyObject(), keysIn$1 = require_keysIn();
+	function toPlainObject$1(value) {
+		return copyObject(value, keysIn$1(value));
+	}
+	module.exports = toPlainObject$1;
+}));
+var require__baseMergeDeep = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assignMergeValue$1 = require__assignMergeValue(), cloneBuffer = require__cloneBuffer(), cloneTypedArray = require__cloneTypedArray(), copyArray = require__copyArray(), initCloneObject = require__initCloneObject(), isArguments = require_isArguments(), isArray = require_isArray(), isArrayLikeObject = require_isArrayLikeObject(), isBuffer = require_isBuffer(), isFunction = require_isFunction(), isObject$2 = require_isObject(), isPlainObject = require_isPlainObject(), isTypedArray = require_isTypedArray(), safeGet$1 = require__safeGet(), toPlainObject = require_toPlainObject();
+	function baseMergeDeep$1(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+		var objValue = safeGet$1(object, key), srcValue = safeGet$1(source, key), stacked = stack.get(srcValue);
+		if (stacked) {
+			assignMergeValue$1(object, key, stacked);
+			return;
+		}
+		var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
+		var isCommon = newValue === void 0;
+		if (isCommon) {
+			var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+			newValue = srcValue;
+			if (isArr || isBuff || isTyped) if (isArray(objValue)) newValue = objValue;
+			else if (isArrayLikeObject(objValue)) newValue = copyArray(objValue);
+			else if (isBuff) {
+				isCommon = false;
+				newValue = cloneBuffer(srcValue, true);
+			} else if (isTyped) {
+				isCommon = false;
+				newValue = cloneTypedArray(srcValue, true);
+			} else newValue = [];
+			else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+				newValue = objValue;
+				if (isArguments(objValue)) newValue = toPlainObject(objValue);
+				else if (!isObject$2(objValue) || isFunction(objValue)) newValue = initCloneObject(srcValue);
+			} else isCommon = false;
+		}
+		if (isCommon) {
+			stack.set(srcValue, newValue);
+			mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+			stack["delete"](srcValue);
+		}
+		assignMergeValue$1(object, key, newValue);
+	}
+	module.exports = baseMergeDeep$1;
+}));
+var require__baseMerge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stack = require__Stack(), assignMergeValue = require__assignMergeValue(), baseFor = require__baseFor(), baseMergeDeep = require__baseMergeDeep(), isObject$1 = require_isObject(), keysIn = require_keysIn(), safeGet = require__safeGet();
+	function baseMerge$1(object, source, srcIndex, customizer, stack) {
+		if (object === source) return;
+		baseFor(source, function(srcValue, key) {
+			stack || (stack = new Stack());
+			if (isObject$1(srcValue)) baseMergeDeep(object, source, key, srcIndex, baseMerge$1, customizer, stack);
+			else {
+				var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
+				if (newValue === void 0) newValue = srcValue;
+				assignMergeValue(object, key, newValue);
+			}
+		}, keysIn);
+	}
+	module.exports = baseMerge$1;
+}));
+var require_identity = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function identity$2(value) {
+		return value;
+	}
+	module.exports = identity$2;
+}));
+var require__apply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function apply$1(func, thisArg, args) {
+		switch (args.length) {
+			case 0: return func.call(thisArg);
+			case 1: return func.call(thisArg, args[0]);
+			case 2: return func.call(thisArg, args[0], args[1]);
+			case 3: return func.call(thisArg, args[0], args[1], args[2]);
+		}
+		return func.apply(thisArg, args);
+	}
+	module.exports = apply$1;
+}));
+var require__overRest = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var apply = require__apply();
+	var nativeMax = Math.max;
+	function overRest$1(func, start, transform) {
+		start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+		return function() {
+			var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+			while (++index < length) array[index] = args[start + index];
+			index = -1;
+			var otherArgs = Array(start + 1);
+			while (++index < start) otherArgs[index] = args[index];
+			otherArgs[start] = transform(array);
+			return apply(func, this, otherArgs);
+		};
+	}
+	module.exports = overRest$1;
+}));
+var require_constant = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function constant$1(value) {
+		return function() {
+			return value;
+		};
+	}
+	module.exports = constant$1;
+}));
+var require__baseSetToString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constant = require_constant(), defineProperty = require__defineProperty(), identity$1 = require_identity();
+	module.exports = !defineProperty ? identity$1 : function(func, string) {
+		return defineProperty(func, "toString", {
+			"configurable": true,
+			"enumerable": false,
+			"value": constant(string),
+			"writable": true
+		});
+	};
+}));
+var require__shortOut = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var HOT_COUNT = 800, HOT_SPAN = 16;
+	var nativeNow = Date.now;
+	function shortOut(func) {
+		var count = 0, lastCalled = 0;
+		return function() {
+			var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+			lastCalled = stamp;
+			if (remaining > 0) {
+				if (++count >= HOT_COUNT) return arguments[0];
+			} else count = 0;
+			return func.apply(void 0, arguments);
+		};
+	}
+	module.exports = shortOut;
+}));
+var require__setToString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseSetToString = require__baseSetToString();
+	module.exports = require__shortOut()(baseSetToString);
+}));
+var require__baseRest = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var identity = require_identity(), overRest = require__overRest(), setToString = require__setToString();
+	function baseRest$1(func, start) {
+		return setToString(overRest(func, start, identity), func + "");
+	}
+	module.exports = baseRest$1;
+}));
+var require__isIterateeCall = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var eq = require_eq(), isArrayLike = require_isArrayLike(), isIndex = require__isIndex(), isObject = require_isObject();
+	function isIterateeCall$1(value, index, object) {
+		if (!isObject(object)) return false;
+		var type = typeof index;
+		if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) return eq(object[index], value);
+		return false;
+	}
+	module.exports = isIterateeCall$1;
+}));
+var require__createAssigner = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseRest = require__baseRest(), isIterateeCall = require__isIterateeCall();
+	function createAssigner(assigner) {
+		return baseRest(function(object, sources) {
+			var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
+			customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
+			if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+				customizer = length < 3 ? void 0 : customizer;
+				length = 1;
+			}
+			object = Object(object);
+			while (++index < length) {
+				var source = sources[index];
+				if (source) assigner(object, source, index, customizer);
+			}
+			return object;
+		});
+	}
+	module.exports = createAssigner;
+}));
+var require_merge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseMerge = require__baseMerge();
+	module.exports = require__createAssigner()(function(object, source, srcIndex) {
+		baseMerge(object, source, srcIndex);
+	});
+}));
+export { require__Uint8Array as A, require_isTypedArray as C, require__isIndex as D, require_isLength as E, require_isBuffer as O, require__arrayLikeKeys as S, require__baseUnary as T, require__baseFor as _, require__overRest as a, require__overArg as b, require__copyObject as c, require__initCloneObject as d, require__getPrototype as f, require__cloneBuffer as g, require__cloneArrayBuffer as h, require__setToString as i, require__Stack as j, require_isArguments as k, require__assignValue as l, require__cloneTypedArray as m, require__isIterateeCall as n, require_identity as o, require__copyArray as p, require__baseRest as r, require_keysIn as s, require_merge as t, require_isArrayLikeObject as u, require__baseAssignValue as v, require__nodeUtil as w, require__isPrototype as x, require_isArrayLike as y };