@hybridly/vite 0.9.0 → 0.10.0-beta.10

package/dist/_chunks/libs/deepmerge.mjs

@@ -0,0 +1,81 @@
+import { t as __commonJSMin } from "../rolldown-runtime.mjs";
+var require_cjs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isMergeableObject = function isMergeableObject(value) {
+		return isNonNullObject(value) && !isSpecial(value);
+	};
+	function isNonNullObject(value) {
+		return !!value && typeof value === "object";
+	}
+	function isSpecial(value) {
+		var stringValue = Object.prototype.toString.call(value);
+		return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+	}
+	var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for ? Symbol.for("react.element") : 60103;
+	function isReactElement(value) {
+		return value.$$typeof === REACT_ELEMENT_TYPE;
+	}
+	function emptyTarget(val) {
+		return Array.isArray(val) ? [] : {};
+	}
+	function cloneUnlessOtherwiseSpecified(value, options) {
+		return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
+	}
+	function defaultArrayMerge(target, source, options) {
+		return target.concat(source).map(function(element) {
+			return cloneUnlessOtherwiseSpecified(element, options);
+		});
+	}
+	function getMergeFunction(key, options) {
+		if (!options.customMerge) return deepmerge;
+		var customMerge = options.customMerge(key);
+		return typeof customMerge === "function" ? customMerge : deepmerge;
+	}
+	function getEnumerableOwnPropertySymbols(target) {
+		return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+			return Object.propertyIsEnumerable.call(target, symbol);
+		}) : [];
+	}
+	function getKeys(target) {
+		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+	}
+	function propertyIsOnObject(object, property) {
+		try {
+			return property in object;
+		} catch (_) {
+			return false;
+		}
+	}
+	function propertyIsUnsafe(target, key) {
+		return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+	}
+	function mergeObject(target, source, options) {
+		var destination = {};
+		if (options.isMergeableObject(target)) getKeys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+		});
+		getKeys(source).forEach(function(key) {
+			if (propertyIsUnsafe(target, key)) return;
+			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			else destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+		});
+		return destination;
+	}
+	function deepmerge(target, source, options) {
+		options = options || {};
+		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+		var sourceIsArray = Array.isArray(source);
+		if (!(sourceIsArray === Array.isArray(target))) return cloneUnlessOtherwiseSpecified(source, options);
+		else if (sourceIsArray) return options.arrayMerge(target, source, options);
+		else return mergeObject(target, source, options);
+	}
+	deepmerge.all = function deepmergeAll(array, options) {
+		if (!Array.isArray(array)) throw new Error("first argument should be an array");
+		return array.reduce(function(prev, next) {
+			return deepmerge(prev, next, options);
+		}, {});
+	};
+	module.exports = deepmerge;
+}));
+export { require_cjs as t };

package/dist/_chunks/libs/is-plain-object.mjs

@@ -0,0 +1,20 @@
+/*!
+* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+*
+* Copyright (c) 2014-2017, Jon Schlinkert.
+* Released under the MIT License.
+*/
+function isObject(o) {
+	return Object.prototype.toString.call(o) === "[object Object]";
+}
+function isPlainObject(o) {
+	var ctor, prot;
+	if (isObject(o) === false) return false;
+	ctor = o.constructor;
+	if (ctor === void 0) return true;
+	prot = ctor.prototype;
+	if (isObject(prot) === false) return false;
+	if (prot.hasOwnProperty("isPrototypeOf") === false) return false;
+	return true;
+}
+export { isPlainObject as t };

package/dist/_chunks/libs/lodash.clonedeep.mjs

