n8n-editor-ui/dist/assets/merge-k8vSyyXH.js

Workflow Editor UI for n8n

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-ficiegRb.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 };