@cynnie/ui-antd 0.1.0

package/dist/ProFormBuilder-C4qUATw1.js

@@ -0,0 +1,1078 @@
+import { Fragment, computed, createBlock, createElementBlock, createVNode, defineComponent, h, mergeModels, mergeProps, openBlock, ref, renderList, renderSlot, resolveComponent, useModel, withCtx } from "vue";
+import { Checkbox, DatePicker, Input, InputNumber, Modal, Select, Textarea } from "ant-design-vue";
+var _freeGlobal_default = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var _root_default = _freeGlobal_default || freeSelf || Function("return this")();
+var _Symbol_default = _root_default.Symbol;
+var objectProto$3 = Object.prototype;
+var hasOwnProperty$10 = objectProto$3.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$3.toString;
+var symToStringTag$1 = _Symbol_default ? _Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+	var isOwn = hasOwnProperty$10.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+	try {
+		value[symToStringTag$1] = void 0;
+		var unmasked = true;
+	} catch (e) {}
+	var result = nativeObjectToString$1.call(value);
+	if (unmasked) if (isOwn) value[symToStringTag$1] = tag;
+	else delete value[symToStringTag$1];
+	return result;
+}
+var _getRawTag_default = getRawTag;
+var nativeObjectToString = Object.prototype.toString;
+function objectToString(value) {
+	return nativeObjectToString.call(value);
+}
+var _objectToString_default = objectToString;
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+	if (value == null) return value === void 0 ? undefinedTag : nullTag;
+	return symToStringTag && symToStringTag in Object(value) ? _getRawTag_default(value) : _objectToString_default(value);
+}
+var _baseGetTag_default = baseGetTag;
+function isObjectLike(value) {
+	return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+var symbolTag$1 = "[object Symbol]";
+function isSymbol(value) {
+	return typeof value == "symbol" || isObjectLike_default(value) && _baseGetTag_default(value) == symbolTag$1;
+}
+var isSymbol_default = isSymbol;
+function arrayMap(array, iteratee) {
+	var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+	while (++index < length) result[index] = iteratee(array[index], index, array);
+	return result;
+}
+var _arrayMap_default = arrayMap;
+var isArray_default = Array.isArray;
+var INFINITY$1 = Infinity;
+var symbolProto$1 = _Symbol_default ? _Symbol_default.prototype : void 0, symbolToString = symbolProto$1 ? symbolProto$1.toString : void 0;
+function baseToString(value) {
+	if (typeof value == "string") return value;
+	if (isArray_default(value)) return _arrayMap_default(value, baseToString) + "";
+	if (isSymbol_default(value)) return symbolToString ? symbolToString.call(value) : "";
+	var result = value + "";
+	return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+}
+var _baseToString_default = baseToString;
+function isObject(value) {
+	var type = typeof value;
+	return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+function identity(value) {
+	return value;
+}
+var identity_default = identity;
+var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+	if (!isObject_default(value)) return false;
+	var tag = _baseGetTag_default(value);
+	return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+var _coreJsData_default = _root_default["__core-js_shared__"];
+var maskSrcKey = function() {
+	var uid = /[^.]+$/.exec(_coreJsData_default && _coreJsData_default.keys && _coreJsData_default.keys.IE_PROTO || "");
+	return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+	return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked_default = isMasked;
+var funcToString$1 = Function.prototype.toString;
+function toSource(func) {
+	if (func != null) {
+		try {
+			return funcToString$1.call(func);
+		} catch (e) {}
+		try {
+			return func + "";
+		} catch (e) {}
+	}
+	return "";
+}
+var _toSource_default = toSource;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$2 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$9 = objectProto$2.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty$9).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+function baseIsNative(value) {
+	if (!isObject_default(value) || _isMasked_default(value)) return false;
+	return (isFunction_default(value) ? reIsNative : reIsHostCtor).test(_toSource_default(value));
+}
+var _baseIsNative_default = baseIsNative;
+function getValue(object, key) {
+	return object == null ? void 0 : object[key];
+}
+var _getValue_default = getValue;
+function getNative(object, key) {
+	var value = _getValue_default(object, key);
+	return _baseIsNative_default(value) ? value : void 0;
+}
+var _getNative_default = getNative;
+var _WeakMap_default = _getNative_default(_root_default, "WeakMap");
+var _defineProperty_default = function() {
+	try {
+		var func = _getNative_default(Object, "defineProperty");
+		func({}, "", {});
+		return func;
+	} catch (e) {}
+}();
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(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;
+}
+var _isIndex_default = isIndex;
+function baseAssignValue(object, key, value) {
+	if (key == "__proto__" && _defineProperty_default) _defineProperty_default(object, key, {
+		"configurable": true,
+		"enumerable": true,
+		"value": value,
+		"writable": true
+	});
+	else object[key] = value;
+}
+var _baseAssignValue_default = baseAssignValue;
+function eq(value, other) {
+	return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+var hasOwnProperty$8 = Object.prototype.hasOwnProperty;
+function assignValue(object, key, value) {
+	var objValue = object[key];
+	if (!(hasOwnProperty$8.call(object, key) && eq_default(objValue, value)) || value === void 0 && !(key in object)) _baseAssignValue_default(object, key, value);
+}
+var _assignValue_default = assignValue;
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+	return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+var isLength_default = isLength;
+function isArrayLike(value) {
+	return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default = isArrayLike;
+var objectProto$1 = Object.prototype;
+function isPrototype(value) {
+	var Ctor = value && value.constructor;
+	return value === (typeof Ctor == "function" && Ctor.prototype || objectProto$1);
+}
+var _isPrototype_default = isPrototype;
+function baseTimes(n, iteratee) {
+	var index = -1, result = Array(n);
+	while (++index < n) result[index] = iteratee(index);
+	return result;
+}
+var _baseTimes_default = baseTimes;
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments(value) {
+	return isObjectLike_default(value) && _baseGetTag_default(value) == argsTag$2;
+}
+var _baseIsArguments_default = baseIsArguments;
+var objectProto = Object.prototype;
+var hasOwnProperty$7 = objectProto.hasOwnProperty;
+var propertyIsEnumerable$1 = objectProto.propertyIsEnumerable;
+var isArguments_default = _baseIsArguments_default(function() {
+	return arguments;
+}()) ? _baseIsArguments_default : function(value) {
+	return isObjectLike_default(value) && hasOwnProperty$7.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
+};
+function stubFalse() {
+	return false;
+}
+var stubFalse_default = stubFalse;
+var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+var Buffer = freeModule$1 && freeModule$1.exports === freeExports$1 ? _root_default.Buffer : void 0;
+var isBuffer_default = (Buffer ? Buffer.isBuffer : void 0) || stubFalse_default;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", objectTag$2 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", weakMapTag$1 = "[object WeakMap]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[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$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$1] = typedArrayTags[setTag$2] = typedArrayTags[stringTag$1] = typedArrayTags[weakMapTag$1] = false;
+function baseIsTypedArray(value) {
+	return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[_baseGetTag_default(value)];
+}
+var _baseIsTypedArray_default = baseIsTypedArray;
+function baseUnary(func) {
+	return function(value) {
+		return func(value);
+	};
+}
+var _baseUnary_default = baseUnary;
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var freeProcess = freeModule && freeModule.exports === freeExports && _freeGlobal_default.process;
+var _nodeUtil_default = function() {
+	try {
+		var types = freeModule && freeModule.require && freeModule.require("util").types;
+		if (types) return types;
+		return freeProcess && freeProcess.binding && freeProcess.binding("util");
+	} catch (e) {}
+}();
+var nodeIsTypedArray = _nodeUtil_default && _nodeUtil_default.isTypedArray;
+var isTypedArray_default = nodeIsTypedArray ? _baseUnary_default(nodeIsTypedArray) : _baseIsTypedArray_default;
+var hasOwnProperty$6 = Object.prototype.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+	var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? _baseTimes_default(value.length, String) : [], length = result.length;
+	for (var key in value) if ((inherited || hasOwnProperty$6.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || _isIndex_default(key, length)))) result.push(key);
+	return result;
+}
+var _arrayLikeKeys_default = arrayLikeKeys;
+function overArg(func, transform) {
+	return function(arg) {
+		return func(transform(arg));
+	};
+}
+var _overArg_default = overArg;
+var _nativeKeys_default = _overArg_default(Object.keys, Object);
+var hasOwnProperty$5 = Object.prototype.hasOwnProperty;
+function baseKeys(object) {
+	if (!_isPrototype_default(object)) return _nativeKeys_default(object);
+	var result = [];
+	for (var key in Object(object)) if (hasOwnProperty$5.call(object, key) && key != "constructor") result.push(key);
+	return result;
+}
+var _baseKeys_default = baseKeys;
+function keys(object) {
+	return isArrayLike_default(object) ? _arrayLikeKeys_default(object) : _baseKeys_default(object);
+}
+var keys_default = keys;
+function nativeKeysIn(object) {
+	var result = [];
+	if (object != null) for (var key in Object(object)) result.push(key);
+	return result;
+}
+var _nativeKeysIn_default = nativeKeysIn;
+var hasOwnProperty$4 = Object.prototype.hasOwnProperty;
+function baseKeysIn(object) {
+	if (!isObject_default(object)) return _nativeKeysIn_default(object);
+	var isProto = _isPrototype_default(object), result = [];
+	for (var key in object) if (!(key == "constructor" && (isProto || !hasOwnProperty$4.call(object, key)))) result.push(key);
+	return result;
+}
+var _baseKeysIn_default = baseKeysIn;
+function keysIn(object) {
+	return isArrayLike_default(object) ? _arrayLikeKeys_default(object, true) : _baseKeysIn_default(object);
+}
+var keysIn_default = keysIn;
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+	if (isArray_default(value)) return false;
+	var type = typeof value;
+	if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) return true;
+	return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey_default = isKey;
+var _nativeCreate_default = _getNative_default(Object, "create");
+function hashClear() {
+	this.__data__ = _nativeCreate_default ? _nativeCreate_default(null) : {};
+	this.size = 0;
+}
+var _hashClear_default = hashClear;
+function hashDelete(key) {
+	var result = this.has(key) && delete this.__data__[key];
+	this.size -= result ? 1 : 0;
+	return result;
+}
+var _hashDelete_default = hashDelete;
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+function hashGet(key) {
+	var data = this.__data__;
+	if (_nativeCreate_default) {
+		var result = data[key];
+		return result === HASH_UNDEFINED$2 ? void 0 : result;
+	}
+	return hasOwnProperty$3.call(data, key) ? data[key] : void 0;
+}
+var _hashGet_default = hashGet;
+var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+function hashHas(key) {
+	var data = this.__data__;
+	return _nativeCreate_default ? data[key] !== void 0 : hasOwnProperty$2.call(data, key);
+}
+var _hashHas_default = hashHas;
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+	var data = this.__data__;
+	this.size += this.has(key) ? 0 : 1;
+	data[key] = _nativeCreate_default && value === void 0 ? HASH_UNDEFINED$1 : value;
+	return this;
+}
+var _hashSet_default = hashSet;
+function Hash(entries) {
+	var index = -1, length = entries == null ? 0 : entries.length;
+	this.clear();
+	while (++index < length) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+Hash.prototype.clear = _hashClear_default;
+Hash.prototype["delete"] = _hashDelete_default;
+Hash.prototype.get = _hashGet_default;
+Hash.prototype.has = _hashHas_default;
+Hash.prototype.set = _hashSet_default;
+var _Hash_default = Hash;
+function listCacheClear() {
+	this.__data__ = [];
+	this.size = 0;
+}
+var _listCacheClear_default = listCacheClear;
+function assocIndexOf(array, key) {
+	var length = array.length;
+	while (length--) if (eq_default(array[length][0], key)) return length;
+	return -1;
+}
+var _assocIndexOf_default = assocIndexOf;
+var splice = Array.prototype.splice;
+function listCacheDelete(key) {
+	var data = this.__data__, index = _assocIndexOf_default(data, key);
+	if (index < 0) return false;
+	if (index == data.length - 1) data.pop();
+	else splice.call(data, index, 1);
+	--this.size;
+	return true;
+}
+var _listCacheDelete_default = listCacheDelete;
+function listCacheGet(key) {
+	var data = this.__data__, index = _assocIndexOf_default(data, key);
+	return index < 0 ? void 0 : data[index][1];
+}
+var _listCacheGet_default = listCacheGet;
+function listCacheHas(key) {
+	return _assocIndexOf_default(this.__data__, key) > -1;
+}
+var _listCacheHas_default = listCacheHas;
+function listCacheSet(key, value) {
+	var data = this.__data__, index = _assocIndexOf_default(data, key);
+	if (index < 0) {
+		++this.size;
+		data.push([key, value]);
+	} else data[index][1] = value;
+	return this;
+}
+var _listCacheSet_default = listCacheSet;
+function ListCache(entries) {
+	var index = -1, length = entries == null ? 0 : entries.length;
+	this.clear();
+	while (++index < length) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+ListCache.prototype.clear = _listCacheClear_default;
+ListCache.prototype["delete"] = _listCacheDelete_default;
+ListCache.prototype.get = _listCacheGet_default;
+ListCache.prototype.has = _listCacheHas_default;
+ListCache.prototype.set = _listCacheSet_default;
+var _ListCache_default = ListCache;
+var _Map_default = _getNative_default(_root_default, "Map");
+function mapCacheClear() {
+	this.size = 0;
+	this.__data__ = {
+		"hash": new _Hash_default(),
+		"map": new (_Map_default || _ListCache_default)(),
+		"string": new _Hash_default()
+	};
+}
+var _mapCacheClear_default = mapCacheClear;
+function isKeyable(value) {
+	var type = typeof value;
+	return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable_default = isKeyable;
+function getMapData(map, key) {
+	var data = map.__data__;
+	return _isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData_default = getMapData;
+function mapCacheDelete(key) {
+	var result = _getMapData_default(this, key)["delete"](key);
+	this.size -= result ? 1 : 0;
+	return result;
+}
+var _mapCacheDelete_default = mapCacheDelete;
+function mapCacheGet(key) {
+	return _getMapData_default(this, key).get(key);
+}
+var _mapCacheGet_default = mapCacheGet;
+function mapCacheHas(key) {
+	return _getMapData_default(this, key).has(key);
+}
+var _mapCacheHas_default = mapCacheHas;
+function mapCacheSet(key, value) {
+	var data = _getMapData_default(this, key), size = data.size;
+	data.set(key, value);
+	this.size += data.size == size ? 0 : 1;
+	return this;
+}
+var _mapCacheSet_default = mapCacheSet;
+function MapCache(entries) {
+	var index = -1, length = entries == null ? 0 : entries.length;
+	this.clear();
+	while (++index < length) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+MapCache.prototype.clear = _mapCacheClear_default;
+MapCache.prototype["delete"] = _mapCacheDelete_default;
+MapCache.prototype.get = _mapCacheGet_default;
+MapCache.prototype.has = _mapCacheHas_default;
+MapCache.prototype.set = _mapCacheSet_default;
+var _MapCache_default = MapCache;
+var FUNC_ERROR_TEXT$1 = "Expected a function";
+function memoize(func, resolver) {
+	if (typeof func != "function" || resolver != null && typeof resolver != "function") throw new TypeError(FUNC_ERROR_TEXT$1);
+	var memoized = function() {
+		var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+		if (cache.has(key)) return cache.get(key);
+		var result = func.apply(this, args);
+		memoized.cache = cache.set(key, result) || cache;
+		return result;
+	};
+	memoized.cache = new (memoize.Cache || _MapCache_default)();
+	return memoized;
+}
+memoize.Cache = _MapCache_default;
+var memoize_default = memoize;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+	var result = memoize_default(func, function(key) {
+		if (cache.size === MAX_MEMOIZE_SIZE) cache.clear();
+		return key;
+	});
+	var cache = result.cache;
+	return result;
+}
+var _memoizeCapped_default = memoizeCapped;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var _stringToPath_default = _memoizeCapped_default(function(string) {
+	var result = [];
+	if (string.charCodeAt(0) === 46) result.push("");
+	string.replace(rePropName, function(match, number, quote, subString) {
+		result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+	});
+	return result;
+});
+function toString(value) {
+	return value == null ? "" : _baseToString_default(value);
+}
+var toString_default = toString;
+function castPath(value, object) {
+	if (isArray_default(value)) return value;
+	return _isKey_default(value, object) ? [value] : _stringToPath_default(toString_default(value));
+}
+var _castPath_default = castPath;
+var INFINITY = Infinity;
+function toKey(value) {
+	if (typeof value == "string" || isSymbol_default(value)) return value;
+	var result = value + "";
+	return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var _toKey_default = toKey;
+function baseGet(object, path) {
+	path = _castPath_default(path, object);
+	var index = 0, length = path.length;
+	while (object != null && index < length) object = object[_toKey_default(path[index++])];
+	return index && index == length ? object : void 0;
+}
+var _baseGet_default = baseGet;
+function get(object, path, defaultValue) {
+	var result = object == null ? void 0 : _baseGet_default(object, path);
+	return result === void 0 ? defaultValue : result;
+}
+var get_default = get;
+function arrayPush(array, values) {
+	var index = -1, length = values.length, offset = array.length;
+	while (++index < length) array[offset + index] = values[index];
+	return array;
+}
+var _arrayPush_default = arrayPush;
+var _getPrototype_default = _overArg_default(Object.getPrototypeOf, Object);
+function stackClear() {
+	this.__data__ = new _ListCache_default();
+	this.size = 0;
+}
+var _stackClear_default = stackClear;
+function stackDelete(key) {
+	var data = this.__data__, result = data["delete"](key);
+	this.size = data.size;
+	return result;
+}
+var _stackDelete_default = stackDelete;
+function stackGet(key) {
+	return this.__data__.get(key);
+}
+var _stackGet_default = stackGet;
+function stackHas(key) {
+	return this.__data__.has(key);
+}
+var _stackHas_default = stackHas;
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+	var data = this.__data__;
+	if (data instanceof _ListCache_default) {
+		var pairs = data.__data__;
+		if (!_Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
+			pairs.push([key, value]);
+			this.size = ++data.size;
+			return this;
+		}
+		data = this.__data__ = new _MapCache_default(pairs);
+	}
+	data.set(key, value);
+	this.size = data.size;
+	return this;
+}
+var _stackSet_default = stackSet;
+function Stack(entries) {
+	this.size = (this.__data__ = new _ListCache_default(entries)).size;
+}
+Stack.prototype.clear = _stackClear_default;
+Stack.prototype["delete"] = _stackDelete_default;
+Stack.prototype.get = _stackGet_default;
+Stack.prototype.has = _stackHas_default;
+Stack.prototype.set = _stackSet_default;
+var _Stack_default = Stack;
+function arrayFilter(array, predicate) {
+	var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+	while (++index < length) {
+		var value = array[index];
+		if (predicate(value, index, array)) result[resIndex++] = value;
+	}
+	return result;
+}
+var _arrayFilter_default = arrayFilter;
+function stubArray() {
+	return [];
+}
+var stubArray_default = stubArray;
+var propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var _getSymbols_default = !nativeGetSymbols ? stubArray_default : function(object) {
+	if (object == null) return [];
+	object = Object(object);
+	return _arrayFilter_default(nativeGetSymbols(object), function(symbol) {
+		return propertyIsEnumerable.call(object, symbol);
+	});
+};
+var _getSymbolsIn_default = !Object.getOwnPropertySymbols ? stubArray_default : function(object) {
+	var result = [];
+	while (object) {
+		_arrayPush_default(result, _getSymbols_default(object));
+		object = _getPrototype_default(object);
+	}
+	return result;
+};
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+	var result = keysFunc(object);
+	return isArray_default(object) ? result : _arrayPush_default(result, symbolsFunc(object));
+}
+var _baseGetAllKeys_default = baseGetAllKeys;
+function getAllKeys(object) {
+	return _baseGetAllKeys_default(object, keys_default, _getSymbols_default);
+}
+var _getAllKeys_default = getAllKeys;
+function getAllKeysIn(object) {
+	return _baseGetAllKeys_default(object, keysIn_default, _getSymbolsIn_default);
+}
+var _getAllKeysIn_default = getAllKeysIn;
+var _DataView_default = _getNative_default(_root_default, "DataView");
+var _Promise_default = _getNative_default(_root_default, "Promise");
+var _Set_default = _getNative_default(_root_default, "Set");
+var mapTag$1 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$1 = "[object Set]", weakMapTag = "[object WeakMap]";
+var dataViewTag$1 = "[object DataView]";
+var dataViewCtorString = _toSource_default(_DataView_default), mapCtorString = _toSource_default(_Map_default), promiseCtorString = _toSource_default(_Promise_default), setCtorString = _toSource_default(_Set_default), weakMapCtorString = _toSource_default(_WeakMap_default);
+var getTag = _baseGetTag_default;
+if (_DataView_default && getTag(new _DataView_default(/* @__PURE__ */ new ArrayBuffer(1))) != dataViewTag$1 || _Map_default && getTag(new _Map_default()) != mapTag$1 || _Promise_default && getTag(_Promise_default.resolve()) != promiseTag || _Set_default && getTag(new _Set_default()) != setTag$1 || _WeakMap_default && getTag(new _WeakMap_default()) != weakMapTag) getTag = function(value) {
+	var result = _baseGetTag_default(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? _toSource_default(Ctor) : "";
+	if (ctorString) switch (ctorString) {
+		case dataViewCtorString: return dataViewTag$1;
+		case mapCtorString: return mapTag$1;
+		case promiseCtorString: return promiseTag;
+		case setCtorString: return setTag$1;
+		case weakMapCtorString: return weakMapTag;
+	}
+	return result;
+};
+var _getTag_default = getTag;
+var _Uint8Array_default = _root_default.Uint8Array;
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+	this.__data__.set(value, HASH_UNDEFINED);
+	return this;
+}
+var _setCacheAdd_default = setCacheAdd;
+function setCacheHas(value) {
+	return this.__data__.has(value);
+}
+var _setCacheHas_default = setCacheHas;
+function SetCache(values) {
+	var index = -1, length = values == null ? 0 : values.length;
+	this.__data__ = new _MapCache_default();
+	while (++index < length) this.add(values[index]);
+}
+SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd_default;
+SetCache.prototype.has = _setCacheHas_default;
+var _SetCache_default = SetCache;
+function arraySome(array, predicate) {
+	var index = -1, length = array == null ? 0 : array.length;
+	while (++index < length) if (predicate(array[index], index, array)) return true;
+	return false;
+}
+var _arraySome_default = arraySome;
+function cacheHas(cache, key) {
+	return cache.has(key);
+}
+var _cacheHas_default = cacheHas;
+var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+	var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
+	if (arrLength != othLength && !(isPartial && othLength > arrLength)) return false;
+	var arrStacked = stack.get(array);
+	var othStacked = stack.get(other);
+	if (arrStacked && othStacked) return arrStacked == other && othStacked == array;
+	var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new _SetCache_default() : void 0;
+	stack.set(array, other);
+	stack.set(other, array);
+	while (++index < arrLength) {
+		var arrValue = array[index], othValue = other[index];
+		if (customizer) var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+		if (compared !== void 0) {
+			if (compared) continue;
+			result = false;
+			break;
+		}
+		if (seen) {
+			if (!_arraySome_default(other, function(othValue$1, othIndex) {
+				if (!_cacheHas_default(seen, othIndex) && (arrValue === othValue$1 || equalFunc(arrValue, othValue$1, bitmask, customizer, stack))) return seen.push(othIndex);
+			})) {
+				result = false;
+				break;
+			}
+		} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+			result = false;
+			break;
+		}
+	}
+	stack["delete"](array);
+	stack["delete"](other);
+	return result;
+}
+var _equalArrays_default = equalArrays;
+function mapToArray(map) {
+	var index = -1, result = Array(map.size);
+	map.forEach(function(value, key) {
+		result[++index] = [key, value];
+	});
+	return result;
+}
+var _mapToArray_default = mapToArray;
+function setToArray(set) {
+	var index = -1, result = Array(set.size);
+	set.forEach(function(value) {
+		result[++index] = value;
+	});
+	return result;
+}
+var _setToArray_default = setToArray;
+var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2;
+var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
+var symbolProto = _Symbol_default ? _Symbol_default.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+	switch (tag) {
+		case dataViewTag:
+			if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) return false;
+			object = object.buffer;
+			other = other.buffer;
+		case arrayBufferTag:
+			if (object.byteLength != other.byteLength || !equalFunc(new _Uint8Array_default(object), new _Uint8Array_default(other))) return false;
+			return true;
+		case boolTag:
+		case dateTag:
+		case numberTag: return eq_default(+object, +other);
+		case errorTag: return object.name == other.name && object.message == other.message;
+		case regexpTag:
+		case stringTag: return object == other + "";
+		case mapTag: var convert = _mapToArray_default;
+		case setTag:
+			var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+			convert || (convert = _setToArray_default);
+			if (object.size != other.size && !isPartial) return false;
+			var stacked = stack.get(object);
+			if (stacked) return stacked == other;
+			bitmask |= COMPARE_UNORDERED_FLAG$2;
+			stack.set(object, other);
+			var result = _equalArrays_default(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+			stack["delete"](object);
+			return result;
+		case symbolTag: if (symbolValueOf) return symbolValueOf.call(object) == symbolValueOf.call(other);
+	}
+	return false;
+}
+var _equalByTag_default = equalByTag;
+var COMPARE_PARTIAL_FLAG$3 = 1;
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+	var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = _getAllKeys_default(object), objLength = objProps.length;
+	if (objLength != _getAllKeys_default(other).length && !isPartial) return false;
+	var index = objLength;
+	while (index--) {
+		var key = objProps[index];
+		if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) return false;
+	}
+	var objStacked = stack.get(object);
+	var othStacked = stack.get(other);
+	if (objStacked && othStacked) return objStacked == other && othStacked == object;
+	var result = true;
+	stack.set(object, other);
+	stack.set(other, object);
+	var skipCtor = isPartial;
+	while (++index < objLength) {
+		key = objProps[index];
+		var objValue = object[key], othValue = other[key];
+		if (customizer) var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+		if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+			result = false;
+			break;
+		}
+		skipCtor || (skipCtor = key == "constructor");
+	}
+	if (result && !skipCtor) {
+		var objCtor = object.constructor, othCtor = other.constructor;
+		if (objCtor != othCtor && "constructor" in object && "constructor" in other && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) result = false;
+	}
+	stack["delete"](object);
+	stack["delete"](other);
+	return result;
+}
+var _equalObjects_default = equalObjects;
+var COMPARE_PARTIAL_FLAG$2 = 1;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+	var objIsArr = isArray_default(object), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag : _getTag_default(object), othTag = othIsArr ? arrayTag : _getTag_default(other);
+	objTag = objTag == argsTag ? objectTag : objTag;
+	othTag = othTag == argsTag ? objectTag : othTag;
+	var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+	if (isSameTag && isBuffer_default(object)) {
+		if (!isBuffer_default(other)) return false;
+		objIsArr = true;
+		objIsObj = false;
+	}
+	if (isSameTag && !objIsObj) {
+		stack || (stack = new _Stack_default());
+		return objIsArr || isTypedArray_default(object) ? _equalArrays_default(object, other, bitmask, customizer, equalFunc, stack) : _equalByTag_default(object, other, objTag, bitmask, customizer, equalFunc, stack);
+	}
+	if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+		var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+		if (objIsWrapped || othIsWrapped) {
+			var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+			stack || (stack = new _Stack_default());
+			return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+		}
+	}
+	if (!isSameTag) return false;
+	stack || (stack = new _Stack_default());
+	return _equalObjects_default(object, other, bitmask, customizer, equalFunc, stack);
+}
+var _baseIsEqualDeep_default = baseIsEqualDeep;
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+	if (value === other) return true;
+	if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) return value !== value && other !== other;
+	return _baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var _baseIsEqual_default = baseIsEqual;
+var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+	var index = matchData.length, length = index, noCustomizer = !customizer;
+	if (object == null) return !length;
+	object = Object(object);
+	while (index--) {
+		var data = matchData[index];
+		if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) return false;
+	}
+	while (++index < length) {
+		data = matchData[index];
+		var key = data[0], objValue = object[key], srcValue = data[1];
+		if (noCustomizer && data[2]) {
+			if (objValue === void 0 && !(key in object)) return false;
+		} else {
+			var stack = new _Stack_default();
+			if (customizer) var result = customizer(objValue, srcValue, key, object, source, stack);
+			if (!(result === void 0 ? _baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) return false;
+		}
+	}
+	return true;
+}
+var _baseIsMatch_default = baseIsMatch;
+function isStrictComparable(value) {
+	return value === value && !isObject_default(value);
+}
+var _isStrictComparable_default = isStrictComparable;
+function getMatchData(object) {
+	var result = keys_default(object), length = result.length;
+	while (length--) {
+		var key = result[length], value = object[key];
+		result[length] = [
+			key,
+			value,
+			_isStrictComparable_default(value)
+		];
+	}
+	return result;
+}
+var _getMatchData_default = getMatchData;
+function matchesStrictComparable(key, srcValue) {
+	return function(object) {
+		if (object == null) return false;
+		return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+	};
+}
+var _matchesStrictComparable_default = matchesStrictComparable;
+function baseMatches(source) {
+	var matchData = _getMatchData_default(source);
+	if (matchData.length == 1 && matchData[0][2]) return _matchesStrictComparable_default(matchData[0][0], matchData[0][1]);
+	return function(object) {
+		return object === source || _baseIsMatch_default(object, source, matchData);
+	};
+}
+var _baseMatches_default = baseMatches;
+function baseHasIn(object, key) {
+	return object != null && key in Object(object);
+}
+var _baseHasIn_default = baseHasIn;
+function hasPath(object, path, hasFunc) {
+	path = _castPath_default(path, object);
+	var index = -1, length = path.length, result = false;
+	while (++index < length) {
+		var key = _toKey_default(path[index]);
+		if (!(result = object != null && hasFunc(object, key))) break;
+		object = object[key];
+	}
+	if (result || ++index != length) return result;
+	length = object == null ? 0 : object.length;
+	return !!length && isLength_default(length) && _isIndex_default(key, length) && (isArray_default(object) || isArguments_default(object));
+}
+var _hasPath_default = hasPath;
+function hasIn(object, path) {
+	return object != null && _hasPath_default(object, path, _baseHasIn_default);
+}
+var hasIn_default = hasIn;
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty(path, srcValue) {
+	if (_isKey_default(path) && _isStrictComparable_default(srcValue)) return _matchesStrictComparable_default(_toKey_default(path), srcValue);
+	return function(object) {
+		var objValue = get_default(object, path);
+		return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path) : _baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+	};
+}
+var _baseMatchesProperty_default = baseMatchesProperty;
+function baseProperty(key) {
+	return function(object) {
+		return object == null ? void 0 : object[key];
+	};
+}
+var _baseProperty_default = baseProperty;
+function basePropertyDeep(path) {
+	return function(object) {
+		return _baseGet_default(object, path);
+	};
+}
+var _basePropertyDeep_default = basePropertyDeep;
+function property(path) {
+	return _isKey_default(path) ? _baseProperty_default(_toKey_default(path)) : _basePropertyDeep_default(path);
+}
+var property_default = property;
+function baseIteratee(value) {
+	if (typeof value == "function") return value;
+	if (value == null) return identity_default;
+	if (typeof value == "object") return isArray_default(value) ? _baseMatchesProperty_default(value[0], value[1]) : _baseMatches_default(value);
+	return property_default(value);
+}
+var _baseIteratee_default = baseIteratee;
+var FUNC_ERROR_TEXT = "Expected a function";
+function negate(predicate) {
+	if (typeof predicate != "function") throw new TypeError(FUNC_ERROR_TEXT);
+	return function() {
+		var args = arguments;
+		switch (args.length) {
+			case 0: return !predicate.call(this);
+			case 1: return !predicate.call(this, args[0]);
+			case 2: return !predicate.call(this, args[0], args[1]);
+			case 3: return !predicate.call(this, args[0], args[1], args[2]);
+		}
+		return !predicate.apply(this, args);
+	};
+}
+var negate_default = negate;
+function baseSet(object, path, value, customizer) {
+	if (!isObject_default(object)) return object;
+	path = _castPath_default(path, object);
+	var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+	while (nested != null && ++index < length) {
+		var key = _toKey_default(path[index]), newValue = value;
+		if (key === "__proto__" || key === "constructor" || key === "prototype") return object;
+		if (index != lastIndex) {
+			var objValue = nested[key];
+			newValue = customizer ? customizer(objValue, key, nested) : void 0;
+			if (newValue === void 0) newValue = isObject_default(objValue) ? objValue : _isIndex_default(path[index + 1]) ? [] : {};
+		}
+		_assignValue_default(nested, key, newValue);
+		nested = nested[key];
+	}
+	return object;
+}
+var _baseSet_default = baseSet;
+function basePickBy(object, paths, predicate) {
+	var index = -1, length = paths.length, result = {};
+	while (++index < length) {
+		var path = paths[index], value = _baseGet_default(object, path);
+		if (predicate(value, path)) _baseSet_default(result, _castPath_default(path, object), value);
+	}
+	return result;
+}
+var _basePickBy_default = basePickBy;
+function pickBy(object, predicate) {
+	if (object == null) return {};
+	var props = _arrayMap_default(_getAllKeysIn_default(object), function(prop) {
+		return [prop];
+	});
+	predicate = _baseIteratee_default(predicate);
+	return _basePickBy_default(object, props, function(value, path) {
+		return predicate(value, path[0]);
+	});
+}
+var pickBy_default = pickBy;
+function omitBy(object, predicate) {
+	return pickBy_default(object, negate_default(_baseIteratee_default(predicate)));
+}
+var omitBy_default = omitBy;
+var ProFormBuilder_default = /* @__PURE__ */ defineComponent({
+	name: "ProFormBuilder",
+	__name: "index",
+	props: /* @__PURE__ */ mergeModels({
+		formItems: {},
+		rules: {},
+		span: {},
+		formConfig: {}
+	}, {
+		"modelValue": { default: () => ({}) },
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const formData = useModel(__props, "modelValue");
+		const span = computed(() => props.span ?? 24);
+		const visibleItems = computed(() => props.formItems.filter((item) => item.hidden !== true));
+		function transformModelValue(component, key = "value") {
+			return { setup: (props$1, { slots, emit, attrs }) => {
+				return () => {
+					const { modelValue, ...rest } = {
+						...attrs,
+						...props$1
+					};
+					return h(component, {
+						...rest,
+						[key]: modelValue,
+						[`onUpdate:${key}`]: (val) => {
+							emit(`update:modelValue`, val);
+						}
+					}, slots);
+				};
+			} };
+		}
+		const map = {
+			input: transformModelValue(Input),
+			textarea: transformModelValue(Textarea),
+			number: transformModelValue(InputNumber),
+			date: transformModelValue(DatePicker),
+			select: transformModelValue(Select),
+			checkbox: transformModelValue(Checkbox, "checked"),
+			modal: transformModelValue(Modal, "open")
+		};
+		const baseFieldReg = /^(label|key|type|span|hidden|slots|props|rules)$/;
+		function getComponent(item) {
+			if (item.type && typeof item.type !== "string") return item.type;
+			return map[typeof item.type === "string" ? item.type : "input"] ?? map.input;
+		}
+		function getProps(item) {
+			if (item.props) return item.props;
+			return omitBy_default(item, (_value, key) => baseFieldReg.test(key ?? ""));
+		}
+		const selectType = new Set(["select", "date"]);
+		const ComponentItem = {
+			props: ["item"],
+			setup(itemProps) {
+				const { item } = itemProps;
+				return () => {
+					const rest = getProps(item);
+					if (!("placeholder" in rest)) rest.placeholder = (typeof item.type === "string" && selectType.has(item.type) ? "请选择" : "请输入") + (item.label || "");
+					return h(getComponent(item), {
+						...rest,
+						modelValue: formData.value[item.key],
+						"onUpdate:modelValue": (value) => {
+							formData.value[item.key] = value;
+						}
+					}, item.slots);
+				};
+			}
+		};
+		const formRef = ref();
+		function validate() {
+			return formRef.value?.validate();
+		}
+		__expose({ validate });
+		return (_ctx, _cache) => {
+			const _component_a_form_item = resolveComponent("a-form-item");
+			const _component_a_col = resolveComponent("a-col");
+			const _component_a_row = resolveComponent("a-row");
+			const _component_a_form = resolveComponent("a-form");
+			return openBlock(), createBlock(_component_a_form, mergeProps({
+				ref_key: "formRef",
+				ref: formRef
+			}, _ctx.formConfig, {
+				rules: _ctx.rules,
+				model: formData.value
+			}), {
+				default: withCtx(() => [createVNode(_component_a_row, { gutter: 16 }, {
+					default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(visibleItems.value, (item) => {
+						return openBlock(), createBlock(_component_a_col, {
+							key: item.key,
+							span: item.span || span.value
+						}, {
+							default: withCtx(() => [createVNode(_component_a_form_item, {
+								label: item.label,
+								name: item.key
+							}, {
+								default: withCtx(() => [renderSlot(_ctx.$slots, item.key, {}, () => [createVNode(ComponentItem, { item }, null, 8, ["item"])])]),
+								_: 2
+							}, 1032, ["label", "name"])]),
+							_: 2
+						}, 1032, ["span"]);
+					}), 128))]),
+					_: 3
+				})]),
+				_: 3
+			}, 16, ["rules", "model"]);
+		};
+	}
+});
+export { ProFormBuilder_default as t };
+
+//# sourceMappingURL=ProFormBuilder-C4qUATw1.js.map