@v-c/tabs 0.0.2

package/dist/TabNavList/index.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1,516 @@
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+const require_TabContext = require("../TabContext.cjs");
+const require_useIndicator = require("../hooks/useIndicator.cjs");
+const require_useOffsets = require("../hooks/useOffsets.cjs");
+const require_useTouchMove = require("../hooks/useTouchMove.cjs");
+const require_useVisibleRange = require("../hooks/useVisibleRange.cjs");
+const require_utils = require("../utils.cjs");
+const require_AddButton = require("./AddButton.cjs");
+const require_ExtraContent = require("./ExtraContent.cjs");
+const require_OperationNode = require("./OperationNode.cjs");
+const require_TabNode = require("./TabNode.cjs");
+let vue = require("vue");
+let __v_c_util_dist_RenderComponent = require("@v-c/util/dist/RenderComponent");
+__v_c_util_dist_RenderComponent = require_rolldown_runtime.__toESM(__v_c_util_dist_RenderComponent);
+let __v_c_resize_observer = require("@v-c/resize-observer");
+__v_c_resize_observer = require_rolldown_runtime.__toESM(__v_c_resize_observer);
+var _hoisted_1 = ["aria-orientation"];
+var index_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: "TabNavList",
+	inheritAttrs: false,
+	__name: "index",
+	props: {
+		id: {},
+		tabPosition: {},
+		activeKey: {},
+		rtl: { type: Boolean },
+		animated: {},
+		extra: { type: [
+			Object,
+			String,
+			Number,
+			null,
+			Boolean,
+			Array
+		] },
+		editable: {},
+		more: {},
+		mobile: { type: Boolean },
+		tabBarGutter: {},
+		renderTabBar: { type: Function },
+		className: {},
+		style: {},
+		locale: {},
+		onTabClick: { type: Function },
+		onTabScroll: { type: Function },
+		children: { type: Function },
+		getPopupContainer: { type: Function },
+		popupClassName: {},
+		indicator: {},
+		classNames: {},
+		styles: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const { className, style, id, animated, activeKey, rtl, extra, editable, locale, tabPosition, tabBarGutter: tabBarGutterProp, children, onTabClick, onTabScroll, indicator, classNames: tabsClassNames, styles, mobile, more, getPopupContainer, popupClassName } = (0, vue.toRefs)(props);
+		const tabBarGutter = (0, vue.computed)(() => tabBarGutterProp.value ? `${tabBarGutterProp.value}px` : void 0);
+		const ctx = require_TabContext.useTabContext();
+		const tabs = (0, vue.computed)(() => ctx?.value.tabs || []);
+		const prefixCls = (0, vue.computed)(() => ctx?.value.prefixCls || "");
+		const containerRef = (0, vue.ref)(null);
+		const extraLeftRef = (0, vue.ref)(null);
+		const extraRightRef = (0, vue.ref)(null);
+		const tabsWrapperRef = (0, vue.ref)(null);
+		const tabListRef = (0, vue.ref)(null);
+		const tabPositionTopOrBottom = (0, vue.computed)(() => tabPosition.value === "top" || tabPosition.value === "bottom");
+		const transformLeft = (0, vue.ref)(0);
+		const transformTop = (0, vue.ref)(0);
+		(0, vue.watch)(transformLeft, (next, prev) => {
+			if (tabPositionTopOrBottom.value && onTabScroll) props.onTabScroll?.({ direction: next > (prev || 0) ? "left" : "right" });
+		}, { immediate: true });
+		(0, vue.watch)(transformTop, (next, prev) => {
+			if (!tabPositionTopOrBottom.value && onTabScroll) props.onTabScroll?.({ direction: next > (prev || 0) ? "top" : "bottom" });
+		}, { immediate: true });
+		const containerExcludeExtraSize = (0, vue.ref)([0, 0]);
+		const tabContentSize = (0, vue.ref)([0, 0]);
+		const firstTabContentSize = (0, vue.computed)(() => tabContentSize.value[0]);
+		const addSize = (0, vue.ref)([0, 0]);
+		const operationSize = (0, vue.ref)([0, 0]);
+		const tabSizes = (0, vue.shallowRef)(/* @__PURE__ */ new Map());
+		const tabOffsets = require_useOffsets.default(tabs, tabSizes, firstTabContentSize);
+		const operationsRef = (0, vue.ref)(null);
+		const innerAddButtonRef = (0, vue.ref)(null);
+		function getUnitValue(size, tabPositionTopOrBottom$1) {
+			return size[tabPositionTopOrBottom$1 ? 0 : 1];
+		}
+		const containerExcludeExtraSizeValue = (0, vue.computed)(() => getUnitValue(containerExcludeExtraSize.value, tabPositionTopOrBottom.value));
+		const tabContentSizeValue = (0, vue.computed)(() => getUnitValue(tabContentSize.value, tabPositionTopOrBottom.value));
+		const addSizeValue = (0, vue.computed)(() => getUnitValue(addSize.value, tabPositionTopOrBottom.value));
+		const operationSizeValue = (0, vue.computed)(() => getUnitValue(operationSize.value, tabPositionTopOrBottom.value));
+		const needScroll = (0, vue.computed)(() => Math.floor(containerExcludeExtraSizeValue.value) < Math.floor(tabContentSizeValue.value + addSizeValue.value));
+		const visibleTabContentValue = (0, vue.computed)(() => needScroll.value ? containerExcludeExtraSizeValue.value - operationSizeValue.value : containerExcludeExtraSizeValue.value - addSizeValue.value);
+		const operationsHiddenClassName = (0, vue.computed)(() => `${prefixCls.value}-nav-operations-hidden`);
+		const transformComputed = (0, vue.computed)(() => {
+			let transformMin = 0;
+			let transformMax = 0;
+			if (!tabPositionTopOrBottom.value) {
+				transformMin = Math.min(0, visibleTabContentValue.value - tabContentSizeValue.value);
+				transformMax = 0;
+			} else if (rtl.value) {
+				transformMin = 0;
+				transformMax = Math.max(0, tabContentSizeValue.value - visibleTabContentValue.value);
+			} else {
+				transformMin = Math.min(0, visibleTabContentValue.value - tabContentSizeValue.value);
+				transformMax = 0;
+			}
+			return {
+				transformMin,
+				transformMax
+			};
+		});
+		function alignInRange(value) {
+			const { transformMin, transformMax } = transformComputed.value;
+			if (value < transformMin) return transformMin;
+			if (value > transformMax) return transformMax;
+			return value;
+		}
+		const touchMovingRef = (0, vue.ref)(null);
+		const lockAnimation = (0, vue.ref)();
+		function doLockAnimation() {
+			lockAnimation.value = Date.now();
+		}
+		function clearTouchMoving() {
+			if (touchMovingRef.value) clearTimeout(touchMovingRef.value);
+		}
+		require_useTouchMove.default(tabsWrapperRef, (offsetX, offsetY) => {
+			function doMove(dataRef, offset) {
+				dataRef.value = alignInRange(dataRef.value + offset);
+			}
+			if (!needScroll.value) return false;
+			if (tabPositionTopOrBottom.value) doMove(transformLeft, offsetX);
+			else doMove(transformTop, offsetY);
+			clearTouchMoving();
+			doLockAnimation();
+			return true;
+		});
+		(0, vue.watch)(() => lockAnimation.value, async (_n, _o, onCleanup) => {
+			await (0, vue.nextTick)();
+			if (lockAnimation.value) touchMovingRef.value = setTimeout(() => {
+				lockAnimation.value = 0;
+			}, 100);
+			onCleanup(() => {
+				clearTouchMoving();
+			});
+		}, { immediate: true });
+		(0, vue.onUnmounted)(() => {
+			clearTouchMoving();
+		});
+		const visibleRangeRef = require_useVisibleRange.default(tabOffsets, visibleTabContentValue, (0, vue.computed)(() => tabPositionTopOrBottom.value ? transformLeft.value : transformTop.value), tabContentSizeValue, addSizeValue, operationSizeValue, {
+			tabs,
+			tabPosition,
+			rtl
+		});
+		const visibleStart = (0, vue.computed)(() => visibleRangeRef.value[0]);
+		const visibleEnd = (0, vue.computed)(() => visibleRangeRef.value[1]);
+		const hiddenTabs = (0, vue.computed)(() => {
+			const startHidden = tabs.value.slice(0, visibleStart.value);
+			const endHidden = tabs.value.slice(visibleEnd.value + 1);
+			return [...startHidden, ...endHidden];
+		});
+		const hasDropdown = (0, vue.computed)(() => hiddenTabs.value.length > 0);
+		const wrapPrefix = (0, vue.computed)(() => `${prefixCls.value}-nav-wrap`);
+		const pingLeft = (0, vue.computed)(() => tabPositionTopOrBottom.value ? rtl.value ? transformLeft.value > 0 : transformLeft.value < 0 : false);
+		const pingRight = (0, vue.computed)(() => {
+			if (!tabPositionTopOrBottom.value) return false;
+			if (rtl.value) return transformLeft.value !== transformComputed.value.transformMax;
+			return transformLeft.value !== transformComputed.value.transformMin;
+		});
+		const pingTop = (0, vue.computed)(() => !tabPositionTopOrBottom.value ? transformTop.value < 0 : false);
+		const pingBottom = (0, vue.computed)(() => !tabPositionTopOrBottom.value ? transformTop.value !== transformComputed.value.transformMin : false);
+		function scrollToTab(key = activeKey.value) {
+			const tabOffset = tabOffsets.value.get(key) || {
+				width: 0,
+				height: 0,
+				left: 0,
+				right: 0,
+				top: 0
+			};
+			if (tabPositionTopOrBottom.value) {
+				const newTransform = transformLeft;
+				if (rtl.value) {
+					if (tabOffset.right < transformLeft.value) newTransform.value = tabOffset.right;
+					else if (tabOffset.right + tabOffset.width > transformLeft.value + visibleTabContentValue.value) newTransform.value = tabOffset.right + tabOffset.width - visibleTabContentValue.value;
+				} else if (tabOffset.left < -transformLeft.value) newTransform.value = -tabOffset.left;
+				else if (tabOffset.left + tabOffset.width > -transformLeft.value + visibleTabContentValue.value) newTransform.value = -(tabOffset.left + tabOffset.width - visibleTabContentValue.value);
+				transformTop.value = 0;
+				transformLeft.value = alignInRange(newTransform.value);
+			} else {
+				const newTransform = transformTop;
+				if (tabOffset.top < -transformTop.value) newTransform.value = -tabOffset.top;
+				else if (tabOffset.top + tabOffset.height > -transformTop.value + visibleTabContentValue.value) newTransform.value = -(tabOffset.top + tabOffset.height - visibleTabContentValue.value);
+				transformLeft.value = 0;
+				transformTop.value = alignInRange(newTransform.value);
+			}
+		}
+		const focusKey = (0, vue.ref)();
+		const isMouse = (0, vue.ref)(false);
+		const enabledTabs = (0, vue.computed)(() => tabs.value.filter((tab) => !tab.disabled).map((tab) => tab.key));
+		function onOffset(offset) {
+			const enabledKeys = getEnabledKeys(tabs.value);
+			const currentIndex = enabledKeys.indexOf(focusKey.value || activeKey.value);
+			const len = enabledKeys.length;
+			focusKey.value = enabledKeys[(currentIndex + offset + len) % len];
+		}
+		function handleRemoveTab(removalKey, e) {
+			if (!removalKey) return;
+			const removeTab = tabs.value.find((t) => t.key === removalKey);
+			if (removeTab && !removeTab.disabled && (removeTab.closable || editable.value)) {
+				e.preventDefault();
+				e.stopPropagation();
+				editable.value?.onEdit("remove", {
+					key: removalKey,
+					event: e
+				});
+				const enabledKeys = getEnabledKeys(tabs.value);
+				if (enabledKeys.indexOf(removalKey) === enabledKeys.length - 1) onOffset(-1);
+				else onOffset(1);
+			}
+		}
+		function handleMouseDown(key, e) {
+			isMouse.value = true;
+			if (e.button === 1) handleRemoveTab(key, e);
+		}
+		function handleKeyDown(e) {
+			const { code } = e;
+			const isRTL = rtl.value && tabPositionTopOrBottom.value;
+			const firstEnabledTab = enabledTabs.value[0];
+			const lastEnabledTab = enabledTabs.value[enabledTabs.value.length - 1];
+			switch (code) {
+				case "ArrowLeft":
+					if (tabPositionTopOrBottom.value) onOffset(isRTL ? 1 : -1);
+					break;
+				case "ArrowRight":
+					if (tabPositionTopOrBottom.value) onOffset(isRTL ? -1 : 1);
+					break;
+				case "ArrowUp":
+					e.preventDefault();
+					if (!tabPositionTopOrBottom.value) onOffset(-1);
+					break;
+				case "ArrowDown":
+					e.preventDefault();
+					if (!tabPositionTopOrBottom.value) onOffset(1);
+					break;
+				case "Home":
+					e.preventDefault();
+					focusKey.value = firstEnabledTab;
+					break;
+				case "End":
+					e.preventDefault();
+					focusKey.value = lastEnabledTab;
+					break;
+				case "Enter":
+				case "Space":
+					e.preventDefault();
+					props.onTabClick?.(focusKey.value ?? activeKey.value, e);
+					break;
+				case "Backspace":
+				case "Delete":
+					handleRemoveTab(focusKey.value, e);
+					break;
+			}
+		}
+		const isHorizontal = (0, vue.computed)(() => tabPositionTopOrBottom.value);
+		const navClass = (0, vue.computed)(() => [
+			`${prefixCls.value}-nav`,
+			className.value,
+			tabsClassNames.value?.header
+		]);
+		const navStyle = (0, vue.computed)(() => ({
+			...styles.value?.header || {},
+			...style.value || {}
+		}));
+		const navListClass = (0, vue.computed)(() => `${prefixCls.value}-nav-list`);
+		function onItemClick(key, e) {
+			onTabClick.value?.(key, e);
+		}
+		function getEnabledKeys(list) {
+			return list.filter((t) => !t.disabled).map((t) => t.key);
+		}
+		function onItemBlur() {
+			focusKey.value = void 0;
+		}
+		function onTabFocus(key) {
+			if (!isMouse.value) focusKey.value = key;
+			scrollToTab(key);
+			doLockAnimation();
+			const wrap = tabsWrapperRef.value;
+			if (!wrap) return;
+			if (!rtl.value) wrap.scrollLeft = 0;
+			wrap.scrollTop = 0;
+		}
+		const inkStyle = require_useIndicator.default({
+			activeTabOffset: (0, vue.computed)(() => tabOffsets.value.get(activeKey.value)),
+			horizontal: isHorizontal,
+			indicator,
+			rtl
+		});
+		function getTabSize(tab, containerRect) {
+			const { offsetWidth, offsetHeight, offsetTop, offsetLeft } = tab;
+			const { width, height, left, top } = tab.getBoundingClientRect();
+			if (Math.abs(width - offsetWidth) < 1) return [
+				width,
+				height,
+				left - containerRect.left,
+				top - containerRect.top
+			];
+			return [
+				offsetWidth,
+				offsetHeight,
+				offsetLeft,
+				offsetTop
+			];
+		}
+		function getSize(refObj) {
+			const el = refObj.value;
+			const { offsetWidth = 0, offsetHeight = 0 } = el || {};
+			if (el) {
+				const { width, height } = el.getBoundingClientRect();
+				if (Math.abs(width - offsetWidth) < 1) return [width, height];
+			}
+			return [offsetWidth, offsetHeight];
+		}
+		function updateTabSizes() {
+			tabSizes.value = (() => {
+				const newSizes = /* @__PURE__ */ new Map();
+				const listRect = tabListRef.value?.getBoundingClientRect?.();
+				tabs.value.forEach(({ key }) => {
+					const btnNode = tabListRef.value?.querySelector?.(`[data-node-key="${require_utils.genDataNodeKey(key)}"]`);
+					if (btnNode && listRect) {
+						const [width, height, left, top] = getTabSize(btnNode, listRect);
+						newSizes.set(key, {
+							width,
+							height,
+							left,
+							top
+						});
+					}
+				});
+				return newSizes;
+			})();
+		}
+		function onListHolderResize() {
+			const containerSize = getSize(containerRef);
+			const extraLeftEl = extraLeftRef.value?.extraContentRef;
+			const extraRightEl = extraRightRef.value?.extraContentRef;
+			const extraLeftSize = extraLeftEl ? getSize({ value: extraLeftEl }) : [0, 0];
+			const extraRightSize = extraRightEl ? getSize({ value: extraRightEl }) : [0, 0];
+			containerExcludeExtraSize.value = [containerSize[0] - extraLeftSize[0] - extraRightSize[0], containerSize[1] - extraLeftSize[1] - extraRightSize[1]];
+			const opEl = operationsRef.value?.operationNodeRef;
+			operationSize.value = opEl ? getSize({ value: opEl }) : [0, 0];
+			const tabListEl = tabListRef.value;
+			const tabContentFullSize = tabListEl ? getSize({ value: tabListEl }) : [0, 0];
+			const addEl = innerAddButtonRef.value?.buttonRef;
+			addSize.value = addEl ? getSize({ value: addEl }) : [0, 0];
+			tabContentSize.value = [tabContentFullSize[0] - addSize.value[0], tabContentFullSize[1] - addSize.value[1]];
+			updateTabSizes();
+		}
+		(0, vue.watch)(() => tabs.value.map((t) => t.key).join("_"), () => {
+			(0, vue.nextTick)(() => {
+				updateTabSizes();
+			});
+		});
+		(0, vue.watch)([
+			activeKey,
+			() => transformComputed.value.transformMin,
+			() => transformComputed.value.transformMax,
+			visibleTabContentValue,
+			tabOffsets
+		], () => {
+			scrollToTab();
+		});
+		(0, vue.watch)(rtl, () => {
+			onListHolderResize();
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(__v_c_resize_observer.default), { onResize: onListHolderResize }, {
+				default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", {
+					ref_key: "containerRef",
+					ref: containerRef,
+					class: (0, vue.normalizeClass)(navClass.value),
+					style: (0, vue.normalizeStyle)(navStyle.value),
+					role: "tablist",
+					"aria-orientation": isHorizontal.value ? "horizontal" : "vertical",
+					onKeydown: _cache[0] || (_cache[0] = () => {
+						doLockAnimation();
+					})
+				}, [
+					(0, vue.createVNode)(require_ExtraContent.default, {
+						ref_key: "extraLeftRef",
+						ref: extraLeftRef,
+						position: "left",
+						"prefix-cls": prefixCls.value,
+						extra: (0, vue.unref)(extra)
+					}, null, 8, ["prefix-cls", "extra"]),
+					(0, vue.createVNode)((0, vue.unref)(__v_c_resize_observer.default), { onResize: onListHolderResize }, {
+						default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", {
+							ref_key: "tabsWrapperRef",
+							ref: tabsWrapperRef,
+							class: (0, vue.normalizeClass)([wrapPrefix.value, {
+								[`${wrapPrefix.value}-ping-left`]: pingLeft.value,
+								[`${wrapPrefix.value}-ping-right`]: pingRight.value,
+								[`${wrapPrefix.value}-ping-top`]: pingTop.value,
+								[`${wrapPrefix.value}-ping-bottom`]: pingBottom.value
+							}])
+						}, [(0, vue.createVNode)((0, vue.unref)(__v_c_resize_observer.default), { onResize: onListHolderResize }, {
+							default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("div", {
+								ref_key: "tabListRef",
+								ref: tabListRef,
+								class: (0, vue.normalizeClass)(navListClass.value),
+								style: (0, vue.normalizeStyle)({
+									transform: `translate(${transformLeft.value}px, ${transformTop.value}px)`,
+									transition: lockAnimation.value ? "none" : void 0
+								})
+							}, [
+								(0, vue.createVNode)((0, vue.unref)(__v_c_util_dist_RenderComponent.default), { render: tabs.value.map((tab, i) => (0, vue.h)(require_TabNode.default, {
+									id: (0, vue.unref)(id),
+									prefixCls: prefixCls.value,
+									key: tab.key,
+									tab,
+									className: (0, vue.unref)(tabsClassNames)?.item,
+									style: i === 0 ? (0, vue.unref)(styles)?.item : {
+										...isHorizontal.value ? { marginInlineStart: tabBarGutter.value } : { marginTop: tabBarGutter.value },
+										...(0, vue.unref)(styles)?.item || {}
+									},
+									closable: tab.closable,
+									editable: (0, vue.unref)(editable),
+									active: tab.key === (0, vue.unref)(activeKey),
+									focus: tab.key === focusKey.value,
+									renderWrapper: (0, vue.unref)(children),
+									removeAriaLabel: (0, vue.unref)(locale)?.removeAriaLabel,
+									tabCount: tabs.value.filter((t) => !t.disabled).length,
+									currentPosition: i + 1,
+									onClick: (e) => onItemClick(tab.key, e),
+									onKeyDown: handleKeyDown,
+									onFocus: () => onTabFocus(tab.key),
+									onBlur: () => onItemBlur(),
+									onMouseDown: (e) => handleMouseDown(tab.key, e),
+									onMouseUp: () => {
+										isMouse.value = false;
+									}
+								})) }, null, 8, ["render"]),
+								(0, vue.createVNode)(require_AddButton.default, {
+									ref_key: "innerAddButtonRef",
+									ref: innerAddButtonRef,
+									"prefix-cls": prefixCls.value,
+									locale: (0, vue.unref)(locale),
+									editable: (0, vue.unref)(editable),
+									style: (0, vue.normalizeStyle)({
+										...tabs.value.length === 0 ? {} : isHorizontal.value ? { marginInlineStart: tabBarGutter.value } : { marginTop: tabBarGutter.value },
+										visibility: hasDropdown.value ? "hidden" : null
+									})
+								}, null, 8, [
+									"prefix-cls",
+									"locale",
+									"editable",
+									"style"
+								]),
+								(0, vue.createElementVNode)("div", {
+									class: (0, vue.normalizeClass)([
+										`${prefixCls.value}-ink-bar`,
+										(0, vue.unref)(tabsClassNames)?.indicator,
+										{ [`${prefixCls.value}-ink-bar-animated`]: (0, vue.unref)(animated)?.inkBar }
+									]),
+									style: (0, vue.normalizeStyle)({
+										...(0, vue.unref)(styles)?.indicator || {},
+										...(0, vue.unref)(inkStyle)
+									})
+								}, null, 6)
+							], 6)]),
+							_: 1
+						})], 2)]),
+						_: 1
+					}),
+					(0, vue.createVNode)(require_OperationNode.default, (0, vue.mergeProps)({
+						ref_key: "operationsRef",
+						ref: operationsRef,
+						"remove-aria-label": (0, vue.unref)(locale)?.removeAriaLabel,
+						"prefix-cls": prefixCls.value,
+						tabs: hiddenTabs.value,
+						"class-name": [(0, vue.unref)(tabsClassNames)?.operations, !hasDropdown.value ? operationsHiddenClassName.value : void 0],
+						"popup-style": (0, vue.unref)(styles)?.popup,
+						"tab-moving": !!lockAnimation.value
+					}, {
+						id: (0, vue.unref)(id),
+						rtl: (0, vue.unref)(rtl),
+						tabBarGutter: (0, vue.unref)(tabBarGutterProp),
+						activeKey: (0, vue.unref)(activeKey),
+						mobile: (0, vue.unref)(mobile),
+						more: (0, vue.unref)(more),
+						editable: (0, vue.unref)(editable),
+						locale: (0, vue.unref)(locale),
+						onTabClick: (0, vue.unref)(onTabClick),
+						getPopupContainer: (0, vue.unref)(getPopupContainer),
+						popupClassName: (0, vue.unref)(popupClassName)
+					}), null, 16, [
+						"remove-aria-label",
+						"prefix-cls",
+						"tabs",
+						"class-name",
+						"popup-style",
+						"tab-moving"
+					]),
+					(0, vue.createVNode)(require_ExtraContent.default, {
+						ref_key: "extraRightRef",
+						ref: extraRightRef,
+						position: "right",
+						"prefix-cls": prefixCls.value,
+						extra: (0, vue.unref)(extra)
+					}, null, 8, ["prefix-cls", "extra"]),
+					(0, vue.createVNode)((0, vue.unref)(__v_c_util_dist_RenderComponent.default), { render: (0, vue.unref)(children) }, null, 8, ["render"])
+				], 46, _hoisted_1)]),
+				_: 1
+			});
+		};
+	}
+});
+exports.default = index_vue_vue_type_script_setup_true_lang_default;