@youcan/celeste 0.6.101 → 0.7.0

package/dist/cjs/chunks/tooltip-trigger.cjs

@@ -1,17 +1,123 @@
-const require_dist = require("./dist.cjs");
+require("./chunk.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_useForwardProps = require("./useForwardProps.cjs");
+const require_useId = require("./useId.cjs");
+const require_PopperAnchor = require("./PopperAnchor.cjs");
+const require_TooltipProvider = require("./TooltipProvider.cjs");
+const require_TooltipRoot = require("./TooltipRoot.cjs");
 let vue = require("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__ */ (0, vue.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 = require_TooltipRoot.injectTooltipRootContext();
+		const providerContext = require_TooltipProvider.injectTooltipProviderContext();
+		rootContext.contentId ||= require_useId.useId(void 0, "reka-tooltip-content");
+		const { forwardRef, currentElement: triggerElement } = require_useForwardExpose.useForwardExpose();
+		const isPointerDown = (0, vue.ref)(false);
+		const hasPointerMoveOpened = (0, vue.ref)(false);
+		const tooltipListeners = (0, vue.computed)(() => {
+			if (rootContext.disabled.value) return {};
+			return {
+				click: handleClick,
+				focus: handleFocus,
+				pointermove: handlePointerMove,
+				pointerleave: handlePointerLeave,
+				pointerdown: handlePointerDown,
+				blur: handleBlur
+			};
+		});
+		(0, vue.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 (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperAnchor.PopperAnchor_default), {
+				"as-child": "",
+				reference: _ctx.reference
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)({
+					ref: (0, vue.unref)(forwardRef),
+					"aria-describedby": (0, vue.unref)(rootContext).open.value ? (0, vue.unref)(rootContext).contentId : void 0,
+					"data-state": (0, vue.unref)(rootContext).stateAttribute.value,
+					as: _ctx.as,
+					"as-child": props.asChild,
+					"data-grace-area-trigger": ""
+				}, (0, vue.toHandlers)(tooltipListeners.value)), {
+					default: (0, vue.withCtx)(() => [(0, vue.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__ */ (0, vue.defineComponent)({
 	__name: "tooltip-trigger",
 	props: {
+		reference: {},
 		asChild: { type: Boolean },
 		as: {}
 	},
 	setup(__props) {
-		const forwardedProps = require_dist.Ot(__props);
+		const forwardedProps = require_useForwardProps.useForwardProps(__props);
 		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_dist.jg), (0, vue.mergeProps)((0, vue.unref)(forwardedProps), { "as-child": "" }), {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(TooltipTrigger_default), (0, vue.mergeProps)((0, vue.unref)(forwardedProps), { "as-child": "" }), {
 				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
 				_: 3
 			}, 16);

package/dist/cjs/chunks/tooltip.cjs

@@ -1,9 +1,10 @@
-const require_dist = require("./dist.cjs");
-const require_use_delegated_props = require("../use-delegated-props.cjs");
+require("./chunk.cjs");
+const require_useForwardPropsEmits = require("./useForwardPropsEmits.cjs");
 const require_tooltip_content = require("./tooltip-content.cjs");
+const require_tooltip_trigger = require("./tooltip-trigger.cjs");
+const require_use_delegated_props = require("../use-delegated-props.cjs");
 const require_tooltip_provider = require("./tooltip-provider.cjs");
 const require_tooltip_root = require("./tooltip-root.cjs");
-const require_tooltip_trigger = require("./tooltip-trigger.cjs");
 let vue = require("vue");
 //#endregion
 //#region src/components/tooltip/tooltip.vue
@@ -37,13 +38,15 @@ var tooltip_default = /* @__PURE__ */ (0, vue.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 = require_dist.Se(require_use_delegated_props.useDelegatedProps(props, [
+		const forwarded = require_useForwardPropsEmits.useForwardPropsEmits(require_use_delegated_props.useDelegatedProps(props, [
 			"class",
 			"size",
 			"variant",

package/dist/cjs/chunks/use-color-model.cjs

@@ -1,4 +1,4 @@
-require("./dist.cjs");
+require("./chunk.cjs");
 let vue = require("vue");
 //#region ../../node_modules/.pnpm/tinycolor2@1.6.0/node_modules/tinycolor2/esm/tinycolor.js
 function _typeof(obj) {

package/dist/cjs/chunks/useArrowNavigation.cjs

@@ -0,0 +1,65 @@
+//#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
+Object.defineProperty(exports, "useArrowNavigation", {
+	enumerable: true,
+	get: function() {
+		return useArrowNavigation;
+	}
+});

package/dist/cjs/chunks/useComposing.cjs

@@ -0,0 +1,27 @@
+require("./chunk.cjs");
+let vue = require("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 = (0, vue.ref)(false);
+	function handleCompositionStart() {
+		isComposing.value = true;
+	}
+	function handleCompositionEnd(event) {
+		(0, vue.nextTick)(() => {
+			isComposing.value = false;
+			onEnd?.(event);
+		});
+	}
+	return {
+		isComposing,
+		handleCompositionStart,
+		handleCompositionEnd
+	};
+}
+//#endregion
+Object.defineProperty(exports, "useComposing", {
+	enumerable: true,
+	get: function() {
+		return useComposing;
+	}
+});

package/dist/cjs/chunks/useDirection.cjs

@@ -0,0 +1,20 @@
+require("./chunk.cjs");
+const require_ConfigProvider = require("./ConfigProvider.cjs");
+let vue = require("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 = require_ConfigProvider.injectConfigProviderContext({ dir: (0, vue.ref)("ltr") });
+	return (0, vue.computed)(() => dir?.value || context.dir?.value || "ltr");
+}
+//#endregion
+Object.defineProperty(exports, "useDirection", {
+	enumerable: true,
+	get: function() {
+		return useDirection;
+	}
+});

package/dist/cjs/chunks/useEmitAsProps.cjs

@@ -0,0 +1,34 @@
+require("./chunk.cjs");
+let vue = require("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 = (0, vue.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[(0, vue.toHandlerKey)((0, vue.camelize)(ev))] = (...arg) => emit(ev, ...arg);
+	});
+	return result;
+}
+//#endregion
+Object.defineProperty(exports, "useEmitAsProps", {
+	enumerable: true,
+	get: function() {
+		return useEmitAsProps;
+	}
+});

package/dist/cjs/chunks/useFocusGuards.cjs

@@ -0,0 +1,40 @@
+require("./chunk.cjs");
+const require_dist = require("./dist.cjs");
+let vue = require("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() {
+	(0, vue.watchEffect)((cleanupFn) => {
+		if (!require_dist.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
+Object.defineProperty(exports, "useFocusGuards", {
+	enumerable: true,
+	get: function() {
+		return useFocusGuards;
+	}
+});

package/dist/cjs/chunks/useFormControl.cjs

@@ -0,0 +1,14 @@
+require("./chunk.cjs");
+const require_dist = require("./dist.cjs");
+let vue = require("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 (0, vue.computed)(() => (0, vue.toValue)(el) ? Boolean(require_dist.unrefElement(el)?.closest("form")) : true);
+}
+//#endregion
+Object.defineProperty(exports, "useFormControl", {
+	enumerable: true,
+	get: function() {
+		return useFormControl;
+	}
+});

package/dist/cjs/chunks/useForwardExpose.cjs

@@ -0,0 +1,64 @@
+require("./chunk.cjs");
+const require_dist = require("./dist.cjs");
+let vue = require("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 = (0, vue.getCurrentInstance)();
+	const currentRef = (0, vue.ref)();
+	const currentElement = (0, vue.computed)(() => resolveCurrentElement());
+	(0, vue.onUpdated)(() => {
+		if (currentElement.value !== resolveCurrentElement()) (0, vue.triggerRef)(currentRef);
+	});
+	function resolveCurrentElement() {
+		return currentRef.value && "$el" in currentRef.value && ["#text", "#comment"].includes(currentRef.value.$el.nodeName) ? currentRef.value.$el.nextElementSibling : require_dist.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
+Object.defineProperty(exports, "useForwardExpose", {
+	enumerable: true,
+	get: function() {
+		return useForwardExpose;
+	}
+});

package/dist/cjs/chunks/useForwardProps.cjs

@@ -0,0 +1,40 @@
+require("./chunk.cjs");
+let vue = require("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 = (0, vue.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 = (0, vue.toRef)(props);
+	return (0, vue.computed)(() => {
+		const preservedProps = {};
+		const assignedProps = vm?.vnode.props ?? {};
+		Object.keys(assignedProps).forEach((key) => {
+			preservedProps[(0, vue.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
+Object.defineProperty(exports, "useForwardProps", {
+	enumerable: true,
+	get: function() {
+		return useForwardProps;
+	}
+});

package/dist/cjs/chunks/useForwardPropsEmits.cjs

@@ -0,0 +1,20 @@
+require("./chunk.cjs");
+const require_useEmitAsProps = require("./useEmitAsProps.cjs");
+const require_useForwardProps = require("./useForwardProps.cjs");
+let vue = require("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 = require_useForwardProps.useForwardProps(props);
+	const emitsAsProps = emit ? require_useEmitAsProps.useEmitAsProps(emit) : {};
+	return (0, vue.computed)(() => ({
+		...parsedProps.value,
+		...emitsAsProps
+	}));
+}
+//#endregion
+Object.defineProperty(exports, "useForwardPropsEmits", {
+	enumerable: true,
+	get: function() {
+		return useForwardPropsEmits;
+	}
+});

package/dist/cjs/chunks/useForwardScopeId.cjs

@@ -0,0 +1,31 @@
+require("./chunk.cjs");
+let vue = require("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 = ((0, vue.getCurrentInstance)()?.vnode)?.scopeId;
+	return scopeId ? { [scopeId]: "" } : {};
+}
+//#endregion
+Object.defineProperty(exports, "useForwardScopeId", {
+	enumerable: true,
+	get: function() {
+		return useForwardScopeId;
+	}
+});

package/dist/cjs/chunks/useHideOthers.cjs

@@ -0,0 +1,138 @@
+require("./chunk.cjs");
+const require_dist = require("./dist.cjs");
+let vue = require("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;
+	(0, vue.watch)(() => require_dist.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();
+	});
+	(0, vue.onUnmounted)(() => {
+		if (undo) undo();
+	});
+}
+//#endregion
+Object.defineProperty(exports, "useHideOthers", {
+	enumerable: true,
+	get: function() {
+		return useHideOthers;
+	}
+});