@wisemen/vue-core-actions 0.1.1

package/dist/index.js

@@ -0,0 +1,2122 @@
+import { t as actionsLocales } from "./locales-BPtvPqGa.js";
+import { computed, getCurrentInstance, getCurrentScope, inject, isRef, markRaw, nextTick, onBeforeUnmount, onMounted, onScopeDispose, onUnmounted, reactive, ref, shallowRef, toValue, unref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { defineStore } from "pinia";
+import { useRoute, useRouter } from "vue-router";
+function tryOnScopeDispose(e, T) {
+	return getCurrentScope() ? (onScopeDispose(e, T), !0) : !1;
+}
+var isClient = typeof window < "u" && typeof document < "u";
+typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
+var notNullish = (e) => e != null, toString = Object.prototype.toString, isObject = (e) => toString.call(e) === "[object Object]", noop = () => {};
+function createFilterWrapper(e, T) {
+	function E(...E) {
+		return new Promise((D, O) => {
+			Promise.resolve(e(() => T.apply(this, E), {
+				fn: T,
+				thisArg: this,
+				args: E
+			})).then(D).catch(O);
+		});
+	}
+	return E;
+}
+function debounceFilter(e, T = {}) {
+	let E, D, O = noop, k = (e) => {
+		clearTimeout(e), O(), O = noop;
+	}, A;
+	return (j) => {
+		let M = toValue(e), N = toValue(T.maxWait);
+		return E && k(E), M <= 0 || N !== void 0 && N <= 0 ? (D &&= (k(D), void 0), Promise.resolve(j())) : new Promise((e, P) => {
+			O = T.rejectOnCancel ? P : e, A = j, N && !D && (D = setTimeout(() => {
+				E && k(E), D = void 0, e(A());
+			}, N)), E = setTimeout(() => {
+				D && k(D), D = void 0, e(j());
+			}, M);
+		});
+	};
+}
+function throttleFilter(...e) {
+	let T = 0, E, D = !0, O = noop, A, j, M, N, P;
+	!isRef(e[0]) && typeof e[0] == "object" ? {delay: j, trailing: M = !0, leading: N = !0, rejectOnCancel: P = !1} = e[0] : [j, M = !0, N = !0, P = !1] = e;
+	let F = () => {
+		E && (clearTimeout(E), E = void 0, O(), O = noop);
+	};
+	return (e) => {
+		let k = toValue(j), I = Date.now() - T, L = () => A = e();
+		return F(), k <= 0 ? (T = Date.now(), L()) : (I > k ? (T = Date.now(), (N || !D) && L()) : M && (A = new Promise((e, A) => {
+			O = P ? A : e, E = setTimeout(() => {
+				T = Date.now(), D = !0, e(L()), F();
+			}, Math.max(0, k - I));
+		})), !N && !E && (E = setTimeout(() => D = !0, k)), D = !1, A);
+	};
+}
+function toArray(e) {
+	return Array.isArray(e) ? e : [e];
+}
+function getLifeCycleTarget(e) {
+	return e || getCurrentInstance();
+}
+function useDebounceFn(e, T = 200, E = {}) {
+	return createFilterWrapper(debounceFilter(T, E), e);
+}
+function useThrottleFn(e, T = 200, E = !1, D = !0, O = !1) {
+	return createFilterWrapper(throttleFilter(T, E, D, O), e);
+}
+function tryOnMounted(e, T = !0, E) {
+	getLifeCycleTarget(E) ? onMounted(e, E) : T ? e() : nextTick(e);
+}
+function tryOnUnmounted(e, T) {
+	getLifeCycleTarget(T) && onUnmounted(e, T);
+}
+function watchImmediate(e, T, E) {
+	return watch(e, T, {
+		...E,
+		immediate: !0
+	});
+}
+function watchOnce(e, T, E) {
+	return watch(e, T, {
+		...E,
+		once: !0
+	});
+}
+var defaultWindow = isClient ? window : void 0;
+isClient && window.document, isClient && window.navigator, isClient && window.location;
+function unrefElement(e) {
+	let T = toValue(e);
+	return T?.$el ?? T;
+}
+function useEventListener(...e) {
+	let E = (e, T, E, D) => (e.addEventListener(T, E, D), () => e.removeEventListener(T, E, D)), D = computed(() => {
+		let T = toArray(toValue(e[0])).filter((e) => e != null);
+		return T.every((e) => typeof e != "string") ? T : void 0;
+	});
+	return watchImmediate(() => [
+		D.value?.map((e) => unrefElement(e)) ?? [defaultWindow].filter((e) => e != null),
+		toArray(toValue(D.value ? e[1] : e[0])),
+		toArray(unref(D.value ? e[2] : e[1])),
+		toValue(D.value ? e[3] : e[2])
+	], ([e, T, D, O], k, A) => {
+		if (!e?.length || !T?.length || !D?.length) return;
+		let j = isObject(O) ? { ...O } : O, M = e.flatMap((e) => T.flatMap((T) => D.map((D) => E(e, T, D, j))));
+		A(() => {
+			M.forEach((e) => e());
+		});
+	}, { flush: "post" });
+}
+function useMounted() {
+	let e = shallowRef(!1), T = getCurrentInstance();
+	return T && onMounted(() => {
+		e.value = !0;
+	}, T), e;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function useSupported(e) {
+	let E = useMounted();
+	return computed(() => (E.value, !!e()));
+}
+function useMutationObserver(e, E, D = {}) {
+	let { window: O = defaultWindow, ...k } = D, A, j = /* @__PURE__ */ useSupported(() => O && "MutationObserver" in O), M = () => {
+		A &&= (A.disconnect(), void 0);
+	}, N = watch(computed(() => {
+		let T = toArray(toValue(e)).map(unrefElement).filter(notNullish);
+		return new Set(T);
+	}), (e) => {
+		M(), j.value && e.size && (A = new MutationObserver(E), e.forEach((e) => A.observe(e, k)));
+	}, {
+		immediate: !0,
+		flush: "post"
+	}), P = () => A?.takeRecords(), F = () => {
+		N(), M();
+	};
+	return tryOnScopeDispose(F), {
+		isSupported: j,
+		stop: F,
+		takeRecords: P
+	};
+}
+function useIntersectionObserver(e, E, D = {}) {
+	let { root: O, rootMargin: k = "0px", threshold: A = 0, window: j = defaultWindow, immediate: M = !0 } = D, N = /* @__PURE__ */ useSupported(() => j && "IntersectionObserver" in j), P = computed(() => toArray(toValue(e)).map(unrefElement).filter(notNullish)), F = noop, I = shallowRef(M), L = N.value ? watch(() => [
+		P.value,
+		unrefElement(O),
+		I.value
+	], ([e, T]) => {
+		if (F(), !I.value || !e.length) return;
+		let D = new IntersectionObserver(E, {
+			root: unrefElement(T),
+			rootMargin: k,
+			threshold: A
+		});
+		e.forEach((e) => e && D.observe(e)), F = () => {
+			D.disconnect(), F = noop;
+		};
+	}, {
+		immediate: M,
+		flush: "post"
+	}) : noop, B = () => {
+		F(), L(), I.value = !1;
+	};
+	return tryOnScopeDispose(B), {
+		isSupported: N,
+		isActive: I,
+		pause() {
+			F(), I.value = !1;
+		},
+		resume() {
+			I.value = !0;
+		},
+		stop: B
+	};
+}
+function useElementVisibility(e, T = {}) {
+	let { window: E = defaultWindow, scrollTarget: D, threshold: O = 0, rootMargin: k, once: A = !1, initialValue: j = !1 } = T, M = shallowRef(j), { stop: N } = useIntersectionObserver(e, (e) => {
+		let T = M.value, E = 0;
+		for (let D of e) D.time >= E && (E = D.time, T = D.isIntersecting);
+		M.value = T, A && watchOnce(M, () => {
+			N();
+		});
+	}, {
+		root: D,
+		window: E,
+		threshold: O,
+		rootMargin: toValue(k)
+	});
+	return M;
+}
+function resolveElement(e) {
+	return typeof Window < "u" && e instanceof Window ? e.document.documentElement : typeof Document < "u" && e instanceof Document ? e.documentElement : e;
+}
+var ARRIVED_STATE_THRESHOLD_PIXELS = 1;
+function useScroll(e, E = {}) {
+	let { throttle: D = 0, idle: O = 200, onStop: k = noop, onScroll: A = noop, offset: j = {
+		left: 0,
+		right: 0,
+		top: 0,
+		bottom: 0
+	}, observe: M = { mutation: !1 }, eventListenerOptions: N = {
+		capture: !1,
+		passive: !0
+	}, behavior: P = "auto", window: F = defaultWindow, onError: L = (e) => {
+		console.error(e);
+	} } = E, B = typeof M == "boolean" ? { mutation: M } : M, V = shallowRef(0), H = shallowRef(0), U = computed({
+		get() {
+			return V.value;
+		},
+		set(e) {
+			G(e, void 0);
+		}
+	}), W = computed({
+		get() {
+			return H.value;
+		},
+		set(e) {
+			G(void 0, e);
+		}
+	});
+	function G(T, E) {
+		var D, O;
+		if (!F) return;
+		let k = toValue(e);
+		if (!k) return;
+		(D = k instanceof Document ? F.document.body : k) == null || D.scrollTo({
+			top: toValue(E) ?? W.value,
+			left: toValue(T) ?? U.value,
+			behavior: toValue(P)
+		});
+		let A = (k == null || (O = k.document) == null ? void 0 : O.documentElement) || k?.documentElement || k;
+		U != null && (V.value = A.scrollLeft), W != null && (H.value = A.scrollTop);
+	}
+	let K = shallowRef(!1), q = reactive({
+		left: !0,
+		right: !1,
+		top: !0,
+		bottom: !1
+	}), J = reactive({
+		left: !1,
+		right: !1,
+		top: !1,
+		bottom: !1
+	}), Y = (e) => {
+		K.value && (K.value = !1, J.left = !1, J.right = !1, J.top = !1, J.bottom = !1, k(e));
+	}, X = useDebounceFn(Y, D + O), Q = (e) => {
+		var T;
+		if (!F) return;
+		let E = (e == null || (T = e.document) == null ? void 0 : T.documentElement) || e?.documentElement || unrefElement(e), { display: D, flexDirection: O, direction: k } = F.getComputedStyle(E), A = k === "rtl" ? -1 : 1, M = E.scrollLeft;
+		J.left = M < V.value, J.right = M > V.value;
+		let N = Math.abs(M * A) <= (j.left || 0), P = Math.abs(M * A) + E.clientWidth >= E.scrollWidth - (j.right || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
+		D === "flex" && O === "row-reverse" ? (q.left = P, q.right = N) : (q.left = N, q.right = P), V.value = M;
+		let I = E.scrollTop;
+		e === F.document && !I && (I = F.document.body.scrollTop), J.top = I < H.value, J.bottom = I > H.value;
+		let L = Math.abs(I) <= (j.top || 0), R = Math.abs(I) + E.clientHeight >= E.scrollHeight - (j.bottom || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
+		D === "flex" && O === "column-reverse" ? (q.top = R, q.bottom = L) : (q.top = L, q.bottom = R), H.value = I;
+	}, $ = (e) => {
+		F && (Q(e.target.documentElement ?? e.target), K.value = !0, X(e), A(e));
+	};
+	return useEventListener(e, "scroll", D ? useThrottleFn($, D, !0, !1) : $, N), tryOnMounted(() => {
+		try {
+			let T = toValue(e);
+			if (!T) return;
+			Q(T);
+		} catch (e) {
+			L(e);
+		}
+	}), B?.mutation && e != null && e !== F && e !== document && useMutationObserver(e, () => {
+		let T = toValue(e);
+		T && Q(T);
+	}, {
+		attributes: !0,
+		childList: !0,
+		subtree: !0
+	}), useEventListener(e, "scrollend", Y, N), {
+		x: U,
+		y: W,
+		isScrolling: K,
+		arrivedState: q,
+		directions: J,
+		measure() {
+			let T = toValue(e);
+			F && T && Q(T);
+		}
+	};
+}
+function useInfiniteScroll(e, E, D = {}) {
+	let { direction: O = "bottom", interval: k = 100, canLoadMore: A = () => !0 } = D, M = reactive(useScroll(e, {
+		...D,
+		offset: {
+			[O]: D.distance ?? 0,
+			...D.offset
+		}
+	})), N = ref(), P = computed(() => !!N.value), F = computed(() => resolveElement(toValue(e))), R = useElementVisibility(F), B = computed(() => F.value ? A(F.value) : !1);
+	function H() {
+		if (M.measure(), !F.value || !R.value || !B.value) return;
+		let { scrollHeight: e, clientHeight: T, scrollWidth: D, clientWidth: A } = F.value, P = O === "bottom" || O === "top" ? e <= T : D <= A;
+		(M.arrivedState[O] || P) && (N.value ||= Promise.all([E(M), new Promise((e) => setTimeout(e, k))]).finally(() => {
+			N.value = null, nextTick(() => H());
+		}));
+	}
+	return tryOnUnmounted(watch(() => [
+		M.arrivedState[O],
+		R.value,
+		B.value
+	], H, { immediate: !0 })), {
+		isLoading: P,
+		reset() {
+			nextTick(() => H());
+		}
+	};
+}
+const isAuthenticated = shallowRef(!1);
+function setIsAuthenticated(e) {
+	isAuthenticated.value = e;
+}
+function _createUntypedAction(e) {
+	return e;
+}
+function typedActionDropdownMenu(e) {
+	return e;
+}
+function typedActionTrigger(e) {
+	return e;
+}
+function typedActionFocus(e) {
+	return e;
+}
+function createActions() {
+	function e(e) {
+		return e;
+	}
+	return {
+		createAction: e,
+		setIsAuthenticated
+	};
+}
+var wordRegex = /[\s\-_./]+/;
+async function applicableActions(e, T, E, D) {
+	let O = T.searchInput.length, k = O >= 0, A = resolveActionFactories(e);
+	if (k) {
+		let e = [], k = [], j = [...A];
+		for (; j.length > 0;) {
+			let E = j.shift();
+			e.push(E);
+			let D = resolveSearchSubActionsConfig(E, T), A = O >= (D?.minLength ?? 2);
+			if (E.subActions !== void 0 && A) {
+				let e = D?.maxResults ?? 99, O = E.subActions(T);
+				if (Array.isArray(O)) {
+					let T = decorateLiftedChildren(O.slice(0, e), E);
+					j.push(...T);
+				} else if (isSubActionsWithMeta$1(O)) {
+					let T = decorateLiftedChildren(O.actions.slice(0, e), E);
+					j.push(...T);
+				} else {
+					let T = E;
+					k.push(async () => decorateLiftedChildren(await resolveAsyncSubActions(O, e), T));
+				}
+			}
+		}
+		if (k.length > 0 && E !== void 0) {
+			E(filterAndRank(e, T, D));
+			let O = [...e];
+			return await Promise.all(k.map(async (e) => {
+				let k = await e();
+				O.push(...k), E(filterAndRank(O, T, D));
+			})), filterAndRank(O, T, D);
+		}
+		let M = (await Promise.all(k.map((e) => e()))).flat();
+		A = [...e, ...M];
+	}
+	return filterAndRank(A, T, D);
+}
+function filterAndRank(e, T, E) {
+	let D = T.searchInput.length >= 0, O = /* @__PURE__ */ new Set(), k = /* @__PURE__ */ new Set(), A = [];
+	for (let E of e) if (resolveApplicable(E, T)) {
+		if (E.id !== void 0) {
+			if (k.has(E.id)) continue;
+			k.add(E.id);
+		}
+		if (E.key !== void 0) {
+			if (O.has(E.key)) continue;
+			O.add(E.key);
+		}
+		A.push(E);
+	}
+	if (D) {
+		let e = A.map((e) => ({
+			action: e,
+			score: scoreAction(e, T.searchInput, T)
+		})).filter(({ score: e }) => e >= .24);
+		return e = e.toSorted((e, D) => {
+			let O = e.action.parentAction === void 0 ? 0 : 1, k = D.action.parentAction === void 0 ? 0 : 1;
+			if (O !== k) return O - k;
+			let A = e.action.parentAction ?? E, j = D.action.parentAction ?? E, M = A?.showSelectedSubActionsFirst !== !1 && resolveActionSelected(e.action, T) ? 0 : 1, N = j?.showSelectedSubActionsFirst !== !1 && resolveActionSelected(D.action, T) ? 0 : 1;
+			if (M !== N) return M - N;
+			let P = D.score - e.score;
+			if (Math.abs(P) > .05) return P;
+			let F = resolveGroupPriority(e.action, T), I = resolveGroupPriority(D.action, T);
+			return F === I ? P : F - I;
+		}), e.map((e) => e.action);
+	}
+	let j = E?.showSelectedSubActionsFirst !== !1;
+	return A.sort((e, E) => {
+		let D = j && resolveActionSelected(e, T) ? 0 : 1, O = j && resolveActionSelected(E, T) ? 0 : 1;
+		return D === O ? resolveGroupPriority(e, T) - resolveGroupPriority(E, T) : D - O;
+	});
+}
+function isSubActionsWithMeta$1(e) {
+	return typeof e == "object" && !!e && "actions" in e && "pagination" in e && Array.isArray(e.actions);
+}
+async function resolveAsyncSubActions(e, T) {
+	if (e instanceof Promise) {
+		let E = await e;
+		return isSubActionsWithMeta$1(E) ? E.actions.slice(0, T) : E.slice(0, T);
+	}
+	let E = [];
+	for await (let D of e) if (E.push(D), E.length >= T) break;
+	return E;
+}
+function resolveActionFactories(e) {
+	let T = [];
+	for (let E of e) typeof E == "function" ? T.push(...E()) : T.push(E);
+	return T;
+}
+function decorateLiftedChildren(e, T) {
+	let E = T.rootAction ?? T;
+	return e.map((e) => ({
+		...e,
+		group: e.group === void 0 && T.group?.groupWhenLifted ? T.group.groupWhenLifted : e.group,
+		parentAction: T,
+		rootAction: E,
+		onlyVisibleThroughSearch: !0
+	}));
+}
+function resolveApplicable(e, T) {
+	return !(!isAuthenticated.value && e.availableWhenUnauthenticated !== !0 || e.isApplicable !== void 0 && !e.isApplicable(T) || T.menuType === "commandMenu" && e.disabledReason !== void 0 && typeof e.disabledReason(T) == "string" || e.onlyVisibleThroughSearch && T.menuType !== void 0 && T.searchInput.length === 0);
+}
+function resolveGroupPriority(e, T) {
+	let E = e.group?.priority ?? null;
+	return E === null ? 9999 : typeof E == "function" ? E(T) : E;
+}
+function scoreAction(e, T, E) {
+	if (T.trim().length === 0 || e.skipFilterScoring) return 1;
+	let D = resolveActionName(e, E), O = buildSecondaryString(e, E);
+	if (e.keywordsExactMatch) {
+		let T = Array.isArray(e.keywordsExactMatch) ? e.keywordsExactMatch : [e.keywordsExactMatch];
+		if (T.some((e) => D.toLowerCase().includes(e.toLowerCase())) || T.some((e) => O.toLowerCase().includes(e.toLowerCase()))) return 1;
+	}
+	let k = fuzzyScoreSync(D, T), A = fuzzyScoreSync(O, T) * .85, j = Math.max(k, A);
+	return j < .24 && (D.toLowerCase().includes(T.toLowerCase()) ? j = .29 : O.toLowerCase().includes(T.toLowerCase()) && (j = .245)), e.parentAction && (j += -.15), e.scoreOverride !== void 0 && (j = e.scoreOverride), e.sortPriority !== void 0 && (j -= e.sortPriority * 1e-4), j;
+}
+function buildSecondaryString(e, T) {
+	let E = [], D = e.parentScoreInfluence ?? "all";
+	if (D !== "none") {
+		let O = e.parentAction;
+		if (D === "all") for (; O;) {
+			let e = O.nameAsParent ? typeof O.nameAsParent == "function" ? O.nameAsParent(T) : O.nameAsParent : resolveActionName(O, T);
+			E.push(e), O = O.parentAction;
+		}
+		if (D === "direct" && e.parentAction !== void 0) {
+			let D = e.parentAction, O = D.nameAsParent ? typeof D.nameAsParent == "function" ? D.nameAsParent(T) : D.nameAsParent : resolveActionName(D, T);
+			E.push(O);
+		}
+	}
+	if (E.push(resolveActionName(e, T)), e.keywords !== void 0) {
+		let T = Array.isArray(e.keywords) ? e.keywords : [e.keywords];
+		E.push(...T);
+	}
+	return E.join(" ");
+}
+function fuzzyScoreSync(e, T) {
+	if (!e || !T) return 0;
+	let E = e.toLowerCase().trim(), D = T.toLowerCase().trim();
+	if (!D || E === D) return 1;
+	if (E.startsWith(D)) return .92 - Math.min(.12, (E.length - D.length) * .002);
+	let O = E.indexOf(D);
+	if (O !== -1) return .82 - Math.min(.12, O * .004);
+	let k = E.split(wordRegex);
+	if (k.some((e) => e.startsWith(D))) return .68;
+	let A = k.map((e) => e[0] ?? "").join("");
+	if (A === D || A.startsWith(D)) return .6;
+	let j = E.length, M = D.length;
+	if (M > j) return 0;
+	let N = 0, P = -1, F = -1, I = -1, L = 0, R = 0;
+	for (let e = 0; e < j && N < M; e++) E[e] === D[N] && (P === -1 && (P = e), F = e, N++, I === e - 1 ? (L++, R += L * .08) : L = 0, I = e);
+	if (N < M) return 0;
+	let z = F - P + 1, B = (1 - P / j) * .3 + M / z * .35 + M / j * .2 + Math.min(R, .15);
+	return Math.min(.55, Math.max(0, B));
+}
+function resolveActionValue(e, T) {
+	return typeof e == "function" ? e(T) : e;
+}
+function resolveActionName(e, T) {
+	return typeof e.name == "function" ? e.name(T) : e.name;
+}
+function resolveActionAvatar(e, T) {
+	return typeof e.avatar == "function" ? e.avatar(T) : e.avatar ?? null;
+}
+function resolveActionHint(e, T) {
+	return typeof e.hint == "function" ? e.hint(T) : e.hint ?? null;
+}
+function resolveActionSelected(e, T) {
+	return typeof e.selected == "function" ? e.selected(T) : e.selected ?? null;
+}
+function resolveSearchSubActionsConfig(e, T) {
+	return typeof e.searchSubActionsConfig == "function" ? e.searchSubActionsConfig(T) : e.searchSubActionsConfig ?? null;
+}
+function resolveActionPreview(e, T) {
+	return typeof e.preview == "function" ? e.preview(T) : null;
+}
+function useActionPreview({ highlightedActionId: e, getContext: E, resolvedActions: D }) {
+	let O = ref(!1), k = computed(() => {
+		if (e.value === null || !O.value) return null;
+		let T = D.value.find((T) => T.id === e.value) ?? null;
+		return T === null ? null : resolveActionPreview(T, E());
+	});
+	function A() {
+		O.value = !0;
+	}
+	function j() {
+		O.value = !1;
+	}
+	function M(e) {
+		if (!(e.target instanceof HTMLInputElement)) return;
+		let T = e.target;
+		T.selectionStart === T.value.length && e.key === "ArrowRight" && (O.value = !0, e.preventDefault()), e.key === "ArrowLeft" && O.value && (O.value = !1, e.preventDefault()), e.key !== "ArrowLeft" && e.key !== "ArrowRight" && e.key !== "ArrowUp" && e.key !== "ArrowDown" && (O.value = !1);
+	}
+	return {
+		preview: k,
+		onHidePreview: j,
+		onKeyDown: M,
+		onShowPreview: A
+	};
+}
+function useIsSelectorVisible(e) {
+	let T = ref(!1), E = null;
+	function D() {
+		T.value = document.querySelector(e) !== null;
+	}
+	return onMounted(() => {
+		D(), E = new MutationObserver(D), E.observe(document.body, {
+			childList: !0,
+			subtree: !0
+		});
+	}), onBeforeUnmount(() => {
+		E?.disconnect();
+	}), T;
+}
+async function executeAction(e, T, E) {
+	e.execute !== void 0 && (await e.execute(T), E?.onComplete?.());
+}
+function dedupeModels(e) {
+	let T = /* @__PURE__ */ new Set();
+	return e.filter((e) => T.has(e) ? !1 : (T.add(e), !0));
+}
+const useActionManagerStore = defineStore("actionManager", () => {
+	let e = ref([]), T = ref([]), E = ref({}), D = useRouter(), O = useRoute(), k = useIsSelectorVisible("[data-dialog]:not([data-command-menu])");
+	function A(e) {
+		E.value = {
+			...E.value,
+			...e
+		};
+	}
+	function j(e) {
+		let T = { ...E.value };
+		delete T[e], E.value = T;
+	}
+	function M(T) {
+		e.value = T;
+	}
+	function N(e) {
+		T.value = e;
+	}
+	function P(A) {
+		let j = dedupeModels([
+			...A.models ?? [],
+			...T.value,
+			...e.value
+		]), M = {
+			...E.value,
+			...A.metadata
+		};
+		return {
+			getPaginationOffsetForSubActionId: (e) => A.subActionsMeta?.[e] ?? null,
+			hasActiveDialogs: () => k.value,
+			hasTargetedModelsOfType: (e) => j.some((T) => T.modelName === e),
+			isRouteActive: (e, T) => T === void 0 || T === !1 ? O.matched.some((T) => T.name === e) : O.name === e,
+			allModels: j,
+			focusedModels: e.value,
+			keyboardEvent: A.keyboardEvent,
+			menuType: A.menuType,
+			metadata: M,
+			models: A.models ?? [],
+			router: D,
+			searchInput: A.searchInput ?? "",
+			subActionsMeta: A.subActionsMeta,
+			targetedModelOfType: (e) => j.find((T) => T.modelName === e) ?? null,
+			targetedModelOfTypeOrThrow: (e) => {
+				let T = j.find((T) => T.modelName === e) ?? null;
+				if (T === null) throw Error(`Model of type: ${e} not found`);
+				return T;
+			},
+			targetedModelsOfType: (e) => j.filter((T) => T.modelName === e)
+		};
+	}
+	return {
+		actionContext: P,
+		executeAction,
+		focusedModels: e,
+		metadata: E,
+		registerMetadata: A,
+		setFocusedModels: M,
+		setViewModels: N,
+		unregisterMetadata: j,
+		viewModels: T
+	};
+});
+function isSubActionsWithMeta(e) {
+	return typeof e == "object" && !!e && "actions" in e && "pagination" in e && Array.isArray(e.actions);
+}
+function storeSubActionsPagination(e, T, E) {
+	return isSubActionsWithMeta(T) ? (e.id && (E[e.id] = T.pagination.nextOffset), T.actions) : (e.id && delete E[e.id], T);
+}
+async function resolveSubActions(e, T, E, D = 297) {
+	if (e.subActions === void 0) return [];
+	let O = e.subActions(T);
+	if (Array.isArray(O) || isSubActionsWithMeta(O)) return storeSubActionsPagination(e, O, E);
+	if (O instanceof Promise) return storeSubActionsPagination(e, await O, E);
+	let k = [];
+	for await (let e of O) if (k.push(e), k.length >= D) break;
+	return k;
+}
+function useActionDropdownMenuContent({ actions: e, metadata: E, models: D, parentAction: O, scrollContainerRef: k }) {
+	let A = useI18n(), j = useActionManagerStore(), M = ref(null), N = ref(""), P = ref(""), F = ref(!1), I = ref([]), R = ref({}), z = ref(!0), B = 0, U = computed(() => j.actionContext({
+		menuType: "contextualMenu",
+		metadata: E.value,
+		models: D.value,
+		searchInput: P.value
+	})), { preview: W, onHidePreview: G, onKeyDown: K, onShowPreview: q } = useActionPreview({
+		highlightedActionId: M,
+		getContext: () => U.value,
+		resolvedActions: I
+	}), J = computed(() => {
+		if (O.value == null) return A.t("search");
+		let e = resolveSearchSubActionsConfig(O.value, U.value)?.placeholder;
+		return e === void 0 ? A.t("search") : typeof e == "function" ? e() : e;
+	});
+	async function Y() {
+		let T = ++B, E = U.value;
+		try {
+			let D = e.value;
+			O.value?.subActions !== void 0 && (D = await resolveSubActions(O.value, E, R.value));
+			let k = await applicableActions(D, E, (e) => {
+				T !== B || e.length === 0 || (I.value = e);
+			}, O.value ?? void 0);
+			if (T !== B) return;
+			I.value = k, F.value = U.value.searchInput.trim().length > 0;
+		} catch (e) {
+			throw console.error("Error refreshing actions", e), e;
+		} finally {
+			T === B && (z.value = !1);
+		}
+	}
+	useInfiniteScroll(k, async () => {
+		let e = O.value;
+		if (e?.subActions === void 0 || e.id === void 0) return;
+		let T = R.value[e.id];
+		if (T == null) return;
+		let k = j.actionContext({
+			menuType: "contextualMenu",
+			metadata: E.value,
+			models: D.value,
+			searchInput: N.value,
+			subActionsMeta: { [e.id]: T }
+		}), A = e.subActions(k), M;
+		if (Array.isArray(A) || isSubActionsWithMeta(A)) M = A;
+		else if (A instanceof Promise) M = await A;
+		else {
+			let e = [];
+			for await (let T of A) e.push(T);
+			I.value = [...I.value, ...e];
+			return;
+		}
+		I.value = [...I.value, ...storeSubActionsPagination(e, M, R.value)];
+	}, {
+		canLoadMore: () => {
+			let e = O.value;
+			return e?.subActions === void 0 || e.id === void 0 ? !1 : R.value[e.id] != null;
+		},
+		distance: 100
+	});
+	let X = computed(() => {
+		let e = I.value.filter((e) => {
+			let T = e.isApplicable === void 0 || e.isApplicable(U.value), E = e.disabledReason?.(U.value) != null;
+			return T || E;
+		});
+		if (F.value) return e.length > 0 ? [e] : [];
+		let T = [], E = [], D;
+		for (let O of e) E.length > 0 && O.separatorGroup !== D && (T.push(E), E = []), D = O.separatorGroup, E.push(O);
+		return E.length > 0 && T.push(E), T;
+	}), Z = useDebounceFn(() => {
+		P.value = N.value, Y();
+	}, 200);
+	return watch(N, () => {
+		R.value = {}, Z();
+	}), Y(), {
+		highlightedActionId: M,
+		isLoading: z,
+		actionGroups: X,
+		context: U,
+		placeholder: J,
+		preview: W,
+		searchInput: N,
+		onHidePreview: G,
+		onKeyDown: K,
+		onShowPreview: q
+	};
+}
+let GroupPriority = /* @__PURE__ */ function(e) {
+	return e[e.HOVER = 1] = "HOVER", e[e.VIEW = 2] = "VIEW", e[e.MODEL = 3] = "MODEL", e[e.GENERAL = 4] = "GENERAL", e[e.NAVIGATION = 5] = "NAVIGATION", e[e.PREFERENCES = 6] = "PREFERENCES", e[e.ACCOUNT = 7] = "ACCOUNT", e[e.DEVELOPER = 8] = "DEVELOPER", e;
+}({});
+function useActionGroup() {
+	let e = useI18n();
+	return {
+		account: {
+			name: e.t("action.group.account"),
+			priority: GroupPriority.ACCOUNT
+		},
+		developer: {
+			name: e.t("action.group.developer"),
+			priority: GroupPriority.DEVELOPER
+		},
+		general: {
+			name: e.t("action.group.general"),
+			priority: GroupPriority.GENERAL
+		},
+		navigation: {
+			name: e.t("action.group.navigation"),
+			priority: GroupPriority.NAVIGATION
+		},
+		preferences: {
+			name: e.t("action.group.preferences"),
+			priority: GroupPriority.PREFERENCES
+		}
+	};
+}
+var HotkeysContext = Symbol("HotkeysContext");
+function useDefaultHotkeysOptions() {
+	return inject(HotkeysContext, null)?.defaultOptions ?? {};
+}
+function detectPlatform() {
+	if (typeof navigator > "u") return "linux";
+	let e = navigator.platform?.toLowerCase() ?? "", T = navigator.userAgent?.toLowerCase() ?? "";
+	return e.includes("mac") || T.includes("mac") ? "mac" : e.includes("win") || T.includes("win") ? "windows" : "linux";
+}
+var MODIFIER_ORDER = [
+	"Control",
+	"Alt",
+	"Shift",
+	"Meta"
+], MODIFIER_ALIASES = {
+	Control: "Control",
+	Ctrl: "Control",
+	control: "Control",
+	ctrl: "Control",
+	Shift: "Shift",
+	shift: "Shift",
+	Alt: "Alt",
+	Option: "Alt",
+	alt: "Alt",
+	option: "Alt",
+	Command: "Meta",
+	Cmd: "Meta",
+	Meta: "Meta",
+	command: "Meta",
+	cmd: "Meta",
+	meta: "Meta",
+	OS: "Meta",
+	os: "Meta",
+	Win: "Meta",
+	win: "Meta",
+	CommandOrControl: "Mod",
+	Mod: "Mod",
+	commandorcontrol: "Mod",
+	mod: "Mod"
+};
+function resolveModifier(e, T = detectPlatform()) {
+	return e === "Mod" ? T === "mac" ? "Meta" : "Control" : e;
+}
+var LETTER_KEYS = new Set(/* @__PURE__ */ "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("")), NUMBER_KEYS = new Set([
+	"0",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9"
+]), FUNCTION_KEYS = new Set([
+	"F1",
+	"F2",
+	"F3",
+	"F4",
+	"F5",
+	"F6",
+	"F7",
+	"F8",
+	"F9",
+	"F10",
+	"F11",
+	"F12"
+]), NAVIGATION_KEYS = new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+]), EDITING_KEYS = new Set([
+	"Enter",
+	"Escape",
+	"Space",
+	"Tab",
+	"Backspace",
+	"Delete"
+]), PUNCTUATION_KEYS = new Set([
+	"/",
+	"[",
+	"]",
+	"\\",
+	"=",
+	"-",
+	",",
+	".",
+	";",
+	"`"
+]), PUNCTUATION_CODE_MAP = {
+	Backquote: "`",
+	Backslash: "\\",
+	BracketLeft: "[",
+	BracketRight: "]",
+	Comma: ",",
+	Equal: "=",
+	Minus: "-",
+	Period: ".",
+	Semicolon: ";",
+	Slash: "/"
+};
+new Set([
+	...LETTER_KEYS,
+	...NUMBER_KEYS,
+	...FUNCTION_KEYS,
+	...NAVIGATION_KEYS,
+	...EDITING_KEYS,
+	...PUNCTUATION_KEYS
+]);
+var KEY_ALIASES = {
+	Esc: "Escape",
+	esc: "Escape",
+	escape: "Escape",
+	Return: "Enter",
+	return: "Enter",
+	enter: "Enter",
+	" ": "Space",
+	space: "Space",
+	Spacebar: "Space",
+	spacebar: "Space",
+	tab: "Tab",
+	backspace: "Backspace",
+	Del: "Delete",
+	del: "Delete",
+	delete: "Delete",
+	Up: "ArrowUp",
+	up: "ArrowUp",
+	arrowup: "ArrowUp",
+	Down: "ArrowDown",
+	down: "ArrowDown",
+	arrowdown: "ArrowDown",
+	Left: "ArrowLeft",
+	left: "ArrowLeft",
+	arrowleft: "ArrowLeft",
+	Right: "ArrowRight",
+	right: "ArrowRight",
+	arrowright: "ArrowRight",
+	home: "Home",
+	end: "End",
+	pageup: "PageUp",
+	pagedown: "PageDown",
+	PgUp: "PageUp",
+	PgDn: "PageDown",
+	pgup: "PageUp",
+	pgdn: "PageDown"
+};
+function isSingleLetterKey(e) {
+	return /^\p{Letter}$/u.test(e);
+}
+function normalizeKeyName(e) {
+	if (!e) return "";
+	if (e in KEY_ALIASES) return KEY_ALIASES[e];
+	if (isSingleLetterKey(e)) {
+		let T = e.toUpperCase();
+		return T.length === 1 ? T : e;
+	}
+	let T = e.toUpperCase();
+	return /^F([1-9]|1[0-2])$/.test(T) ? T : e;
+}
+function parseHotkey(e, T = detectPlatform()) {
+	let E = e.split("+"), D = /* @__PURE__ */ new Set(), O = "";
+	for (let e = 0; e < E.length; e++) {
+		let k = E[e].trim();
+		if (e === E.length - 1) O = normalizeKeyName(k);
+		else {
+			let e = MODIFIER_ALIASES[k] ?? MODIFIER_ALIASES[k.toLowerCase()];
+			if (e) {
+				let E = resolveModifier(e, T);
+				D.add(E);
+			} else E.length === 1 && (O = normalizeKeyName(k));
+		}
+	}
+	return !O && E.length > 0 && (O = normalizeKeyName(E[E.length - 1].trim())), {
+		key: O,
+		ctrl: D.has("Control"),
+		shift: D.has("Shift"),
+		alt: D.has("Alt"),
+		meta: D.has("Meta"),
+		modifiers: MODIFIER_ORDER.filter((e) => D.has(e))
+	};
+}
+function rawHotkeyToParsedHotkey(e, T = detectPlatform()) {
+	let E = e.ctrl ?? !1, D = e.shift ?? !1, O = e.alt ?? !1, k = e.meta ?? !1;
+	e.mod && (resolveModifier("Mod", T) === "Control" ? E = !0 : k = !0);
+	let A = MODIFIER_ORDER.filter((e) => {
+		switch (e) {
+			case "Control": return E;
+			case "Shift": return D;
+			case "Alt": return O;
+			case "Meta": return k;
+			default: return !1;
+		}
+	});
+	return {
+		key: e.key,
+		ctrl: E,
+		shift: D,
+		alt: O,
+		meta: k,
+		modifiers: A
+	};
+}
+function normalizedHotkeyStringFromParsed(e, T) {
+	let E = T === "mac" ? e.meta && !e.ctrl : e.ctrl && !e.meta, D = [];
+	if (E) D.push("Mod"), e.alt && D.push("Alt"), e.shift && D.push("Shift");
+	else for (let T of MODIFIER_ORDER) e.modifiers.includes(T) && D.push(T);
+	return D.push(normalizeKeyName(e.key)), D.join("+");
+}
+function normalizeHotkey(e, T = detectPlatform()) {
+	return normalizedHotkeyStringFromParsed(parseHotkey(e, T), T);
+}
+function normalizeHotkeyFromParsed(e, T = detectPlatform()) {
+	return normalizedHotkeyStringFromParsed(e, T);
+}
+function normalizeRegisterableHotkey(e, T = detectPlatform()) {
+	return typeof e == "string" ? normalizeHotkey(e, T) : normalizeHotkeyFromParsed(rawHotkeyToParsedHotkey(e, T), T);
+}
+function isModifierKey(e) {
+	return e in MODIFIER_ALIASES || e.toLowerCase() in MODIFIER_ALIASES;
+}
+function formatHotkeySequence(e) {
+	return e.join(" ");
+}
+function formatHotkey(e) {
+	let T = [];
+	for (let E of MODIFIER_ORDER) e.modifiers.includes(E) && T.push(E);
+	return T.push(e.key), T.join("+");
+}
+function matchesKeyboardEvent(e, T, E = detectPlatform()) {
+	let D = typeof T == "string" ? parseHotkey(T, E) : T;
+	if (e.ctrlKey !== D.ctrl || e.shiftKey !== D.shift || e.altKey !== D.alt || e.metaKey !== D.meta) return !1;
+	let O = normalizeKeyName(e.key), k = D.key;
+	if (O !== "Dead" && O.length === 1 && k.length === 1) {
+		if (O.toUpperCase() === k.toUpperCase()) return !0;
+		if (isSingleLetterKey(O) && (/^[A-Za-z]$/.test(O) || !e.altKey)) return !1;
+	}
+	if (e.code && (O === "Dead" || O.length === 1 && k.length === 1)) {
+		if (e.code.startsWith("Key")) {
+			let T = e.code.slice(3);
+			if (T.length === 1 && /^[A-Za-z]$/.test(T)) return T.toUpperCase() === k.toUpperCase();
+		}
+		if (e.code.startsWith("Digit")) {
+			let T = e.code.slice(5);
+			if (T.length === 1 && /^[0-9]$/.test(T)) return T === k;
+		}
+		return e.code in PUNCTUATION_CODE_MAP ? PUNCTUATION_CODE_MAP[e.code] === k : !1;
+	}
+	return O === k;
+}
+var defaultHotkeyOptions = {
+	preventDefault: !0,
+	stopPropagation: !0,
+	eventType: "keydown",
+	enabled: !0,
+	ignoreInputs: !0,
+	conflictBehavior: "warn"
+};
+function getDefaultIgnoreInputs(e) {
+	return !(e.ctrl || e.meta || e.key === "Escape");
+}
+function isInputElement(e) {
+	if (!e) return !1;
+	if (e instanceof HTMLInputElement) {
+		let T = e.type.toLowerCase();
+		return !(T === "button" || T === "submit" || T === "reset");
+	}
+	return !!(e instanceof HTMLTextAreaElement || e instanceof HTMLSelectElement || e instanceof HTMLElement && e.isContentEditable);
+}
+function getActiveElementForListenerTarget(e) {
+	return typeof document > "u" ? null : typeof Document < "u" && e instanceof Document || typeof Node < "u" && e.nodeType === Node.DOCUMENT_NODE ? e.activeElement : typeof HTMLElement < "u" && e instanceof HTMLElement ? e.ownerDocument.activeElement ?? null : e.document.activeElement ?? null;
+}
+function shouldIgnoreInputEvent(e, T, E) {
+	let D = getActiveElementForListenerTarget(T);
+	return D && isInputElement(D) && D !== E || e.composedPath().some((e) => isInputElement(e) && e !== E) ? !0 : isInputElement(e.target) && e.target !== E;
+}
+function isEventForTarget(e, T) {
+	return T === document || T === window ? e.currentTarget === T || e.currentTarget === document.documentElement : T === window ? e.currentTarget === window || e.currentTarget === document || e.currentTarget === document.documentElement : !!(T instanceof HTMLElement && (e.currentTarget === T || e.target instanceof Node && T.contains(e.target)));
+}
+function handleConflict(e, T, E, D) {
+	if (E !== "allow") {
+		if (E === "warn") {
+			console.warn(`'${T}' is already registered. Multiple handlers will be triggered. Use conflictBehavior: 'replace' to replace the existing handler, or conflictBehavior: 'allow' to suppress this warning.`);
+			return;
+		}
+		if (E === "error") throw Error(`'${T}' is already registered. Use conflictBehavior: 'replace' to replace the existing handler, or conflictBehavior: 'allow' to allow multiple registrations.`);
+		D(e);
+	}
+}
+var ReactiveFlags = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.Mutable = 1] = "Mutable", e[e.Watching = 2] = "Watching", e[e.RecursedCheck = 4] = "RecursedCheck", e[e.Recursed = 8] = "Recursed", e[e.Dirty = 16] = "Dirty", e[e.Pending = 32] = "Pending", e;
+}({});
+/* @__NO_SIDE_EFFECTS__ */
+function createReactiveSystem({ update: e, notify: T, unwatched: E }) {
+	return {
+		link: D,
+		unlink: O,
+		propagate: k,
+		checkDirty: A,
+		shallowPropagate: j
+	};
+	function D(e, T, E) {
+		let D = T.depsTail;
+		if (D !== void 0 && D.dep === e) return;
+		let O = D === void 0 ? T.deps : D.nextDep;
+		if (O !== void 0 && O.dep === e) {
+			O.version = E, T.depsTail = O;
+			return;
+		}
+		let k = e.subsTail;
+		if (k !== void 0 && k.version === E && k.sub === T) return;
+		let A = T.depsTail = e.subsTail = {
+			version: E,
+			dep: e,
+			sub: T,
+			prevDep: D,
+			nextDep: O,
+			prevSub: k,
+			nextSub: void 0
+		};
+		O !== void 0 && (O.prevDep = A), D === void 0 ? T.deps = A : D.nextDep = A, k === void 0 ? e.subs = A : k.nextSub = A;
+	}
+	function O(e, T = e.sub) {
+		let D = e.dep, O = e.prevDep, k = e.nextDep, A = e.nextSub, j = e.prevSub;
+		return k === void 0 ? T.depsTail = O : k.prevDep = O, O === void 0 ? T.deps = k : O.nextDep = k, A === void 0 ? D.subsTail = j : A.prevSub = j, j === void 0 ? (D.subs = A) === void 0 && E(D) : j.nextSub = A, k;
+	}
+	function k(e) {
+		let E = e.nextSub, D;
+		top: do {
+			let O = e.sub, k = O.flags;
+			if (k & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed | ReactiveFlags.Dirty | ReactiveFlags.Pending) ? k & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed) ? k & ReactiveFlags.RecursedCheck ? !(k & (ReactiveFlags.Dirty | ReactiveFlags.Pending)) && M(e, O) ? (O.flags = k | (ReactiveFlags.Recursed | ReactiveFlags.Pending), k &= ReactiveFlags.Mutable) : k = ReactiveFlags.None : O.flags = k & ~ReactiveFlags.Recursed | ReactiveFlags.Pending : k = ReactiveFlags.None : O.flags = k | ReactiveFlags.Pending, k & ReactiveFlags.Watching && T(O), k & ReactiveFlags.Mutable) {
+				let T = O.subs;
+				if (T !== void 0) {
+					let O = (e = T).nextSub;
+					O !== void 0 && (D = {
+						value: E,
+						prev: D
+					}, E = O);
+					continue;
+				}
+			}
+			if ((e = E) !== void 0) {
+				E = e.nextSub;
+				continue;
+			}
+			for (; D !== void 0;) if (e = D.value, D = D.prev, e !== void 0) {
+				E = e.nextSub;
+				continue top;
+			}
+			break;
+		} while (!0);
+	}
+	function A(T, E) {
+		let D, O = 0, k = !1;
+		top: do {
+			let A = T.dep, M = A.flags;
+			if (E.flags & ReactiveFlags.Dirty) k = !0;
+			else if ((M & (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) === (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) {
+				if (e(A)) {
+					let e = A.subs;
+					e.nextSub !== void 0 && j(e), k = !0;
+				}
+			} else if ((M & (ReactiveFlags.Mutable | ReactiveFlags.Pending)) === (ReactiveFlags.Mutable | ReactiveFlags.Pending)) {
+				(T.nextSub !== void 0 || T.prevSub !== void 0) && (D = {
+					value: T,
+					prev: D
+				}), T = A.deps, E = A, ++O;
+				continue;
+			}
+			if (!k) {
+				let e = T.nextDep;
+				if (e !== void 0) {
+					T = e;
+					continue;
+				}
+			}
+			for (; O--;) {
+				let O = E.subs, A = O.nextSub !== void 0;
+				if (A ? (T = D.value, D = D.prev) : T = O, k) {
+					if (e(E)) {
+						A && j(O), E = T.sub;
+						continue;
+					}
+					k = !1;
+				} else E.flags &= ~ReactiveFlags.Pending;
+				E = T.sub;
+				let M = T.nextDep;
+				if (M !== void 0) {
+					T = M;
+					continue top;
+				}
+			}
+			return k;
+		} while (!0);
+	}
+	function j(e) {
+		do {
+			let E = e.sub, D = E.flags;
+			(D & (ReactiveFlags.Pending | ReactiveFlags.Dirty)) === ReactiveFlags.Pending && (E.flags = D | ReactiveFlags.Dirty, (D & (ReactiveFlags.Watching | ReactiveFlags.RecursedCheck)) === ReactiveFlags.Watching && T(E));
+		} while ((e = e.nextSub) !== void 0);
+	}
+	function M(e, T) {
+		let E = T.depsTail;
+		for (; E !== void 0;) {
+			if (E === e) return !0;
+			E = E.prevDep;
+		}
+		return !1;
+	}
+}
+function toObserver(e, T, E) {
+	let D = typeof e == "object", O = D ? e : void 0;
+	return {
+		next: (D ? e.next : e)?.bind(O),
+		error: (D ? e.error : T)?.bind(O),
+		complete: (D ? e.complete : E)?.bind(O)
+	};
+}
+var queuedEffects = [], cycle = 0, { link, unlink, propagate, checkDirty, shallowPropagate } = /* @__PURE__ */ createReactiveSystem({
+	update(e) {
+		return e._update();
+	},
+	notify(e) {
+		queuedEffects[queuedEffectsLength++] = e, e.flags &= ~ReactiveFlags.Watching;
+	},
+	unwatched(e) {
+		e.depsTail !== void 0 && (e.depsTail = void 0, e.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty, purgeDeps(e));
+	}
+}), notifyIndex = 0, queuedEffectsLength = 0, activeSub, batchDepth = 0;
+function purgeDeps(e) {
+	let T = e.depsTail, E = T === void 0 ? e.deps : T.nextDep;
+	for (; E !== void 0;) E = unlink(E, e);
+}
+function flush() {
+	if (!(batchDepth > 0)) {
+		for (; notifyIndex < queuedEffectsLength;) {
+			let e = queuedEffects[notifyIndex];
+			queuedEffects[notifyIndex++] = void 0, e.notify();
+		}
+		notifyIndex = 0, queuedEffectsLength = 0;
+	}
+}
+function createAtom(e, T) {
+	let E = typeof e == "function", D = e, O = {
+		_snapshot: E ? void 0 : e,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: E ? ReactiveFlags.None : ReactiveFlags.Mutable,
+		get() {
+			return activeSub !== void 0 && link(O, activeSub, cycle), O._snapshot;
+		},
+		subscribe(e) {
+			let T = toObserver(e), E = { current: !1 }, D = effect(() => {
+				O.get(), E.current ? T.next?.(O._snapshot) : E.current = !0;
+			});
+			return { unsubscribe: () => {
+				D.stop();
+			} };
+		},
+		_update(e) {
+			let k = activeSub, A = T?.compare ?? Object.is;
+			if (E) activeSub = O, ++cycle, O.depsTail = void 0;
+			else if (e === void 0) return !1;
+			E && (O.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck);
+			try {
+				let T = O._snapshot, k = typeof e == "function" ? e(T) : e === void 0 && E ? D(T) : e;
+				return T === void 0 || !A(T, k) ? (O._snapshot = k, !0) : !1;
+			} finally {
+				activeSub = k, E && (O.flags &= ~ReactiveFlags.RecursedCheck), purgeDeps(O);
+			}
+		}
+	};
+	return E ? (O.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty, O.get = function() {
+		let e = O.flags;
+		if (e & ReactiveFlags.Dirty || e & ReactiveFlags.Pending && checkDirty(O.deps, O)) {
+			if (O._update()) {
+				let e = O.subs;
+				e !== void 0 && shallowPropagate(e);
+			}
+		} else e & ReactiveFlags.Pending && (O.flags = e & ~ReactiveFlags.Pending);
+		return activeSub !== void 0 && link(O, activeSub, cycle), O._snapshot;
+	}) : O.set = function(e) {
+		if (O._update(e)) {
+			let e = O.subs;
+			e !== void 0 && (propagate(e), shallowPropagate(e), flush());
+		}
+	}, O;
+}
+function effect(e) {
+	let T = () => {
+		let T = activeSub;
+		activeSub = E, ++cycle, E.depsTail = void 0, E.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
+		try {
+			return e();
+		} finally {
+			activeSub = T, E.flags &= ~ReactiveFlags.RecursedCheck, purgeDeps(E);
+		}
+	}, E = {
+		deps: void 0,
+		depsTail: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
+		notify() {
+			let e = this.flags;
+			e & ReactiveFlags.Dirty || e & ReactiveFlags.Pending && checkDirty(this.deps, this) ? T() : this.flags = ReactiveFlags.Watching;
+		},
+		stop() {
+			this.flags = ReactiveFlags.None, this.depsTail = void 0, purgeDeps(this);
+		}
+	};
+	return T(), E;
+}
+var Store = class {
+	constructor(e, T) {
+		this.atom = createAtom(e), this.get = this.get.bind(this), this.setState = this.setState.bind(this), this.subscribe = this.subscribe.bind(this), T && (this.actions = T(this));
+	}
+	setState(e) {
+		this.atom.set(e);
+	}
+	get state() {
+		return this.atom.get();
+	}
+	get() {
+		return this.state;
+	}
+	subscribe(e) {
+		return this.atom.subscribe(toObserver(e));
+	}
+}, registrationIdCounter = 0;
+function generateId() {
+	return `hotkey_${++registrationIdCounter}`;
+}
+var HotkeyManager = class e {
+	static #e = null;
+	#t;
+	#n = /* @__PURE__ */ new Map();
+	#r = /* @__PURE__ */ new Map();
+	constructor() {
+		this.registrations = new Store(/* @__PURE__ */ new Map()), this.#t = detectPlatform();
+	}
+	static getInstance() {
+		return e.#e ||= new e(), e.#e;
+	}
+	static resetInstance() {
+		e.#e &&= (e.#e.destroy(), null);
+	}
+	register(e, T, E = {}) {
+		if (typeof document > "u" && !E.target) {
+			let e = T;
+			return {
+				id: generateId(),
+				unregister: () => {},
+				get callback() {
+					return e;
+				},
+				set callback(T) {
+					e = T;
+				},
+				setOptions: () => {},
+				get isActive() {
+					return !1;
+				}
+			};
+		}
+		let D = generateId(), O = E.platform ?? this.#t, k = typeof e == "string" ? parseHotkey(e, O) : rawHotkeyToParsedHotkey(e, O), A = typeof e == "string" ? e : formatHotkey(k), j = E.target ?? document, M = E.conflictBehavior ?? "warn", N = this.#d(A, j);
+		N && handleConflict(N.id, A, M, (e) => this.#i(e));
+		let P = E.ignoreInputs ?? getDefaultIgnoreInputs(k), F = {
+			id: D,
+			hotkey: A,
+			parsedHotkey: k,
+			callback: T,
+			options: {
+				...defaultHotkeyOptions,
+				requireReset: !1,
+				...E,
+				platform: O,
+				ignoreInputs: P
+			},
+			hasFired: !1,
+			triggerCount: 0,
+			target: j
+		};
+		this.registrations.setState((e) => new Map(e).set(D, F)), this.#r.has(j) || this.#r.set(j, /* @__PURE__ */ new Set()), this.#r.get(j).add(D), this.#a(j);
+		let I = this;
+		return {
+			get id() {
+				return D;
+			},
+			unregister: () => {
+				I.#i(D);
+			},
+			get callback() {
+				return I.registrations.state.get(D)?.callback ?? T;
+			},
+			set callback(e) {
+				let T = I.registrations.state.get(D);
+				T && (T.callback = e);
+			},
+			setOptions: (e) => {
+				I.registrations.setState((T) => {
+					let E = T.get(D);
+					if (E) {
+						let O = new Map(T);
+						return O.set(D, {
+							...E,
+							options: {
+								...E.options,
+								...e
+							}
+						}), O;
+					}
+					return T;
+				});
+			},
+			get isActive() {
+				return I.registrations.state.has(D);
+			}
+		};
+	}
+	#i(e) {
+		let T = this.registrations.state.get(e);
+		if (!T) return;
+		let E = T.target;
+		this.registrations.setState((T) => {
+			let E = new Map(T);
+			return E.delete(e), E;
+		});
+		let D = this.#r.get(E);
+		D && (D.delete(e), D.size === 0 && this.#o(E));
+	}
+	#a(e) {
+		if (typeof document > "u" || this.#n.has(e)) return;
+		let T = this.#l(e), E = this.#u(e);
+		e.addEventListener("keydown", T), e.addEventListener("keyup", E), this.#n.set(e, {
+			keydown: T,
+			keyup: E
+		});
+	}
+	#o(e) {
+		if (typeof document > "u") return;
+		let T = this.#n.get(e);
+		T && (e.removeEventListener("keydown", T.keydown), e.removeEventListener("keyup", T.keyup), this.#n.delete(e), this.#r.delete(e));
+	}
+	#s(e, T, E) {
+		let D = this.#r.get(T);
+		if (D) for (let O of D) {
+			let D = this.registrations.state.get(O);
+			if (D && isEventForTarget(e, T) && D.options.enabled && !(D.options.ignoreInputs !== !1 && shouldIgnoreInputEvent(e, T, D.target))) if (E === "keydown") {
+				if (D.options.eventType !== "keydown") continue;
+				matchesKeyboardEvent(e, D.parsedHotkey, D.options.platform) && (D.options.preventDefault && e.preventDefault(), D.options.stopPropagation && e.stopPropagation(), (!D.options.requireReset || !D.hasFired) && (this.#c(D, e), D.options.requireReset && (D.hasFired = !0)));
+			} else D.options.eventType === "keyup" && matchesKeyboardEvent(e, D.parsedHotkey, D.options.platform) && this.#c(D, e), D.options.requireReset && D.hasFired && this.#f(D, e) && (D.hasFired = !1);
+		}
+	}
+	#c(e, T) {
+		e.options.preventDefault && T.preventDefault(), e.options.stopPropagation && T.stopPropagation(), e.triggerCount++, this.registrations.setState((e) => new Map(e));
+		let E = {
+			hotkey: e.hotkey,
+			parsedHotkey: e.parsedHotkey
+		};
+		e.callback(T, E);
+	}
+	#l(e) {
+		return (T) => {
+			this.#s(T, e, "keydown");
+		};
+	}
+	#u(e) {
+		return (T) => {
+			this.#s(T, e, "keyup");
+		};
+	}
+	#d(e, T) {
+		for (let E of this.registrations.state.values()) if (E.hotkey === e && E.target === T) return E;
+		return null;
+	}
+	#f(e, T) {
+		let E = e.parsedHotkey, D = normalizeKeyName(T.key), O = E.key.length === 1 ? E.key.toUpperCase() : E.key;
+		return !!((D.length === 1 ? D.toUpperCase() : D) === O || E.ctrl && D === "Control" || E.shift && D === "Shift" || E.alt && D === "Alt" || E.meta && D === "Meta");
+	}
+	triggerRegistration(e) {
+		let T = this.registrations.state.get(e);
+		if (!T) return !1;
+		let E = T.parsedHotkey, D = new KeyboardEvent(T.options.eventType ?? "keydown", {
+			key: E.key,
+			ctrlKey: E.ctrl,
+			shiftKey: E.shift,
+			altKey: E.alt,
+			metaKey: E.meta,
+			bubbles: !0,
+			cancelable: !0
+		});
+		return T.triggerCount++, this.registrations.setState((e) => new Map(e)), T.callback(D, {
+			hotkey: T.hotkey,
+			parsedHotkey: T.parsedHotkey
+		}), !0;
+	}
+	getRegistrationCount() {
+		return this.registrations.state.size;
+	}
+	isRegistered(e, T) {
+		for (let E of this.registrations.state.values()) if (E.hotkey === e && (T === void 0 || E.target === T)) return !0;
+		return !1;
+	}
+	destroy() {
+		for (let e of this.#n.keys()) this.#o(e);
+		this.registrations.setState(() => /* @__PURE__ */ new Map()), this.#n.clear(), this.#r.clear();
+	}
+};
+function getHotkeyManager() {
+	return HotkeyManager.getInstance();
+}
+var DEFAULT_SEQUENCE_TIMEOUT = 1e3, sequenceIdCounter = 0;
+function generateSequenceId() {
+	return `sequence_${++sequenceIdCounter}`;
+}
+function sequenceKey(e) {
+	return e.join("|");
+}
+function toRegistrationView(e) {
+	let T = e.parsedSequence.length, E = e.currentIndex > 0 && e.currentIndex < T;
+	return {
+		id: e.id,
+		sequence: e.sequence,
+		options: e.options,
+		target: e.target,
+		triggerCount: e.triggerCount,
+		hasFired: e.hasFired,
+		matchedStepCount: E ? e.currentIndex : 0,
+		partialMatchLastKeyTime: E ? e.lastKeyTime : 0
+	};
+}
+var SequenceManager = class e {
+	static #e = null;
+	#t = /* @__PURE__ */ new Map();
+	#n = /* @__PURE__ */ new Map();
+	#r = /* @__PURE__ */ new Map();
+	#i;
+	constructor() {
+		this.registrations = new Store(/* @__PURE__ */ new Map()), this.#i = detectPlatform();
+	}
+	static getInstance() {
+		return e.#e ||= new e(), e.#e;
+	}
+	static resetInstance() {
+		e.#e &&= (e.#e.destroy(), null);
+	}
+	#a(e) {
+		this.registrations.setState((T) => new Map(T).set(e.id, toRegistrationView(e)));
+	}
+	register(e, T, E = {}) {
+		if (e.length === 0) throw Error("Sequence must contain at least one hotkey");
+		let D = generateSequenceId(), O = E.platform ?? this.#i, k = e.map((e) => parseHotkey(e, O)), A = E.target ?? (typeof document < "u" ? document : {}), j = E.conflictBehavior ?? "warn", M = this.#f(e, A);
+		M && handleConflict(M.id, formatHotkeySequence(e), j, (e) => this.#o(e));
+		let N = k[0], P = E.ignoreInputs ?? getDefaultIgnoreInputs(N), F = {
+			id: D,
+			sequence: e,
+			parsedSequence: k,
+			callback: T,
+			options: {
+				...defaultHotkeyOptions,
+				timeout: DEFAULT_SEQUENCE_TIMEOUT,
+				...E,
+				platform: O,
+				ignoreInputs: P
+			},
+			target: A,
+			currentIndex: 0,
+			lastKeyTime: 0,
+			triggerCount: 0,
+			hasFired: !1
+		};
+		this.#t.set(D, F), this.registrations.setState((e) => new Map(e).set(D, toRegistrationView(F))), this.#r.has(A) || this.#r.set(A, /* @__PURE__ */ new Set()), this.#r.get(A).add(D), this.#s(A);
+		let I = this;
+		return {
+			get id() {
+				return D;
+			},
+			get isActive() {
+				return I.#t.has(D);
+			},
+			get callback() {
+				return I.#t.get(D)?.callback ?? T;
+			},
+			set callback(e) {
+				let T = I.#t.get(D);
+				T && (T.callback = e);
+			},
+			setOptions: (e) => {
+				let T = I.#t.get(D);
+				T && (T.options = {
+					...T.options,
+					...e
+				}, I.registrations.setState((e) => new Map(e).set(D, toRegistrationView(T))));
+			},
+			unregister: () => {
+				I.#o(D);
+			}
+		};
+	}
+	#o(e) {
+		let T = this.#t.get(e);
+		if (!T) return;
+		let E = T.target;
+		this.#t.delete(e), this.registrations.setState((T) => {
+			let E = new Map(T);
+			return E.delete(e), E;
+		});
+		let D = this.#r.get(E);
+		D && (D.delete(e), D.size === 0 && this.#c(E));
+	}
+	#s(e) {
+		if (typeof document > "u" || this.#n.has(e)) return;
+		let T = this.#l(e), E = this.#u(e);
+		e.addEventListener("keydown", T), e.addEventListener("keyup", E), this.#n.set(e, {
+			keydown: T,
+			keyup: E
+		});
+	}
+	#c(e) {
+		if (typeof document > "u") return;
+		let T = this.#n.get(e);
+		T && (e.removeEventListener("keydown", T.keydown), e.removeEventListener("keyup", T.keyup), this.#n.delete(e), this.#r.delete(e));
+	}
+	#l(e) {
+		return (T) => {
+			this.#d(T, e, "keydown");
+		};
+	}
+	#u(e) {
+		return (T) => {
+			this.#d(T, e, "keyup");
+		};
+	}
+	#d(e, T, E) {
+		if (isModifierKey(normalizeKeyName(e.key))) return;
+		let D = this.#r.get(T);
+		if (!D) return;
+		let O = Date.now();
+		registrationIds: for (let k of D) {
+			let D = this.#t.get(k);
+			if (!D || !isEventForTarget(e, T) || !D.options.enabled) continue;
+			if (D.options.ignoreInputs !== !1 && shouldIgnoreInputEvent(e, T, D.target)) continue registrationIds;
+			if (D.options.eventType !== E) continue;
+			let A = D.options.timeout ?? 1e3;
+			D.currentIndex > 0 && O - D.lastKeyTime > A && (D.currentIndex = 0, this.#a(D));
+			let j = D.parsedSequence[D.currentIndex];
+			if (j) {
+				if (matchesKeyboardEvent(e, j, D.options.platform)) if (D.lastKeyTime = O, D.currentIndex++, D.currentIndex >= D.parsedSequence.length) {
+					D.options.preventDefault && e.preventDefault(), D.options.stopPropagation && e.stopPropagation();
+					let T = {
+						hotkey: D.sequence.join(" "),
+						parsedHotkey: D.parsedSequence[D.parsedSequence.length - 1]
+					};
+					D.triggerCount++, D.hasFired = !0, D.currentIndex = 0, this.#a(D), D.callback(e, T);
+				} else this.#a(D);
+				else if (D.currentIndex > 0) {
+					let T = D.parsedSequence[0];
+					matchesKeyboardEvent(e, T, D.options.platform) ? (D.currentIndex = 1, D.lastKeyTime = O) : D.currentIndex = 0, this.#a(D);
+				}
+			}
+		}
+	}
+	#f(e, T) {
+		let E = sequenceKey(e);
+		for (let e of this.#t.values()) if (sequenceKey(e.sequence) === E && e.target === T) return e;
+		return null;
+	}
+	resetAll() {
+		for (let e of this.#t.values()) e.currentIndex = 0, e.lastKeyTime = 0, this.#a(e);
+	}
+	triggerSequence(e) {
+		let T = this.#t.get(e);
+		if (!T) return !1;
+		let E = T.parsedSequence[T.parsedSequence.length - 1];
+		if (!E) return !1;
+		let D = new KeyboardEvent(T.options.eventType ?? "keydown", {
+			key: E.key,
+			ctrlKey: E.ctrl,
+			shiftKey: E.shift,
+			altKey: E.alt,
+			metaKey: E.meta,
+			bubbles: !0,
+			cancelable: !0
+		});
+		T.triggerCount++, T.hasFired = !0, this.#a(T);
+		let O = {
+			hotkey: T.sequence.join(" "),
+			parsedHotkey: E
+		};
+		return T.callback(D, O), !0;
+	}
+	getRegistrationCount() {
+		return this.#t.size;
+	}
+	destroy() {
+		for (let e of this.#n.keys()) this.#c(e);
+		this.#t.clear(), this.registrations.setState(() => /* @__PURE__ */ new Map());
+	}
+};
+function getSequenceManager() {
+	return SequenceManager.getInstance();
+}
+function useHotkeys(e, T = {}) {
+	let E = useDefaultHotkeysOptions(), D = getHotkeyManager(), O = /* @__PURE__ */ new Map(), k = watch(() => {
+		let D = resolveMaybeRefOrGetter$1(e), O = resolveMaybeRefOrGetter$1(T);
+		return D.map((e, T) => {
+			let D = resolveMaybeRefOrGetter$1(e.hotkey), k = e.options ? resolveMaybeRefOrGetter$1(e.options) : {}, A = {
+				...E.hotkey,
+				...O,
+				...k
+			}, j = normalizeRegisterableHotkey(D, A.platform ?? detectPlatform()), M = A.enabled === void 0 ? void 0 : resolveMaybeRefOrGetter$1(A.enabled), N = A.target === void 0 ? void 0 : resolveMaybeRefOrGetter$1(A.target);
+			return {
+				index: T,
+				hotkeyString: j,
+				callback: e.callback,
+				mergedOptions: A,
+				resolvedEnabled: M,
+				resolvedTarget: N
+			};
+		});
+	}, (e) => {
+		let T = /* @__PURE__ */ new Set(), E = [];
+		for (let D of e) {
+			let e = D.resolvedTarget ?? (typeof document < "u" ? document : null);
+			if (!e) continue;
+			let O = `${D.index}:${D.hotkeyString}`;
+			T.add(O), E.push({
+				registrationKey: O,
+				entry: D,
+				finalTarget: e
+			});
+		}
+		for (let [e, E] of [...O.entries()]) T.has(e) || (E.handle.isActive && E.handle.unregister(), O.delete(e));
+		for (let { registrationKey: e, entry: T, finalTarget: k } of E) {
+			let E = O.get(e);
+			if (E?.handle.isActive && E.target === k) {
+				E.handle.callback = T.callback;
+				let { target: e, enabled: D, ...O } = T.mergedOptions, k = {
+					...O,
+					...T.resolvedEnabled === void 0 ? {} : { enabled: T.resolvedEnabled }
+				};
+				E.handle.setOptions(k);
+				continue;
+			}
+			E && (E.handle.isActive && E.handle.unregister(), O.delete(e));
+			let { target: A, enabled: j, ...M } = T.mergedOptions, N = {
+				...M,
+				...T.resolvedEnabled === void 0 ? {} : { enabled: T.resolvedEnabled }
+			}, P = D.register(T.hotkeyString, T.callback, {
+				...N,
+				target: k
+			});
+			O.set(e, {
+				handle: P,
+				target: k
+			});
+		}
+	}, { immediate: !0 });
+	onUnmounted(() => {
+		k();
+		for (let { handle: e } of O.values()) e.isActive && e.unregister();
+		O.clear();
+	});
+}
+function resolveMaybeRefOrGetter$1(e) {
+	return typeof e == "function" ? e() : unref(e);
+}
+function useHotkeySequences(e, T = {}) {
+	let E = useDefaultHotkeysOptions(), D = getSequenceManager(), O = /* @__PURE__ */ new Map(), k = watch(() => {
+		let D = resolveMaybeRefOrGetter(e), O = resolveMaybeRefOrGetter(T);
+		return D.map((e, T) => {
+			let D = resolveMaybeRefOrGetter(e.sequence), k = e.options ? resolveMaybeRefOrGetter(e.options) : {}, A = {
+				...E.hotkeySequence,
+				...O,
+				...k
+			}, j = formatHotkeySequence(D), M = A.enabled === void 0 ? void 0 : resolveMaybeRefOrGetter(A.enabled), N = A.target === void 0 ? void 0 : resolveMaybeRefOrGetter(A.target);
+			return {
+				index: T,
+				resolvedSequence: D,
+				sequenceString: j,
+				callback: e.callback,
+				mergedOptions: A,
+				resolvedEnabled: M,
+				resolvedTarget: N
+			};
+		});
+	}, (e) => {
+		let T = /* @__PURE__ */ new Set(), E = [];
+		for (let D of e) {
+			if (D.resolvedSequence.length === 0) continue;
+			let e = D.resolvedTarget ?? (typeof document < "u" ? document : null);
+			if (!e) continue;
+			let O = `${D.index}:${D.sequenceString}`;
+			T.add(O), E.push({
+				registrationKey: O,
+				entry: D,
+				finalTarget: e
+			});
+		}
+		for (let [e, E] of [...O.entries()]) T.has(e) || (E.handle.isActive && E.handle.unregister(), O.delete(e));
+		for (let { registrationKey: e, entry: T, finalTarget: k } of E) {
+			let E = O.get(e);
+			if (E?.handle.isActive && E.target === k) {
+				E.handle.callback = T.callback;
+				let { target: e, enabled: D, ...O } = T.mergedOptions, k = {
+					...O,
+					...T.resolvedEnabled === void 0 ? {} : { enabled: T.resolvedEnabled }
+				};
+				E.handle.setOptions(k);
+				continue;
+			}
+			E && (E.handle.isActive && E.handle.unregister(), O.delete(e));
+			let { target: A, enabled: j, ...M } = T.mergedOptions, N = {
+				...M,
+				...T.resolvedEnabled === void 0 ? {} : { enabled: T.resolvedEnabled }
+			}, P = D.register(T.resolvedSequence, T.callback, {
+				...N,
+				target: k
+			});
+			O.set(e, {
+				handle: P,
+				target: k
+			});
+		}
+	}, { immediate: !0 });
+	onUnmounted(() => {
+		k();
+		for (let { handle: e } of O.values()) e.isActive && e.unregister();
+		O.clear();
+	});
+}
+function resolveMaybeRefOrGetter(e) {
+	return typeof e == "function" ? e() : unref(e);
+}
+const useActionRegistryStore = defineStore("actionRegistry", () => {
+	let e = ref([]), T = ref(/* @__PURE__ */ new Map()), E = 1;
+	function D() {
+		return [...e.value, ...T.value.values().map((e) => e)];
+	}
+	function O(...T) {
+		e.value.push(...T);
+	}
+	function k(e) {
+		let D = E++;
+		return T.value.set(D, markRaw(e)), D;
+	}
+	function j(e) {
+		T.value.delete(e);
+	}
+	return {
+		allActions: D,
+		registerActions: O,
+		registerTemporaryAction: k,
+		unregisterAction: j
+	};
+});
+function* collectActionsForShortcuts(e, T) {
+	for (let E of e) {
+		if (yield E, E.subActionsHaveKeyboardShortcuts !== !0 || E.subActions === void 0) continue;
+		let e = E.subActions(T);
+		Array.isArray(e) ? yield* collectActionsForShortcuts(e, T) : typeof e == "object" && e && "actions" in e && Array.isArray(e.actions) && (yield* collectActionsForShortcuts(e.actions, T));
+	}
+}
+function simpleShortcutKey(e) {
+	return [
+		e.key,
+		e.alt === !0 ? "alt" : "",
+		e.ctrl === !0 ? "ctrl" : "",
+		e.meta === !0 ? "meta" : "",
+		e.mod === !0 ? "mod" : "",
+		e.shift === !0 ? "shift" : ""
+	].filter(Boolean).join("+");
+}
+function useActionShortcuts(e) {
+	let T = useActionRegistryStore(), E = useActionManagerStore();
+	function D(T) {
+		return () => {
+			let D = e ? e() : E.actionContext({});
+			for (let e = T.length - 1; e >= 0; e--) {
+				let E = T[e];
+				if (!resolveApplicable(E, D)) continue;
+				let O = E.execute?.(D);
+				O instanceof Promise && O.catch((e) => {
+					console.error("[useActionShortcuts] action.execute threw:", e);
+				});
+				return;
+			}
+		};
+	}
+	useHotkeys(() => {
+		let O = /* @__PURE__ */ new Map(), k = e ? e() : E.actionContext({});
+		for (let e of collectActionsForShortcuts(T.allActions(), k)) {
+			if (e.keyboardShortcut === void 0 || "sequence" in e.keyboardShortcut) continue;
+			let T = e.keyboardShortcut, E = simpleShortcutKey(T);
+			O.has(E) || O.set(E, []), O.get(E).push(e);
+		}
+		return Array.from(O.values()).map((e) => {
+			let T = e[0].keyboardShortcut;
+			return {
+				callback: D(e),
+				hotkey: {
+					key: T.key,
+					...T.alt !== void 0 && { alt: T.alt },
+					...T.ctrl !== void 0 && { ctrl: T.ctrl },
+					...T.meta !== void 0 && { meta: T.meta },
+					...T.mod !== void 0 && { mod: T.mod },
+					...T.shift !== void 0 && { shift: T.shift }
+				},
+				options: {
+					ignoreInputs: !T.runWithInputFocus,
+					preventDefault: !0,
+					stopPropagation: !0
+				}
+			};
+		});
+	}, { conflictBehavior: "allow" }), useHotkeySequences(() => {
+		let O = /* @__PURE__ */ new Map(), k = e ? e() : E.actionContext({});
+		for (let e of collectActionsForShortcuts(T.allActions(), k)) {
+			if (e.keyboardShortcut === void 0 || !("sequence" in e.keyboardShortcut)) continue;
+			let T = e.keyboardShortcut.sequence.join(",");
+			O.has(T) || O.set(T, []), O.get(T).push(e);
+		}
+		return Array.from(O.values()).map((e) => {
+			let T = e[0].keyboardShortcut;
+			return {
+				callback: D(e),
+				options: {
+					ignoreInputs: !T.runWithInputFocus,
+					preventDefault: !0,
+					stopPropagation: !0
+				},
+				sequence: T.sequence
+			};
+		});
+	}, { conflictBehavior: "allow" });
+}
+function useCommandMenuActions({ actionsSnapshot: e, focusedModelsSnapshot: E, listboxContentRef: D, listboxRootRef: O, manager: k, navStack: A, searchInput: j }) {
+	let M = ref(!1), N = ref(!1), P = shallowRef([]), F = ref({}), I = 0, z = computed(() => D.value?.$el);
+	function B(e) {
+		return k.actionContext({
+			menuType: "commandMenu",
+			models: E,
+			searchInput: j.value,
+			subActionsMeta: e
+		});
+	}
+	async function H() {
+		let T = ++I;
+		N.value = !1, M.value = !0;
+		try {
+			let E = B(), D;
+			if (A.value.length > 0) {
+				let e = A.value.at(-1);
+				D = e.parentAction.subActions === void 0 ? e.actions : await resolveSubActions(e.parentAction, E, F.value);
+			} else D = e;
+			let O = await applicableActions(D, E, (e) => {
+				T === I && e.length > 0 && (P.value = e);
+			}, A.value.at(-1)?.parentAction);
+			T === I && (P.value = O);
+		} catch (e) {
+			throw console.error("Error refreshing actions", e), e;
+		} finally {
+			T === I && (M.value = !1);
+		}
+	}
+	let U = useDebounceFn(H, 80);
+	return watch(j, () => {
+		F.value = {}, N.value = !0, (D.value?.$el)?.scrollTo({
+			behavior: "instant",
+			top: 0
+		}), U();
+	}), watch(P, (e, T) => {
+		if (e.length === 0) return;
+		let E = O.value?.$el;
+		setTimeout(() => {
+			(E?.querySelector("[data-highlighted]") ?? null) === null && O.value?.highlightFirstItem();
+		}), T.length === 0 && setTimeout(() => {
+			(D.value?.$el)?.scrollTo({
+				behavior: "instant",
+				top: 0
+			});
+		});
+	}), useInfiniteScroll(z, async () => {
+		let e = A.value.at(-1)?.parentAction;
+		if (e?.subActions === void 0 || e.id === void 0) return;
+		let T = F.value[e.id];
+		if (T == null) return;
+		let E = B({ [e.id]: T }), D = e.subActions(E), O;
+		if (Array.isArray(D) || isSubActionsWithMeta(D)) O = D;
+		else if (D instanceof Promise) O = await D;
+		else {
+			let e = [];
+			for await (let T of D) e.push(T);
+			P.value = [...P.value, ...e];
+			return;
+		}
+		P.value = [...P.value, ...storeSubActionsPagination(e, O, F.value)];
+	}, {
+		canLoadMore: () => {
+			let e = A.value.at(-1)?.parentAction;
+			return e?.subActions === void 0 || e.id === void 0 ? !1 : F.value[e.id] != null;
+		},
+		distance: 40
+	}), {
+		isDebouncing: N,
+		isLoadingActions: M,
+		buildContext: B,
+		refreshActions: H,
+		resolvedActions: P,
+		subActionsMetaMap: F
+	};
+}
+function useCommandMenuAnimation(e, T) {
+	let E = ref(!1), D = ref(!1), O = null;
+	return watch(e, (e) => {
+		e || (D.value = !1);
+	}), watch(T, () => {
+		D.value = !0, O !== null && (clearTimeout(O), E.value = !1), nextTick(() => {
+			E.value = !0, O = setTimeout(() => {
+				E.value = !1;
+			}, 250);
+		});
+	}), {
+		hasNavigated: D,
+		isBouncing: E
+	};
+}
+function useCommandMenuNavigation({ isShiftKeyHeld: e, buildContext: E, emit: D, listboxRootRef: O, manager: k, navStack: A, refreshActions: j, resolvedActions: M, scrollToTopOfGroup: N, searchInput: P, subActionsMetaMap: F }) {
+	let I = useI18n(), R = ref(null), z = computed(() => A.value.at(-1)?.parentAction ?? null), B = computed(() => {
+		let e = E();
+		return A.value.filter((e) => e.parentAction.forceAsRootMenu !== !0).map((T) => {
+			let E = T.parentAction;
+			return E.nameAsParent === void 0 ? resolveActionValue(E.name, e) : typeof E.nameAsParent == "function" ? E.nameAsParent(e) : E.nameAsParent;
+		});
+	}), V = computed(() => {
+		if (z.value === null) return I.t("type_a_command_or_search");
+		let e = resolveSearchSubActionsConfig(z.value, E())?.placeholder;
+		return e === void 0 ? I.t("search") : typeof e == "function" ? e() : e;
+	}), { preview: U, onKeyDown: W } = useActionPreview({
+		highlightedActionId: R,
+		getContext: E,
+		resolvedActions: M
+	});
+	async function G(T) {
+		let O = E();
+		if (!T.disabledReason?.(O)) {
+			if (T.execute !== void 0) {
+				k.executeAction(T, O), (!(z.value?.multiSelectSubActions ?? !1) || !e.value) && D("close");
+				return;
+			}
+			T.subActions !== void 0 && (A.value.push({
+				actions: [],
+				parentAction: T,
+				savedActiveAction: T,
+				savedResolvedActions: M.value,
+				savedSearchInput: P.value
+			}), F.value = {}, P.value = "", M.value = [], await j());
+		}
+	}
+	async function K() {
+		let e = A.value.pop() ?? null;
+		e !== null && (P.value = e.savedSearchInput, M.value = e.savedResolvedActions, await j(), e.savedActiveAction !== null && O.value?.highlightItem(e.savedActiveAction.id));
+	}
+	function q(e) {
+		e.key === "Backspace" && !e.repeat && P.value === "" && A.value.length > 0 && (e.preventDefault(), K()), (e.key === "ArrowDown" || e.key === "ArrowUp") && N(), W(e);
+	}
+	return {
+		highlightedActionId: R,
+		activateAction: G,
+		breadcrumbs: B,
+		currentParent: z,
+		placeholder: V,
+		preview: U,
+		restoreParentFrame: K,
+		onKeyDown: q
+	};
+}
+function resolveActionBreadcrumbs(e, T) {
+	let E = [], D = e.parentAction ?? null;
+	for (; D !== null;) {
+		if (D.forceAsRootMenu === !0) return E;
+		let e = D.nameAsParent === void 0 ? resolveActionName(D, T) : resolveActionValue(D.nameAsParent, T);
+		E.unshift({
+			icon: D.icon?.(T) ?? null,
+			label: e
+		}), D = D.parentAction ?? null;
+	}
+	return E.slice(-1);
+}
+function useFocusedModels(e) {
+	let T = useActionManagerStore(), E = ref(!1);
+	function D() {
+		E.value = !0, T.setFocusedModels([...T.focusedModels, ...e.value]);
+	}
+	function O() {
+		E.value = !1, T.setFocusedModels(T.focusedModels.filter((T) => !e.value.some((e) => e.key === T.key)));
+	}
+	return watch(e, (D, O) => {
+		E.value && T.setFocusedModels([...T.focusedModels.filter((e) => !O.some((T) => T.key === e.key)), ...e.value]);
+	}), onBeforeUnmount(() => {
+		O();
+	}), {
+		register: D,
+		unregister: O
+	};
+}
+function useTemporaryActions(e, T, E = !1) {
+	let D = useActionRegistryStore(), O = [];
+	function k() {
+		O.length > 0 || (O = (Array.isArray(e) ? e : [e]).map((e) => D.registerTemporaryAction(j(e))));
+	}
+	function A() {
+		for (let e of O) D.unregisterAction(e);
+		O = [];
+	}
+	function j(e) {
+		return T === void 0 ? e : {
+			...e,
+			group: {
+				...e.group,
+				priority: T
+			}
+		};
+	}
+	return E || (k(), onBeforeUnmount(() => {
+		A();
+	})), {
+		register: k,
+		unregister: A
+	};
+}
+function useActiveModels(e, T) {
+	let E = useActionManagerStore();
+	function D() {
+		T === "focused" ? E.setFocusedModels([...E.focusedModels, ...e.value]) : E.setViewModels([...E.viewModels, ...e.value]);
+	}
+	function O() {
+		T === "focused" ? E.setFocusedModels(E.focusedModels.filter((T) => !e.value.some((e) => e.key === T.key))) : E.setViewModels(E.viewModels.filter((T) => !e.value.some((e) => e.key === T.key)));
+	}
+	watch(e, () => {
+		O(), D();
+	}), D(), onBeforeUnmount(() => {
+		O();
+	});
+}
+function useViewModels(e) {
+	useActiveModels(e, "view");
+}
+var _unnamedGroupCounter = 0, _unnamedGroupKeys = /* @__PURE__ */ new WeakMap();
+function resolveStableGroupKey(e, T) {
+	return e === void 0 ? "no-group" : e.name ? resolveActionValue(e.name, T) : (_unnamedGroupKeys.has(e) || _unnamedGroupKeys.set(e, `unnamed-${_unnamedGroupCounter++}`), _unnamedGroupKeys.get(e));
+}
+function buildCommandMenuGroups(e, T) {
+	let E = /* @__PURE__ */ new Map();
+	for (let D of e) {
+		let e = D.group, O = resolveStableGroupKey(e, T), k = E.get(O);
+		if (k === void 0) {
+			let D = e?.name ? resolveActionValue(e.name, T) : null;
+			k = {
+				category: e?.category ? resolveActionValue(e.category, T) : null,
+				icon: e?.icon?.(T) ?? null,
+				items: [],
+				key: O,
+				label: D,
+				showIfOnlyGroup: e?.showIfOnlyGroup ?? !1
+			}, E.set(O, k);
+		}
+		k.items.push(D);
+	}
+	return [...E.values()];
+}
+export { GroupPriority, _createUntypedAction, actionsLocales, applicableActions, buildCommandMenuGroups, createActions, isAuthenticated, isSubActionsWithMeta, resolveActionAvatar, resolveActionBreadcrumbs, resolveActionHint, resolveActionName, resolveActionPreview, resolveActionSelected, resolveActionValue, resolveApplicable, resolveSearchSubActionsConfig, resolveSubActions, storeSubActionsPagination, typedActionDropdownMenu, typedActionFocus, typedActionTrigger, useActionDropdownMenuContent, useActionGroup, useActionManagerStore, useActionPreview, useActionRegistryStore, useActionShortcuts, useCommandMenuActions, useCommandMenuAnimation, useCommandMenuNavigation, useFocusedModels, useTemporaryActions, useViewModels };