@@ -0,0 +1,484 @@
+import { t as __commonJSMin } from "../rolldown-runtime.mjs";
+var require_lodash_clonedeep = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var LARGE_ARRAY_SIZE = 200;
+	var HASH_UNDEFINED = "__lodash_hash_undefined__";
+	var MAX_SAFE_INTEGER = 9007199254740991;
+	var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", promiseTag = "[object Promise]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", 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 reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+	var reFlags = /\w*$/;
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+	var reIsUint = /^(?:0|[1-9]\d*)$/;
+	var cloneableTags = {};
+	cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+	cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
+	var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	var root = freeGlobal || freeSelf || Function("return this")();
+	var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+	var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+	var moduleExports = freeModule && freeModule.exports === freeExports;
+	function addMapEntry(map, pair) {
+		map.set(pair[0], pair[1]);
+		return map;
+	}
+	function addSetEntry(set, value) {
+		set.add(value);
+		return set;
+	}
+	function arrayEach(array, iteratee) {
+		var index = -1, length = array ? array.length : 0;
+		while (++index < length) if (iteratee(array[index], index, array) === false) break;
+		return array;
+	}
+	function arrayPush(array, values) {
+		var index = -1, length = values.length, offset = array.length;
+		while (++index < length) array[offset + index] = values[index];
+		return array;
+	}
+	function arrayReduce(array, iteratee, accumulator, initAccum) {
+		var index = -1, length = array ? array.length : 0;
+		if (initAccum && length) accumulator = array[++index];
+		while (++index < length) accumulator = iteratee(accumulator, array[index], index, array);
+		return accumulator;
+	}
+	function baseTimes(n, iteratee) {
+		var index = -1, result = Array(n);
+		while (++index < n) result[index] = iteratee(index);
+		return result;
+	}
+	function getValue(object, key) {
+		return object == null ? void 0 : object[key];
+	}
+	function isHostObject(value) {
+		var result = false;
+		if (value != null && typeof value.toString != "function") try {
+			result = !!(value + "");
+		} catch (e) {}
+		return result;
+	}
+	function mapToArray(map) {
+		var index = -1, result = Array(map.size);
+		map.forEach(function(value, key) {
+			result[++index] = [key, value];
+		});
+		return result;
+	}
+	function overArg(func, transform) {
+		return function(arg) {
+			return func(transform(arg));
+		};
+	}
+	function setToArray(set) {
+		var index = -1, result = Array(set.size);
+		set.forEach(function(value) {
+			result[++index] = value;
+		});
+		return result;
+	}
+	var arrayProto = Array.prototype, funcProto = Function.prototype, objectProto = Object.prototype;
+	var coreJsData = root["__core-js_shared__"];
+	var maskSrcKey = function() {
+		var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+		return uid ? "Symbol(src)_1." + uid : "";
+	}();
+	var funcToString = funcProto.toString;
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	var objectToString = objectProto.toString;
+	var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+	var Buffer = moduleExports ? root.Buffer : void 0, Symbol = root.Symbol, Uint8Array = root.Uint8Array, getPrototype = overArg(Object.getPrototypeOf, Object), objectCreate = Object.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice;
+	var nativeGetSymbols = Object.getOwnPropertySymbols, nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0, nativeKeys = overArg(Object.keys, Object);
+	var DataView = getNative(root, "DataView"), Map = getNative(root, "Map"), Promise = getNative(root, "Promise"), Set = getNative(root, "Set"), WeakMap = getNative(root, "WeakMap"), nativeCreate = getNative(Object, "create");
+	var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map), promiseCtorString = toSource(Promise), setCtorString = toSource(Set), weakMapCtorString = toSource(WeakMap);
+	var symbolProto = Symbol ? Symbol.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+	function Hash(entries) {
+		var index = -1, length = entries ? entries.length : 0;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	function hashClear() {
+		this.__data__ = nativeCreate ? nativeCreate(null) : {};
+	}
+	function hashDelete(key) {
+		return this.has(key) && delete this.__data__[key];
+	}
+	function hashGet(key) {
+		var data = this.__data__;
+		if (nativeCreate) {
+			var result = data[key];
+			return result === HASH_UNDEFINED ? void 0 : result;
+		}
+		return hasOwnProperty.call(data, key) ? data[key] : void 0;
+	}
+	function hashHas(key) {
+		var data = this.__data__;
+		return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+	}
+	function hashSet(key, value) {
+		var data = this.__data__;
+		data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+		return this;
+	}
+	Hash.prototype.clear = hashClear;
+	Hash.prototype["delete"] = hashDelete;
+	Hash.prototype.get = hashGet;
+	Hash.prototype.has = hashHas;
+	Hash.prototype.set = hashSet;
+	function ListCache(entries) {
+		var index = -1, length = entries ? entries.length : 0;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	function listCacheClear() {
+		this.__data__ = [];
+	}
+	function listCacheDelete(key) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) return false;
+		if (index == data.length - 1) data.pop();
+		else splice.call(data, index, 1);
+		return true;
+	}
+	function listCacheGet(key) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		return index < 0 ? void 0 : data[index][1];
+	}
+	function listCacheHas(key) {
+		return assocIndexOf(this.__data__, key) > -1;
+	}
+	function listCacheSet(key, value) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) data.push([key, value]);
+		else data[index][1] = value;
+		return this;
+	}
+	ListCache.prototype.clear = listCacheClear;
+	ListCache.prototype["delete"] = listCacheDelete;
+	ListCache.prototype.get = listCacheGet;
+	ListCache.prototype.has = listCacheHas;
+	ListCache.prototype.set = listCacheSet;
+	function MapCache(entries) {
+		var index = -1, length = entries ? entries.length : 0;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	function mapCacheClear() {
+		this.__data__ = {
+			"hash": new Hash(),
+			"map": new (Map || ListCache)(),
+			"string": new Hash()
+		};
+	}
+	function mapCacheDelete(key) {
+		return getMapData(this, key)["delete"](key);
+	}
+	function mapCacheGet(key) {
+		return getMapData(this, key).get(key);
+	}
+	function mapCacheHas(key) {
+		return getMapData(this, key).has(key);
+	}
+	function mapCacheSet(key, value) {
+		getMapData(this, key).set(key, value);
+		return this;
+	}
+	MapCache.prototype.clear = mapCacheClear;
+	MapCache.prototype["delete"] = mapCacheDelete;
+	MapCache.prototype.get = mapCacheGet;
+	MapCache.prototype.has = mapCacheHas;
+	MapCache.prototype.set = mapCacheSet;
+	function Stack(entries) {
+		this.__data__ = new ListCache(entries);
+	}
+	function stackClear() {
+		this.__data__ = new ListCache();
+	}
+	function stackDelete(key) {
+		return this.__data__["delete"](key);
+	}
+	function stackGet(key) {
+		return this.__data__.get(key);
+	}
+	function stackHas(key) {
+		return this.__data__.has(key);
+	}
+	function stackSet(key, value) {
+		var cache = this.__data__;
+		if (cache instanceof ListCache) {
+			var pairs = cache.__data__;
+			if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+				pairs.push([key, value]);
+				return this;
+			}
+			cache = this.__data__ = new MapCache(pairs);
+		}
+		cache.set(key, value);
+		return this;
+	}
+	Stack.prototype.clear = stackClear;
+	Stack.prototype["delete"] = stackDelete;
+	Stack.prototype.get = stackGet;
+	Stack.prototype.has = stackHas;
+	Stack.prototype.set = stackSet;
+	function arrayLikeKeys(value, inherited) {
+		var result = isArray(value) || isArguments(value) ? baseTimes(value.length, String) : [];
+		var length = result.length, skipIndexes = !!length;
+		for (var key in value) if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isIndex(key, length)))) result.push(key);
+		return result;
+	}
+	function assignValue(object, key, value) {
+		var objValue = object[key];
+		if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) object[key] = value;
+	}
+	function assocIndexOf(array, key) {
+		var length = array.length;
+		while (length--) if (eq(array[length][0], key)) return length;
+		return -1;
+	}
+	function baseAssign(object, source) {
+		return object && copyObject(source, keys(source), object);
+	}
+	function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
+		var result;
+		if (customizer) result = object ? customizer(value, key, object, stack) : customizer(value);
+		if (result !== void 0) return result;
+		if (!isObject(value)) return value;
+		var isArr = isArray(value);
+		if (isArr) {
+			result = initCloneArray(value);
+			if (!isDeep) return copyArray(value, result);
+		} else {
+			var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
+			if (isBuffer(value)) return cloneBuffer(value, isDeep);
+			if (tag == objectTag || tag == argsTag || isFunc && !object) {
+				if (isHostObject(value)) return object ? value : {};
+				result = initCloneObject(isFunc ? {} : value);
+				if (!isDeep) return copySymbols(value, baseAssign(result, value));
+			} else {
+				if (!cloneableTags[tag]) return object ? value : {};
+				result = initCloneByTag(value, tag, baseClone, isDeep);
+			}
+		}
+		stack || (stack = new Stack());
+		var stacked = stack.get(value);
+		if (stacked) return stacked;
+		stack.set(value, result);
+		if (!isArr) var props = isFull ? getAllKeys(value) : keys(value);
+		arrayEach(props || value, function(subValue, key) {
+			if (props) {
+				key = subValue;
+				subValue = value[key];
+			}
+			assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
+		});
+		return result;
+	}
+	function baseCreate(proto) {
+		return isObject(proto) ? objectCreate(proto) : {};
+	}
+	function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+		var result = keysFunc(object);
+		return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+	}
+	function baseGetTag(value) {
+		return objectToString.call(value);
+	}
+	function baseIsNative(value) {
+		if (!isObject(value) || isMasked(value)) return false;
+		return (isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor).test(toSource(value));
+	}
+	function baseKeys(object) {
+		if (!isPrototype(object)) return nativeKeys(object);
+		var result = [];
+		for (var key in Object(object)) if (hasOwnProperty.call(object, key) && key != "constructor") result.push(key);
+		return result;
+	}
+	function cloneBuffer(buffer, isDeep) {
+		if (isDeep) return buffer.slice();
+		var result = new buffer.constructor(buffer.length);
+		buffer.copy(result);
+		return result;
+	}
+	function cloneArrayBuffer(arrayBuffer) {
+		var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+		new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+		return result;
+	}
+	function cloneDataView(dataView, isDeep) {
+		var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+		return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+	}
+	function cloneMap(map, isDeep, cloneFunc) {
+		return arrayReduce(isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map), addMapEntry, new map.constructor());
+	}
+	function cloneRegExp(regexp) {
+		var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+		result.lastIndex = regexp.lastIndex;
+		return result;
+	}
+	function cloneSet(set, isDeep, cloneFunc) {
+		return arrayReduce(isDeep ? cloneFunc(setToArray(set), true) : setToArray(set), addSetEntry, new set.constructor());
+	}
+	function cloneSymbol(symbol) {
+		return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+	}
+	function cloneTypedArray(typedArray, isDeep) {
+		var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+		return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+	}
+	function copyArray(source, array) {
+		var index = -1, length = source.length;
+		array || (array = Array(length));
+		while (++index < length) array[index] = source[index];
+		return array;
+	}
+	function copyObject(source, props, object, customizer) {
+		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;
+			assignValue(object, key, newValue === void 0 ? source[key] : newValue);
+		}
+		return object;
+	}
+	function copySymbols(source, object) {
+		return copyObject(source, getSymbols(source), object);
+	}
+	function getAllKeys(object) {
+		return baseGetAllKeys(object, keys, getSymbols);
+	}
+	function getMapData(map, key) {
+		var data = map.__data__;
+		return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+	}
+	function getNative(object, key) {
+		var value = getValue(object, key);
+		return baseIsNative(value) ? value : void 0;
+	}
+	var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
+	var getTag = baseGetTag;
+	if (DataView && getTag(new DataView(/* @__PURE__ */ new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise && getTag(Promise.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) getTag = function(value) {
+		var result = objectToString.call(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : void 0;
+		if (ctorString) switch (ctorString) {
+			case dataViewCtorString: return dataViewTag;
+			case mapCtorString: return mapTag;
+			case promiseCtorString: return promiseTag;
+			case setCtorString: return setTag;
+			case weakMapCtorString: return weakMapTag;
+		}
+		return result;
+	};
+	function initCloneArray(array) {
+		var length = array.length, result = array.constructor(length);
+		if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) {
+			result.index = array.index;
+			result.input = array.input;
+		}
+		return result;
+	}
+	function initCloneObject(object) {
+		return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+	}
+	function initCloneByTag(object, tag, cloneFunc, isDeep) {
+		var Ctor = object.constructor;
+		switch (tag) {
+			case arrayBufferTag: return cloneArrayBuffer(object);
+			case boolTag:
+			case dateTag: return new Ctor(+object);
+			case dataViewTag: return cloneDataView(object, isDeep);
+			case float32Tag:
+			case float64Tag:
+			case int8Tag:
+			case int16Tag:
+			case int32Tag:
+			case uint8Tag:
+			case uint8ClampedTag:
+			case uint16Tag:
+			case uint32Tag: return cloneTypedArray(object, isDeep);
+			case mapTag: return cloneMap(object, isDeep, cloneFunc);
+			case numberTag:
+			case stringTag: return new Ctor(object);
+			case regexpTag: return cloneRegExp(object);
+			case setTag: return cloneSet(object, isDeep, cloneFunc);
+			case symbolTag: return cloneSymbol(object);
+		}
+	}
+	function isIndex(value, length) {
+		length = length == null ? MAX_SAFE_INTEGER : length;
+		return !!length && (typeof value == "number" || reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+	}
+	function isKeyable(value) {
+		var type = typeof value;
+		return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+	}
+	function isMasked(func) {
+		return !!maskSrcKey && maskSrcKey in func;
+	}
+	function isPrototype(value) {
+		var Ctor = value && value.constructor;
+		return value === (typeof Ctor == "function" && Ctor.prototype || objectProto);
+	}
+	function toSource(func) {
+		if (func != null) {
+			try {
+				return funcToString.call(func);
+			} catch (e) {}
+			try {
+				return func + "";
+			} catch (e) {}
+		}
+		return "";
+	}
+	function cloneDeep(value) {
+		return baseClone(value, true, true);
+	}
+	function eq(value, other) {
+		return value === other || value !== value && other !== other;
+	}
+	function isArguments(value) {
+		return isArrayLikeObject(value) && hasOwnProperty.call(value, "callee") && (!propertyIsEnumerable.call(value, "callee") || objectToString.call(value) == argsTag);
+	}
+	var isArray = Array.isArray;
+	function isArrayLike(value) {
+		return value != null && isLength(value.length) && !isFunction(value);
+	}
+	function isArrayLikeObject(value) {
+		return isObjectLike(value) && isArrayLike(value);
+	}
+	var isBuffer = nativeIsBuffer || stubFalse;
+	function isFunction(value) {
+		var tag = isObject(value) ? objectToString.call(value) : "";
+		return tag == funcTag || tag == genTag;
+	}
+	function isLength(value) {
+		return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+	function isObject(value) {
+		var type = typeof value;
+		return !!value && (type == "object" || type == "function");
+	}
+	function isObjectLike(value) {
+		return !!value && typeof value == "object";
+	}
+	function keys(object) {
+		return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+	}
+	function stubArray() {
+		return [];
+	}
+	function stubFalse() {
+		return false;
+	}
+	module.exports = cloneDeep;
+}));
+export { require_lodash_clonedeep as t };

package/dist/_chunks/rolldown-runtime.mjs

@@ -0,0 +1,24 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+export { __require as n, __toESM as r, __commonJSMin as t };