@youcan/celeste 0.6.101 → 0.7.0

package/dist/es/chunks/tooltip-trigger.js

@@ -1,17 +1,122 @@
-import { O as Ot, bt as jg } from "./dist.js";
-import { createBlock, defineComponent, mergeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+import { t as Primitive } from "./Primitive.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { t as useForwardProps } from "./useForwardProps.js";
+import { t as useId } from "./useId.js";
+import { t as PopperAnchor_default } from "./PopperAnchor.js";
+import { n as injectTooltipProviderContext } from "./TooltipProvider.js";
+import { n as injectTooltipRootContext } from "./TooltipRoot.js";
+import { computed, createBlock, createVNode, defineComponent, mergeProps, onMounted, openBlock, ref, renderSlot, toHandlers, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tooltip/TooltipTrigger.js
+var TooltipTrigger_default = /* @__PURE__ */ defineComponent({
+	__name: "TooltipTrigger",
+	props: {
+		reference: {
+			type: null,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "button"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = injectTooltipRootContext();
+		const providerContext = injectTooltipProviderContext();
+		rootContext.contentId ||= useId(void 0, "reka-tooltip-content");
+		const { forwardRef, currentElement: triggerElement } = useForwardExpose();
+		const isPointerDown = ref(false);
+		const hasPointerMoveOpened = ref(false);
+		const tooltipListeners = computed(() => {
+			if (rootContext.disabled.value) return {};
+			return {
+				click: handleClick,
+				focus: handleFocus,
+				pointermove: handlePointerMove,
+				pointerleave: handlePointerLeave,
+				pointerdown: handlePointerDown,
+				blur: handleBlur
+			};
+		});
+		onMounted(() => {
+			rootContext.onTriggerChange(triggerElement.value);
+		});
+		function handlePointerUp() {
+			setTimeout(() => {
+				isPointerDown.value = false;
+			}, 1);
+		}
+		function handlePointerDown() {
+			if (rootContext.open && !rootContext.disableClosingTrigger.value) rootContext.onClose();
+			isPointerDown.value = true;
+			document.addEventListener("pointerup", handlePointerUp, { once: true });
+		}
+		function handlePointerMove(event) {
+			if (event.pointerType === "touch") return;
+			if (!hasPointerMoveOpened.value && !providerContext.isPointerInTransitRef.value) {
+				rootContext.onTriggerEnter();
+				hasPointerMoveOpened.value = true;
+			}
+		}
+		function handlePointerLeave() {
+			rootContext.onTriggerLeave();
+			hasPointerMoveOpened.value = false;
+		}
+		function handleFocus(event) {
+			if (isPointerDown.value) return;
+			if (rootContext.ignoreNonKeyboardFocus.value && !event.target.matches?.(":focus-visible")) return;
+			rootContext.onOpen();
+		}
+		function handleBlur() {
+			rootContext.onClose();
+		}
+		function handleClick() {
+			if (!rootContext.disableClosingTrigger.value) rootContext.onClose();
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(PopperAnchor_default), {
+				"as-child": "",
+				reference: _ctx.reference
+			}, {
+				default: withCtx(() => [createVNode(unref(Primitive), mergeProps({
+					ref: unref(forwardRef),
+					"aria-describedby": unref(rootContext).open.value ? unref(rootContext).contentId : void 0,
+					"data-state": unref(rootContext).stateAttribute.value,
+					as: _ctx.as,
+					"as-child": props.asChild,
+					"data-grace-area-trigger": ""
+				}, toHandlers(tooltipListeners.value)), {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+					_: 3
+				}, 16, [
+					"aria-describedby",
+					"data-state",
+					"as",
+					"as-child"
+				])]),
+				_: 3
+			}, 8, ["reference"]);
+		};
+	}
+});
 //#endregion
 //#region src/components/tooltip/tooltip-trigger.vue
 var tooltip_trigger_default = /* @__PURE__ */ defineComponent({
 	__name: "tooltip-trigger",
 	props: {
+		reference: {},
 		asChild: { type: Boolean },
 		as: {}
 	},
 	setup(__props) {
-		const forwardedProps = Ot(__props);
+		const forwardedProps = useForwardProps(__props);
 		return (_ctx, _cache) => {
-			return openBlock(), createBlock(unref(jg), mergeProps(unref(forwardedProps), { "as-child": "" }), {
+			return openBlock(), createBlock(unref(TooltipTrigger_default), mergeProps(unref(forwardedProps), { "as-child": "" }), {
 				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
 				_: 3
 			}, 16);

package/dist/es/chunks/tooltip.js

@@ -1,9 +1,9 @@
-import { I as Se } from "./dist.js";
-import { useDelegatedProps } from "../use-delegated-props.js";
+import { t as useForwardPropsEmits } from "./useForwardPropsEmits.js";
 import { t as tooltip_content_default } from "./tooltip-content.js";
+import { t as tooltip_trigger_default } from "./tooltip-trigger.js";
+import { useDelegatedProps } from "../use-delegated-props.js";
 import { t as tooltip_provider_default } from "./tooltip-provider.js";
 import { t as tooltip_root_default } from "./tooltip-root.js";
-import { t as tooltip_trigger_default } from "./tooltip-trigger.js";
 import { createBlock, createVNode, defineComponent, mergeProps, openBlock, ref, renderSlot, unref, withCtx } from "vue";
 //#endregion
 //#region src/components/tooltip/tooltip.vue
@@ -37,13 +37,15 @@ var tooltip_default = /* @__PURE__ */ defineComponent({
 		collisionPadding: {},
 		arrowPadding: {},
 		sticky: {},
-		hideWhenDetached: { type: Boolean }
+		hideWhenDetached: { type: Boolean },
+		positionStrategy: {},
+		updatePositionStrategy: {}
 	},
 	emits: ["update:open"],
 	setup(__props, { emit: __emit }) {
 		const props = __props;
 		const emits = __emit;
-		const forwarded = Se(useDelegatedProps(props, [
+		const forwarded = useForwardPropsEmits(useDelegatedProps(props, [
 			"class",
 			"size",
 			"variant",

package/dist/es/chunks/useArrowNavigation.js

@@ -0,0 +1,60 @@
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useArrowNavigation.js
+var ignoredElement = ["INPUT", "TEXTAREA"];
+/**
+* Allow arrow navigation for every html element with data-reka-collection-item tag
+*
+* @param e               Keyboard event
+* @param currentElement  Event initiator element or any element that wants to handle the navigation
+* @param parentElement   Parent element where contains all the collection items, this will collect every item to be used when nav
+* @param options         further options
+* @returns               the navigated html element or null if none
+*/
+function useArrowNavigation(e, currentElement, parentElement, options = {}) {
+	if (!currentElement || options.enableIgnoredElement && ignoredElement.includes(currentElement.nodeName)) return null;
+	const { arrowKeyOptions = "both", attributeName = "[data-reka-collection-item]", itemsArray = [], loop = true, dir = "ltr", preventScroll = true, focus = false } = options;
+	const [right, left, up, down, home, end] = [
+		e.key === "ArrowRight",
+		e.key === "ArrowLeft",
+		e.key === "ArrowUp",
+		e.key === "ArrowDown",
+		e.key === "Home",
+		e.key === "End"
+	];
+	const goingVertical = up || down;
+	const goingHorizontal = right || left;
+	if (!home && !end && (!goingVertical && !goingHorizontal || arrowKeyOptions === "vertical" && goingHorizontal || arrowKeyOptions === "horizontal" && goingVertical)) return null;
+	const allCollectionItems = parentElement ? Array.from(parentElement.querySelectorAll(attributeName)) : itemsArray;
+	if (!allCollectionItems.length) return null;
+	if (preventScroll) e.preventDefault();
+	let item = null;
+	if (goingHorizontal || goingVertical) item = findNextFocusableElement(allCollectionItems, currentElement, {
+		goForward: goingVertical ? down : dir === "ltr" ? right : left,
+		loop
+	});
+	else if (home) item = allCollectionItems.at(0) || null;
+	else if (end) item = allCollectionItems.at(-1) || null;
+	if (focus) item?.focus();
+	return item;
+}
+/**
+* Recursive function to find the next focusable element to avoid disabled elements
+*
+* @param elements Elements to navigate
+* @param currentElement Current active element
+* @param options
+* @returns next focusable element
+*/
+function findNextFocusableElement(elements, currentElement, options, iterations = !elements.includes(currentElement) ? elements.length + 1 : elements.length) {
+	if (--iterations === 0) return null;
+	const index = elements.indexOf(currentElement);
+	let newIndex;
+	if (index === -1) newIndex = options.goForward ? 0 : elements.length - 1;
+	else newIndex = options.goForward ? index + 1 : index - 1;
+	if (!options.loop && (newIndex < 0 || newIndex >= elements.length)) return null;
+	const candidate = elements[(newIndex + elements.length) % elements.length];
+	if (!candidate) return null;
+	if (candidate.hasAttribute("disabled") && candidate.getAttribute("disabled") !== "false") return findNextFocusableElement(elements, candidate, options, iterations);
+	return candidate;
+}
+//#endregion
+export { useArrowNavigation as t };

package/dist/es/chunks/useComposing.js

@@ -0,0 +1,21 @@
+import { nextTick, ref } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useComposing.js
+function useComposing(onEnd) {
+	const isComposing = ref(false);
+	function handleCompositionStart() {
+		isComposing.value = true;
+	}
+	function handleCompositionEnd(event) {
+		nextTick(() => {
+			isComposing.value = false;
+			onEnd?.(event);
+		});
+	}
+	return {
+		isComposing,
+		handleCompositionStart,
+		handleCompositionEnd
+	};
+}
+//#endregion
+export { useComposing as t };

package/dist/es/chunks/useDirection.js

@@ -0,0 +1,14 @@
+import { t as injectConfigProviderContext } from "./ConfigProvider.js";
+import { computed, ref } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useDirection.js
+/**
+* The `useDirection` function provides a way to access the current direction in your application.
+* @param {Ref<Direction | undefined>} [dir] - An optional ref containing the direction (ltr or rtl).
+* @returns  computed value that combines with the resolved direction.
+*/
+function useDirection(dir) {
+	const context = injectConfigProviderContext({ dir: ref("ltr") });
+	return computed(() => dir?.value || context.dir?.value || "ltr");
+}
+//#endregion
+export { useDirection as t };

package/dist/es/chunks/useEmitAsProps.js

@@ -0,0 +1,28 @@
+import { camelize, getCurrentInstance, toHandlerKey } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useEmitAsProps.js
+/**
+* The `useEmitAsProps` function is a TypeScript utility that converts emitted events into props for a
+* Vue component.
+*
+* @template Name - The event name string union type.
+* @template Fn - The emit function type.
+*
+* @param emit - The `emit` parameter is a function that is used to emit events from a component. It
+*
+* takes two parameters: `name` which is the name of the event to be emitted, and `...args` which are
+* the arguments to be passed along with the event.
+* @returns The function `useEmitAsProps` returns an object that maps event names to functions that
+* call the `emit` function with the corresponding event name and arguments.
+*/
+function useEmitAsProps(emit) {
+	const vm = getCurrentInstance();
+	const events = vm?.type.emits;
+	const result = {};
+	if (!events?.length) console.warn(`No emitted event found. Please check component: ${vm?.type.__name}`);
+	events?.forEach((ev) => {
+		result[toHandlerKey(camelize(ev))] = (...arg) => emit(ev, ...arg);
+	});
+	return result;
+}
+//#endregion
+export { useEmitAsProps as t };

package/dist/es/chunks/useFocusGuards.js

@@ -0,0 +1,34 @@
+import { d as isClient } from "./dist.js";
+import { watchEffect } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useFocusGuards.js
+/** Number of components which have requested interest to have focus guards */
+var count = 0;
+/**
+* Injects a pair of focus guards at the edges of the whole DOM tree
+* to ensure `focusin` & `focusout` events can be caught consistently.
+*/
+function useFocusGuards() {
+	watchEffect((cleanupFn) => {
+		if (!isClient) return;
+		const edgeGuards = document.querySelectorAll("[data-reka-focus-guard]");
+		document.body.insertAdjacentElement("afterbegin", edgeGuards[0] ?? createFocusGuard());
+		document.body.insertAdjacentElement("beforeend", edgeGuards[1] ?? createFocusGuard());
+		count++;
+		cleanupFn(() => {
+			if (count === 1) document.querySelectorAll("[data-reka-focus-guard]").forEach((node) => node.remove());
+			count--;
+		});
+	});
+}
+function createFocusGuard() {
+	const element = document.createElement("span");
+	element.setAttribute("data-reka-focus-guard", "");
+	element.tabIndex = 0;
+	element.style.outline = "none";
+	element.style.opacity = "0";
+	element.style.position = "fixed";
+	element.style.pointerEvents = "none";
+	return element;
+}
+//#endregion
+export { useFocusGuards as t };

package/dist/es/chunks/useFormControl.js

@@ -0,0 +1,8 @@
+import { r as unrefElement } from "./dist.js";
+import { computed, toValue } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useFormControl.js
+function useFormControl(el) {
+	return computed(() => toValue(el) ? Boolean(unrefElement(el)?.closest("form")) : true);
+}
+//#endregion
+export { useFormControl as t };

package/dist/es/chunks/useForwardExpose.js

@@ -0,0 +1,58 @@
+import { r as unrefElement } from "./dist.js";
+import { computed, getCurrentInstance, onUpdated, ref, triggerRef } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useForwardExpose.js
+function useForwardExpose() {
+	const instance = getCurrentInstance();
+	const currentRef = ref();
+	const currentElement = computed(() => resolveCurrentElement());
+	onUpdated(() => {
+		if (currentElement.value !== resolveCurrentElement()) triggerRef(currentRef);
+	});
+	function resolveCurrentElement() {
+		return currentRef.value && "$el" in currentRef.value && ["#text", "#comment"].includes(currentRef.value.$el.nodeName) ? currentRef.value.$el.nextElementSibling : unrefElement(currentRef);
+	}
+	const localExpose = Object.assign({}, instance.exposed);
+	const ret = {};
+	for (const key in instance.props) Object.defineProperty(ret, key, {
+		enumerable: true,
+		configurable: true,
+		get: () => instance.props[key]
+	});
+	if (Object.keys(localExpose).length > 0) for (const key in localExpose) Object.defineProperty(ret, key, {
+		enumerable: true,
+		configurable: true,
+		get: () => localExpose[key]
+	});
+	Object.defineProperty(ret, "$el", {
+		enumerable: true,
+		configurable: true,
+		get: () => instance.vnode.el
+	});
+	instance.exposed = ret;
+	function forwardRef(ref$1) {
+		currentRef.value = ref$1;
+		if (!ref$1) return;
+		Object.defineProperty(ret, "$el", {
+			enumerable: true,
+			configurable: true,
+			get: () => ref$1 instanceof Element ? ref$1 : ref$1.$el
+		});
+		if (!(ref$1 instanceof Element) && !Object.hasOwn(ref$1, "$el")) {
+			const childExposed = ref$1.$.exposed;
+			const merged = Object.assign({}, ret);
+			for (const key in childExposed) Object.defineProperty(merged, key, {
+				enumerable: true,
+				configurable: true,
+				get: () => childExposed[key]
+			});
+			instance.exposed = merged;
+		}
+	}
+	return {
+		forwardRef,
+		currentRef,
+		currentElement
+	};
+}
+//#endregion
+export { useForwardExpose as t };

package/dist/es/chunks/useForwardProps.js

@@ -0,0 +1,34 @@
+import { camelize, computed, getCurrentInstance, toRef } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useForwardProps.js
+/**
+* The `useForwardProps` function in TypeScript takes in a set of props and returns a computed value
+* that combines default props with assigned props from the current instance.
+* @param {T} props - The `props` parameter is an object that represents the props passed to a
+* component.
+* @returns computed value that combines the default props, preserved props, and assigned props.
+*/
+function useForwardProps(props) {
+	const vm = getCurrentInstance();
+	const defaultProps = Object.keys(vm?.type.props ?? {}).reduce((prev, curr) => {
+		const defaultValue = (vm?.type.props[curr]).default;
+		if (defaultValue !== void 0) prev[curr] = defaultValue;
+		return prev;
+	}, {});
+	const refProps = toRef(props);
+	return computed(() => {
+		const preservedProps = {};
+		const assignedProps = vm?.vnode.props ?? {};
+		Object.keys(assignedProps).forEach((key) => {
+			preservedProps[camelize(key)] = assignedProps[key];
+		});
+		return Object.keys({
+			...defaultProps,
+			...preservedProps
+		}).reduce((prev, curr) => {
+			if (refProps.value[curr] !== void 0) prev[curr] = refProps.value[curr];
+			return prev;
+		}, {});
+	});
+}
+//#endregion
+export { useForwardProps as t };

package/dist/es/chunks/useForwardPropsEmits.js

@@ -0,0 +1,14 @@
+import { t as useEmitAsProps } from "./useEmitAsProps.js";
+import { t as useForwardProps } from "./useForwardProps.js";
+import { computed } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useForwardPropsEmits.js
+function useForwardPropsEmits(props, emit) {
+	const parsedProps = useForwardProps(props);
+	const emitsAsProps = emit ? useEmitAsProps(emit) : {};
+	return computed(() => ({
+		...parsedProps.value,
+		...emitsAsProps
+	}));
+}
+//#endregion
+export { useForwardPropsEmits as t };

package/dist/es/chunks/useForwardScopeId.js

@@ -0,0 +1,25 @@
+import { getCurrentInstance } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useForwardScopeId.js
+/**
+* Returns the parent component's `<style scoped>` id (e.g. `data-v-xxxxxxx`) as a
+* bindable attribute object, so it can be manually forwarded onto the chosen root
+* element of a multi-root component.
+*
+* Vue only auto-applies the parent's scope id to a **single-root** component's root.
+* When a component renders multiple root nodes (e.g. an interactive control plus a
+* sibling hidden form input), that fallthrough is dropped and the parent's scoped
+* styles can no longer reach the component. Spread the returned object onto the
+* element that should stay styleable by the parent.
+*
+* @example
+* ```ts
+* const scopeIdAttrs = useForwardScopeId()
+* // <Primitive v-bind="{ ...$attrs, ...scopeIdAttrs }" />
+* ```
+*/
+function useForwardScopeId() {
+	const scopeId = (getCurrentInstance()?.vnode)?.scopeId;
+	return scopeId ? { [scopeId]: "" } : {};
+}
+//#endregion
+export { useForwardScopeId as t };

package/dist/es/chunks/useHideOthers.js

@@ -0,0 +1,132 @@
+import { r as unrefElement } from "./dist.js";
+import { onUnmounted, watch } from "vue";
+//#region ../../node_modules/.pnpm/aria-hidden@1.2.4/node_modules/aria-hidden/dist/es2015/index.js
+var getDefaultParent = function(originalTarget) {
+	if (typeof document === "undefined") return null;
+	return (Array.isArray(originalTarget) ? originalTarget[0] : originalTarget).ownerDocument.body;
+};
+var counterMap = /* @__PURE__ */ new WeakMap();
+var uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+var markerMap = {};
+var lockCount = 0;
+var unwrapHost = function(node) {
+	return node && (node.host || unwrapHost(node.parentNode));
+};
+var correctTargets = function(parent, targets) {
+	return targets.map(function(target) {
+		if (parent.contains(target)) return target;
+		var correctedTarget = unwrapHost(target);
+		if (correctedTarget && parent.contains(correctedTarget)) return correctedTarget;
+		console.error("aria-hidden", target, "in not contained inside", parent, ". Doing nothing");
+		return null;
+	}).filter(function(x) {
+		return Boolean(x);
+	});
+};
+/**
+* Marks everything except given node(or nodes) as aria-hidden
+* @param {Element | Element[]} originalTarget - elements to keep on the page
+* @param [parentNode] - top element, defaults to document.body
+* @param {String} [markerName] - a special attribute to mark every node
+* @param {String} [controlAttribute] - html Attribute to control
+* @return {Undo} undo command
+*/
+var applyAttributeToOthers = function(originalTarget, parentNode, markerName, controlAttribute) {
+	var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
+	if (!markerMap[markerName]) markerMap[markerName] = /* @__PURE__ */ new WeakMap();
+	var markerCounter = markerMap[markerName];
+	var hiddenNodes = [];
+	var elementsToKeep = /* @__PURE__ */ new Set();
+	var elementsToStop = new Set(targets);
+	var keep = function(el) {
+		if (!el || elementsToKeep.has(el)) return;
+		elementsToKeep.add(el);
+		keep(el.parentNode);
+	};
+	targets.forEach(keep);
+	var deep = function(parent) {
+		if (!parent || elementsToStop.has(parent)) return;
+		Array.prototype.forEach.call(parent.children, function(node) {
+			if (elementsToKeep.has(node)) deep(node);
+			else try {
+				var attr = node.getAttribute(controlAttribute);
+				var alreadyHidden = attr !== null && attr !== "false";
+				var counterValue = (counterMap.get(node) || 0) + 1;
+				var markerValue = (markerCounter.get(node) || 0) + 1;
+				counterMap.set(node, counterValue);
+				markerCounter.set(node, markerValue);
+				hiddenNodes.push(node);
+				if (counterValue === 1 && alreadyHidden) uncontrolledNodes.set(node, true);
+				if (markerValue === 1) node.setAttribute(markerName, "true");
+				if (!alreadyHidden) node.setAttribute(controlAttribute, "true");
+			} catch (e) {
+				console.error("aria-hidden: cannot operate on ", node, e);
+			}
+		});
+	};
+	deep(parentNode);
+	elementsToKeep.clear();
+	lockCount++;
+	return function() {
+		hiddenNodes.forEach(function(node) {
+			var counterValue = counterMap.get(node) - 1;
+			var markerValue = markerCounter.get(node) - 1;
+			counterMap.set(node, counterValue);
+			markerCounter.set(node, markerValue);
+			if (!counterValue) {
+				if (!uncontrolledNodes.has(node)) node.removeAttribute(controlAttribute);
+				uncontrolledNodes.delete(node);
+			}
+			if (!markerValue) node.removeAttribute(markerName);
+		});
+		lockCount--;
+		if (!lockCount) {
+			counterMap = /* @__PURE__ */ new WeakMap();
+			counterMap = /* @__PURE__ */ new WeakMap();
+			uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+			markerMap = {};
+		}
+	};
+};
+/**
+* Marks everything except given node(or nodes) as aria-hidden
+* @param {Element | Element[]} originalTarget - elements to keep on the page
+* @param [parentNode] - top element, defaults to document.body
+* @param {String} [markerName] - a special attribute to mark every node
+* @return {Undo} undo command
+*/
+var hideOthers = function(originalTarget, parentNode, markerName) {
+	if (markerName === void 0) markerName = "data-aria-hidden";
+	var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
+	var activeParentNode = parentNode || getDefaultParent(originalTarget);
+	if (!activeParentNode) return function() {
+		return null;
+	};
+	targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll("[aria-live]")));
+	return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden");
+};
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useHideOthers.js
+/**
+* The `useHideOthers` function is a TypeScript function that takes a target element reference and
+* hides all other elements in ARIA when the target element is present, and restores the visibility of the
+* hidden elements when the target element is removed.
+* @param {MaybeElementRef} target - The `target` parameter is a reference to the element that you want
+* to hide other elements when it is clicked or focused.
+*/
+function useHideOthers(target) {
+	let undo;
+	watch(() => unrefElement(target), (el) => {
+		let isInsideClosedPopover = false;
+		try {
+			isInsideClosedPopover = !!el?.closest("[popover]:not(:popover-open)");
+		} catch {}
+		if (el && !isInsideClosedPopover) undo = hideOthers(el);
+		else if (undo) undo();
+	});
+	onUnmounted(() => {
+		if (undo) undo();
+	});
+}
+//#endregion
+export { useHideOthers as t };

package/dist/es/chunks/useId.js

@@ -0,0 +1,23 @@
+import { t as injectConfigProviderContext } from "./ConfigProvider.js";
+import * as vue from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useId.js
+var count = 0;
+/**
+* The `useId` function generates a unique identifier using a provided deterministic ID,
+* a configured `<ConfigProvider>` ID source, Vue's native `useId`, or a fallback counter.
+* @param {string | null | undefined} [deterministicId] - The `useId` function you provided takes an
+* optional parameter `deterministicId`, which can be a string, null, or undefined. If
+* `deterministicId` is provided, the function will return it. Otherwise, it will generate an id using
+* the configured ID source.
+*/
+function useId(deterministicId, prefix = "reka") {
+	if (deterministicId) return deterministicId;
+	let id;
+	const configProviderContext = injectConfigProviderContext({ useId: void 0 });
+	if (configProviderContext.useId) id = configProviderContext.useId();
+	else if ("useId" in vue) id = vue.useId?.();
+	else id = `${++count}`;
+	return prefix ? `${prefix}-${id}` : id;
+}
+//#endregion
+export { useId as t };

package/dist/es/chunks/useKbd.js

@@ -0,0 +1,41 @@
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useKbd.js
+function useKbd() {
+	return {
+		ALT: "Alt",
+		ARROW_DOWN: "ArrowDown",
+		ARROW_LEFT: "ArrowLeft",
+		ARROW_RIGHT: "ArrowRight",
+		ARROW_UP: "ArrowUp",
+		BACKSPACE: "Backspace",
+		CAPS_LOCK: "CapsLock",
+		CONTROL: "Control",
+		DELETE: "Delete",
+		END: "End",
+		ENTER: "Enter",
+		ESCAPE: "Escape",
+		F1: "F1",
+		F10: "F10",
+		F11: "F11",
+		F12: "F12",
+		F2: "F2",
+		F3: "F3",
+		F4: "F4",
+		F5: "F5",
+		F6: "F6",
+		F7: "F7",
+		F8: "F8",
+		F9: "F9",
+		HOME: "Home",
+		META: "Meta",
+		PAGE_DOWN: "PageDown",
+		PAGE_UP: "PageUp",
+		SHIFT: "Shift",
+		SPACE: " ",
+		TAB: "Tab",
+		CTRL: "Control",
+		ASTERISK: "*",
+		SPACE_CODE: "Space"
+	};
+}
+//#endregion
+export { useKbd as t };