businesslens 0.2.2

package/.output/server/chunks/build/Slideover-KOfskX1l.mjs

@@ -0,0 +1,4226 @@
+import { t as useComponentProps, Q as useLocale, v as useAppConfig, C as useForwardProps, D as reactivePick, E as usePortal, z as tv, G as FieldGroupReset, V as VisuallyHidden_default, f as _sfc_main$8, p as useForwardExpose, P as Primitive, T as Teleport_default, k as useVModel, a4 as useEmitAsProps, s as Presence_default, j as injectConfigProviderContext, o as useForwardProps$1, n as createContext, a5 as onKeyStroke, l as isNullish, h as unrefElement, a3 as tryOnBeforeUnmount, ae as computedEager, i as getActiveElement, a7 as AUTOFOCUS_ON_MOUNT, a8 as focusFirst$1, a9 as getTabbableCandidates, aa as focus, ab as AUTOFOCUS_ON_UNMOUNT, a2 as createSharedComposable, ac as EVENT_OPTIONS, ad as getTabbableEdges, a6 as createGlobalState } from './server.mjs';
+import * as vue from 'vue';
+import { useSlots, toRef, computed, unref, mergeProps, withCtx, renderSlot, toHandlers, createTextVNode, toDisplayString, openBlock, createBlock, createCommentVNode, createVNode, defineComponent, normalizeProps, guardReactiveProps, ref, toRefs, withModifiers, createElementBlock, normalizeStyle, watchPostEffect, watch, watchEffect, mergeDefaults, reactive, toValue as toValue$1, nextTick, shallowRef, getCurrentScope, onScopeDispose, shallowReadonly, useSSRContext } from 'vue';
+import { ssrRenderComponent, ssrRenderSlot, ssrInterpolate, ssrRenderClass } from 'vue/server-renderer';
+
+const useBodyLockStackCount = createSharedComposable(() => {
+  const map = ref(/* @__PURE__ */ new Map());
+  ref();
+  const locked = computed(() => {
+    for (const value of map.value.values()) if (value) return true;
+    return false;
+  });
+  injectConfigProviderContext({ scrollBody: ref(true) });
+  watch(locked, (val, oldVal) => {
+    return;
+  }, {
+    immediate: true,
+    flush: "sync"
+  });
+  return map;
+});
+function useBodyScrollLock(initialState) {
+  const id = Math.random().toString(36).substring(2, 7);
+  const map = useBodyLockStackCount();
+  map.value.set(id, initialState ?? false);
+  const locked = computed({
+    get: () => map.value.get(id) ?? false,
+    set: (value) => map.value.set(id, value)
+  });
+  tryOnBeforeUnmount();
+  return locked;
+}
+function useDirection(dir) {
+  const context2 = injectConfigProviderContext({ dir: ref("ltr") });
+  return computed(() => dir?.value || context2.dir?.value || "ltr");
+}
+function useFocusGuards() {
+  watchEffect((cleanupFn) => {
+    return;
+  });
+}
+function useForwardPropsEmits(props, emit) {
+  const parsedProps = useForwardProps$1(props);
+  const emitsAsProps = emit ? useEmitAsProps(emit) : {};
+  return computed(() => ({
+    ...parsedProps.value,
+    ...emitsAsProps
+  }));
+}
+var getDefaultParent = function(originalTarget) {
+  {
+    return null;
+  }
+};
+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);
+  });
+};
+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 = {};
+    }
+  };
+};
+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 = getDefaultParent();
+  if (!activeParentNode) {
+    return function() {
+      return null;
+    };
+  }
+  targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll("[aria-live], script")));
+  return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden");
+};
+function useHideOthers(target) {
+  let undo;
+  watch(() => unrefElement(target), (el) => {
+    let isInsideClosedPopover = false;
+    try {
+      isInsideClosedPopover = !!el?.closest("[popover]:not(:popover-open)");
+    } catch {
+    }
+    if (el && !isInsideClosedPopover) undo = hideOthers(el);
+    else if (undo) undo();
+  });
+}
+let count = 0;
+function useId(deterministicId, prefix = "reka") {
+  if (deterministicId) return deterministicId;
+  let id;
+  const configProviderContext = injectConfigProviderContext({ useId: void 0 });
+  if (configProviderContext.useId) id = configProviderContext.useId();
+  else if ("useId" in vue) id = vue.useId?.();
+  else id = `${++count}`;
+  return prefix ? `${prefix}-${id}` : id;
+}
+function useSize(element) {
+  const size2 = ref();
+  const width = computed(() => size2.value?.width ?? 0);
+  const height = computed(() => size2.value?.height ?? 0);
+  return {
+    width,
+    height
+  };
+}
+const [injectDialogRootContext, provideDialogRootContext] = /* @__PURE__ */ createContext("DialogRoot");
+var DialogRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  inheritAttrs: false,
+  __name: "DialogRoot",
+  props: {
+    open: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    defaultOpen: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    modal: {
+      type: Boolean,
+      required: false,
+      default: true
+    }
+  },
+  emits: ["update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const open = useVModel(props, "open", emit, {
+      defaultValue: props.defaultOpen,
+      passive: props.open === void 0
+    });
+    const triggerElement = ref();
+    const contentElement = ref();
+    const { modal } = toRefs(props);
+    provideDialogRootContext({
+      open,
+      modal,
+      openModal: () => {
+        open.value = true;
+      },
+      onOpenChange: (value) => {
+        open.value = value;
+      },
+      onOpenToggle: () => {
+        open.value = !open.value;
+      },
+      contentId: "",
+      titleId: "",
+      descriptionId: "",
+      triggerElement,
+      contentElement
+    });
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default", {
+        open: unref(open),
+        close: () => open.value = false
+      });
+    };
+  }
+});
+var DialogRoot_default = DialogRoot_vue_vue_type_script_setup_true_lang_default;
+var DialogClose_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogClose",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "button"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    useForwardExpose();
+    const rootContext = injectDialogRootContext();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, {
+        type: _ctx.as === "button" ? "button" : void 0,
+        onClick: _cache[0] || (_cache[0] = ($event) => unref(rootContext).onOpenChange(false))
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, ["type"]);
+    };
+  }
+});
+var DialogClose_default = DialogClose_vue_vue_type_script_setup_true_lang_default;
+function usePointerDownOutside(onPointerDownOutside, element, enabled = true) {
+  element?.value?.ownerDocument ?? globalThis?.document;
+  const isPointerInsideDOMTree = ref(false);
+  ref(() => {
+  });
+  watchEffect((cleanupFn) => {
+    return;
+  });
+  return { onPointerDownCapture: () => {
+    if (!toValue$1(enabled)) return;
+    isPointerInsideDOMTree.value = true;
+  } };
+}
+function useFocusOutside(onFocusOutside, element, enabled = true) {
+  element?.value?.ownerDocument ?? globalThis?.document;
+  const isFocusInsideDOMTree = ref(false);
+  watchEffect((cleanupFn) => {
+    return;
+  });
+  return {
+    onFocusCapture: () => {
+      if (!toValue$1(enabled)) return;
+      isFocusInsideDOMTree.value = true;
+    },
+    onBlurCapture: () => {
+      if (!toValue$1(enabled)) return;
+      isFocusInsideDOMTree.value = false;
+    }
+  };
+}
+const context = /* @__PURE__ */ reactive({
+  layersRoot: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  originalBodyPointerEvents: void 0,
+  branches: /* @__PURE__ */ new Set()
+});
+var DismissableLayer_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DismissableLayer",
+  props: {
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "dismiss"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { forwardRef, currentElement: layerElement } = useForwardExpose();
+    const ownerDocument = computed(() => layerElement.value?.ownerDocument ?? globalThis.document);
+    const layers = computed(() => context.layersRoot);
+    const index = computed(() => {
+      return layerElement.value ? Array.from(layers.value).indexOf(layerElement.value) : -1;
+    });
+    const isBodyPointerEventsDisabled = computed(() => {
+      return context.layersWithOutsidePointerEventsDisabled.size > 0;
+    });
+    const isPointerEventsEnabled = computed(() => {
+      const localLayers = Array.from(layers.value);
+      const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
+      const highestLayerWithOutsidePointerEventsDisabledIndex = localLayers.indexOf(highestLayerWithOutsidePointerEventsDisabled);
+      return index.value >= highestLayerWithOutsidePointerEventsDisabledIndex;
+    });
+    const pointerDownOutside2 = usePointerDownOutside(async (event) => {
+      const isPointerDownOnBranch = [...context.branches].some((branch) => branch?.contains(event.target));
+      if (!isPointerEventsEnabled.value || isPointerDownOnBranch) return;
+      emits("pointerDownOutside", event);
+      emits("interactOutside", event);
+      await nextTick();
+      if (!event.defaultPrevented) emits("dismiss");
+    }, layerElement);
+    const focusOutside = useFocusOutside((event) => {
+      const isFocusInBranch = [...context.branches].some((branch) => branch?.contains(event.target));
+      if (isFocusInBranch) return;
+      emits("focusOutside", event);
+      emits("interactOutside", event);
+      if (!event.defaultPrevented) emits("dismiss");
+    }, layerElement);
+    onKeyStroke("Escape", (event) => {
+      const isHighestLayer = index.value === layers.value.size - 1;
+      if (!isHighestLayer) return;
+      emits("escapeKeyDown", event);
+      if (!event.defaultPrevented) emits("dismiss");
+    });
+    watch([layerElement, () => props.disableOutsidePointerEvents], ([element, disableOutsidePointerEvents], _, onCleanup) => {
+      if (!element) return;
+      if (disableOutsidePointerEvents) {
+        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
+          context.originalBodyPointerEvents = ownerDocument.value.body.style.pointerEvents;
+          ownerDocument.value.body.style.pointerEvents = "none";
+        }
+        context.layersWithOutsidePointerEventsDisabled.add(element);
+        onCleanup(() => {
+          context.layersWithOutsidePointerEventsDisabled.delete(element);
+          if (context.layersWithOutsidePointerEventsDisabled.size === 0 && !isNullish(context.originalBodyPointerEvents)) ownerDocument.value.body.style.pointerEvents = context.originalBodyPointerEvents;
+        });
+      }
+      layers.value.add(element);
+    }, { immediate: true });
+    watchEffect((cleanupFn) => {
+      cleanupFn(() => {
+        if (!layerElement.value) return;
+        layers.value.delete(layerElement.value);
+        context.layersWithOutsidePointerEventsDisabled.delete(layerElement.value);
+      });
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        ref: unref(forwardRef),
+        "as-child": _ctx.asChild,
+        as: _ctx.as,
+        "data-dismissable-layer": "",
+        style: normalizeStyle({ pointerEvents: isBodyPointerEventsDisabled.value ? isPointerEventsEnabled.value ? "auto" : "none" : void 0 }),
+        onFocusCapture: unref(focusOutside).onFocusCapture,
+        onBlurCapture: unref(focusOutside).onBlurCapture,
+        onPointerdownCapture: unref(pointerDownOutside2).onPointerDownCapture
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 8, [
+        "as-child",
+        "as",
+        "style",
+        "onFocusCapture",
+        "onBlurCapture",
+        "onPointerdownCapture"
+      ]);
+    };
+  }
+});
+var DismissableLayer_default = DismissableLayer_vue_vue_type_script_setup_true_lang_default;
+const useFocusStackState = createGlobalState(() => {
+  const stack = ref([]);
+  return stack;
+});
+function createFocusScopesStack() {
+  const stack = useFocusStackState();
+  return {
+    add(focusScope) {
+      const activeFocusScope = stack.value[0];
+      if (focusScope !== activeFocusScope) activeFocusScope?.pause();
+      stack.value = arrayRemove(stack.value, focusScope);
+      stack.value.unshift(focusScope);
+    },
+    remove(focusScope) {
+      stack.value = arrayRemove(stack.value, focusScope);
+      stack.value[0]?.resume();
+    }
+  };
+}
+function arrayRemove(array, item) {
+  const updatedArray = [...array];
+  const index = updatedArray.indexOf(item);
+  if (index !== -1) updatedArray.splice(index, 1);
+  return updatedArray;
+}
+var FocusScope_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "FocusScope",
+  props: {
+    loop: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    trapped: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: ["mountAutoFocus", "unmountAutoFocus"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { currentRef, currentElement } = useForwardExpose();
+    ref(null);
+    const focusScopesStack = createFocusScopesStack();
+    const focusScope = /* @__PURE__ */ reactive({
+      paused: false,
+      pause() {
+        this.paused = true;
+      },
+      resume() {
+        this.paused = false;
+      }
+    });
+    watchEffect((cleanupFn) => {
+      return;
+    });
+    watchEffect(async (cleanupFn) => {
+      const container = currentElement.value;
+      await nextTick();
+      if (!container) return;
+      focusScopesStack.add(focusScope);
+      const previouslyFocusedElement = getActiveElement();
+      const hasFocusedCandidate = container.contains(previouslyFocusedElement);
+      if (!hasFocusedCandidate) {
+        const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
+        container.addEventListener(AUTOFOCUS_ON_MOUNT, (ev) => emits("mountAutoFocus", ev));
+        container.dispatchEvent(mountEvent);
+        if (!mountEvent.defaultPrevented) {
+          focusFirst$1(getTabbableCandidates(container), { select: true });
+          if (getActiveElement() === previouslyFocusedElement) focus(container);
+        }
+      }
+      cleanupFn(() => {
+        container.removeEventListener(AUTOFOCUS_ON_MOUNT, (ev) => emits("mountAutoFocus", ev));
+        const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
+        const unmountEventHandler = (ev) => {
+          emits("unmountAutoFocus", ev);
+        };
+        container.addEventListener(AUTOFOCUS_ON_UNMOUNT, unmountEventHandler);
+        container.dispatchEvent(unmountEvent);
+        container.setAttribute("data-focus-scope-unmounting", "");
+        setTimeout(() => {
+          if (!unmountEvent.defaultPrevented) focus(previouslyFocusedElement ?? (void 0).body, { select: true });
+          container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, unmountEventHandler);
+          focusScopesStack.remove(focusScope);
+          container.removeAttribute("data-focus-scope-unmounting");
+        }, 0);
+      });
+    });
+    function handleKeyDown(event) {
+      if (!props.loop && !props.trapped) return;
+      if (focusScope.paused) return;
+      const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+      const focusedElement = getActiveElement();
+      if (isTabKey && focusedElement) {
+        const container = event.currentTarget;
+        const [first, last] = getTabbableEdges(container);
+        const hasTabbableElementsInside = first && last;
+        if (!hasTabbableElementsInside) {
+          if (focusedElement === container) event.preventDefault();
+        } else if (!event.shiftKey && focusedElement === last) {
+          event.preventDefault();
+          if (props.loop) focus(first, { select: true });
+        } else if (event.shiftKey && focusedElement === first) {
+          event.preventDefault();
+          if (props.loop) focus(last, { select: true });
+        }
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        ref_key: "currentRef",
+        ref: currentRef,
+        tabindex: "-1",
+        "as-child": _ctx.asChild,
+        as: _ctx.as,
+        onKeydown: handleKeyDown
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 8, ["as-child", "as"]);
+    };
+  }
+});
+var FocusScope_default = FocusScope_vue_vue_type_script_setup_true_lang_default;
+function getOpenState(open) {
+  return open ? "open" : "closed";
+}
+function focusFirst(candidates) {
+  const PREVIOUSLY_FOCUSED_ELEMENT = getActiveElement();
+  for (const candidate of candidates) {
+    if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
+    candidate.focus();
+    if (getActiveElement() !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+  }
+}
+var DialogContentImpl_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogContentImpl",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    trapFocus: {
+      type: Boolean,
+      required: false
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const rootContext = injectDialogRootContext();
+    const { forwardRef, currentElement: contentElement } = useForwardExpose();
+    rootContext.titleId ||= useId(void 0, "reka-dialog-title");
+    rootContext.descriptionId ||= useId(void 0, "reka-dialog-description");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(FocusScope_default), {
+        "as-child": "",
+        loop: "",
+        trapped: props.trapFocus,
+        onMountAutoFocus: _cache[5] || (_cache[5] = ($event) => emits("openAutoFocus", $event)),
+        onUnmountAutoFocus: _cache[6] || (_cache[6] = ($event) => emits("closeAutoFocus", $event))
+      }, {
+        default: withCtx(() => [createVNode(unref(DismissableLayer_default), mergeProps({
+          id: unref(rootContext).contentId,
+          ref: unref(forwardRef),
+          as: _ctx.as,
+          "as-child": _ctx.asChild,
+          "disable-outside-pointer-events": _ctx.disableOutsidePointerEvents,
+          role: "dialog",
+          "aria-describedby": unref(rootContext).descriptionId,
+          "aria-labelledby": unref(rootContext).titleId,
+          "data-state": unref(getOpenState)(unref(rootContext).open.value)
+        }, _ctx.$attrs, {
+          onDismiss: _cache[0] || (_cache[0] = ($event) => unref(rootContext).onOpenChange(false)),
+          onEscapeKeyDown: _cache[1] || (_cache[1] = ($event) => emits("escapeKeyDown", $event)),
+          onFocusOutside: _cache[2] || (_cache[2] = ($event) => emits("focusOutside", $event)),
+          onInteractOutside: _cache[3] || (_cache[3] = ($event) => emits("interactOutside", $event)),
+          onPointerDownOutside: _cache[4] || (_cache[4] = ($event) => emits("pointerDownOutside", $event))
+        }), {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 16, [
+          "id",
+          "as",
+          "as-child",
+          "disable-outside-pointer-events",
+          "aria-describedby",
+          "aria-labelledby",
+          "data-state"
+        ])]),
+        _: 3
+      }, 8, ["trapped"]);
+    };
+  }
+});
+var DialogContentImpl_default = DialogContentImpl_vue_vue_type_script_setup_true_lang_default;
+var DialogContentModal_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogContentModal",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    trapFocus: {
+      type: Boolean,
+      required: false
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const rootContext = injectDialogRootContext();
+    const emitsAsProps = useEmitAsProps(emits);
+    const { forwardRef, currentElement } = useForwardExpose();
+    useHideOthers(currentElement);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(DialogContentImpl_default, mergeProps({
+        ...props,
+        ...unref(emitsAsProps)
+      }, {
+        ref: unref(forwardRef),
+        "trap-focus": unref(rootContext).open.value,
+        "disable-outside-pointer-events": props.disableOutsidePointerEvents,
+        onCloseAutoFocus: _cache[0] || (_cache[0] = (event) => {
+          if (!event.defaultPrevented) {
+            event.preventDefault();
+            unref(rootContext).triggerElement.value?.focus();
+          }
+        }),
+        onPointerDownOutside: _cache[1] || (_cache[1] = (event) => {
+          const originalEvent = event.detail.originalEvent;
+          const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
+          const isRightClick = originalEvent.button === 2 || ctrlLeftClick;
+          if (isRightClick) event.preventDefault();
+        }),
+        onFocusOutside: _cache[2] || (_cache[2] = (event) => {
+          event.preventDefault();
+        })
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, ["trap-focus", "disable-outside-pointer-events"]);
+    };
+  }
+});
+var DialogContentModal_default = DialogContentModal_vue_vue_type_script_setup_true_lang_default;
+var DialogContentNonModal_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogContentNonModal",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    trapFocus: {
+      type: Boolean,
+      required: false
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const emitsAsProps = useEmitAsProps(emits);
+    useForwardExpose();
+    const rootContext = injectDialogRootContext();
+    const hasInteractedOutsideRef = ref(false);
+    const hasPointerDownOutsideRef = ref(false);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(DialogContentImpl_default, mergeProps({
+        ...props,
+        ...unref(emitsAsProps)
+      }, {
+        "trap-focus": false,
+        "disable-outside-pointer-events": false,
+        onCloseAutoFocus: _cache[0] || (_cache[0] = (event) => {
+          if (!event.defaultPrevented) {
+            if (!hasInteractedOutsideRef.value) unref(rootContext).triggerElement.value?.focus();
+            event.preventDefault();
+          }
+          hasInteractedOutsideRef.value = false;
+          hasPointerDownOutsideRef.value = false;
+        }),
+        onInteractOutside: _cache[1] || (_cache[1] = (event) => {
+          if (!event.defaultPrevented) {
+            hasInteractedOutsideRef.value = true;
+            if (event.detail.originalEvent.type === "pointerdown") hasPointerDownOutsideRef.value = true;
+          }
+          const target = event.target;
+          const targetIsTrigger = unref(rootContext).triggerElement.value?.contains(target);
+          if (targetIsTrigger) event.preventDefault();
+          if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.value) event.preventDefault();
+        })
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+var DialogContentNonModal_default = DialogContentNonModal_vue_vue_type_script_setup_true_lang_default;
+var DialogContent_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogContent",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const rootContext = injectDialogRootContext();
+    const emitsAsProps = useEmitAsProps(emits);
+    const { forwardRef } = useForwardExpose();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Presence_default), { present: _ctx.forceMount || unref(rootContext).open.value }, {
+        default: withCtx(() => [unref(rootContext).modal.value ? (openBlock(), createBlock(DialogContentModal_default, mergeProps({
+          key: 0,
+          ref: unref(forwardRef)
+        }, {
+          ...props,
+          ...unref(emitsAsProps),
+          ..._ctx.$attrs
+        }), {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 16)) : (openBlock(), createBlock(DialogContentNonModal_default, mergeProps({
+          key: 1,
+          ref: unref(forwardRef)
+        }, {
+          ...props,
+          ...unref(emitsAsProps),
+          ..._ctx.$attrs
+        }), {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 16))]),
+        _: 3
+      }, 8, ["present"]);
+    };
+  }
+});
+var DialogContent_default = DialogContent_vue_vue_type_script_setup_true_lang_default;
+var DialogDescription_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogDescription",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "p"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    useForwardExpose();
+    const rootContext = injectDialogRootContext();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, { id: unref(rootContext).descriptionId }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, ["id"]);
+    };
+  }
+});
+var DialogDescription_default = DialogDescription_vue_vue_type_script_setup_true_lang_default;
+var DialogOverlayImpl_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogOverlayImpl",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  setup(__props) {
+    const rootContext = injectDialogRootContext();
+    useBodyScrollLock(true);
+    useForwardExpose();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        as: _ctx.as,
+        "as-child": _ctx.asChild,
+        "data-state": unref(rootContext).open.value ? "open" : "closed",
+        style: { "pointer-events": "auto" },
+        onPointerdown: _cache[0] || (_cache[0] = withModifiers(() => {
+        }, [
+          "left",
+          "self",
+          "prevent"
+        ]))
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 8, [
+        "as",
+        "as-child",
+        "data-state"
+      ]);
+    };
+  }
+});
+var DialogOverlayImpl_default = DialogOverlayImpl_vue_vue_type_script_setup_true_lang_default;
+var DialogOverlay_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogOverlay",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  setup(__props) {
+    const rootContext = injectDialogRootContext();
+    const { forwardRef } = useForwardExpose();
+    return (_ctx, _cache) => {
+      return unref(rootContext)?.modal.value ? (openBlock(), createBlock(unref(Presence_default), {
+        key: 0,
+        present: _ctx.forceMount || unref(rootContext).open.value
+      }, {
+        default: withCtx(() => [createVNode(DialogOverlayImpl_default, mergeProps(_ctx.$attrs, {
+          ref: unref(forwardRef),
+          as: _ctx.as,
+          "as-child": _ctx.asChild
+        }), {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 16, ["as", "as-child"])]),
+        _: 3
+      }, 8, ["present"])) : createCommentVNode("v-if", true);
+    };
+  }
+});
+var DialogOverlay_default = DialogOverlay_vue_vue_type_script_setup_true_lang_default;
+var DialogPortal_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogPortal",
+  props: {
+    to: {
+      type: null,
+      required: false
+    },
+    disabled: {
+      type: Boolean,
+      required: false
+    },
+    defer: {
+      type: Boolean,
+      required: false
+    },
+    forceMount: {
+      type: Boolean,
+      required: false
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Teleport_default), normalizeProps(guardReactiveProps(props)), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+var DialogPortal_default = DialogPortal_vue_vue_type_script_setup_true_lang_default;
+var DialogTitle_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogTitle",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "h2"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const rootContext = injectDialogRootContext();
+    useForwardExpose();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, { id: unref(rootContext).titleId }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, ["id"]);
+    };
+  }
+});
+var DialogTitle_default = DialogTitle_vue_vue_type_script_setup_true_lang_default;
+var DialogTrigger_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogTrigger",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "button"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const rootContext = injectDialogRootContext();
+    const { forwardRef } = useForwardExpose();
+    rootContext.contentId ||= useId(void 0, "reka-dialog-content");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, {
+        ref: unref(forwardRef),
+        type: _ctx.as === "button" ? "button" : void 0,
+        "aria-haspopup": "dialog",
+        "aria-expanded": unref(rootContext).open.value || false,
+        "aria-controls": unref(rootContext).open.value ? unref(rootContext).contentId : void 0,
+        "data-state": unref(rootContext).open.value ? "open" : "closed",
+        onClick: unref(rootContext).onOpenToggle
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, [
+        "type",
+        "aria-expanded",
+        "aria-controls",
+        "data-state",
+        "onClick"
+      ]);
+    };
+  }
+});
+var DialogTrigger_default = DialogTrigger_vue_vue_type_script_setup_true_lang_default;
+const [injectPopperRootContext, providePopperRootContext] = /* @__PURE__ */ createContext("PopperRoot");
+var PopperRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  inheritAttrs: false,
+  __name: "PopperRoot",
+  setup(__props) {
+    const anchor = ref();
+    providePopperRootContext({
+      anchor,
+      onAnchorChange: (element) => anchor.value = element
+    });
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var PopperRoot_default = PopperRoot_vue_vue_type_script_setup_true_lang_default;
+var PopperAnchor_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "PopperAnchor",
+  props: {
+    reference: {
+      type: null,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const { forwardRef, currentElement } = useForwardExpose();
+    const rootContext = injectPopperRootContext();
+    watchPostEffect(() => {
+      rootContext.onAnchorChange(props.reference ?? currentElement.value);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        ref: unref(forwardRef),
+        as: _ctx.as,
+        "as-child": _ctx.asChild
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 8, ["as", "as-child"]);
+    };
+  }
+});
+var PopperAnchor_default = PopperAnchor_vue_vue_type_script_setup_true_lang_default;
+const _hoisted_1 = {
+  key: 0,
+  d: "M0 0L6 6L12 0"
+};
+const _hoisted_2 = {
+  key: 1,
+  d: "M0 0L4.58579 4.58579C5.36683 5.36683 6.63316 5.36684 7.41421 4.58579L12 0"
+};
+var Arrow_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "Arrow",
+  props: {
+    width: {
+      type: Number,
+      required: false,
+      default: 10
+    },
+    height: {
+      type: Number,
+      required: false,
+      default: 5
+    },
+    rounded: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "svg"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    useForwardExpose();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, {
+        width: _ctx.width,
+        height: _ctx.height,
+        viewBox: _ctx.asChild ? void 0 : "0 0 12 6",
+        preserveAspectRatio: _ctx.asChild ? void 0 : "none"
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default", {}, () => [!_ctx.rounded ? (openBlock(), createElementBlock("path", _hoisted_1)) : (openBlock(), createElementBlock("path", _hoisted_2))])]),
+        _: 3
+      }, 16, [
+        "width",
+        "height",
+        "viewBox",
+        "preserveAspectRatio"
+      ]);
+    };
+  }
+});
+var Arrow_default = Arrow_vue_vue_type_script_setup_true_lang_default;
+function isNotNull(value) {
+  return value !== null;
+}
+function transformOrigin(options) {
+  return {
+    name: "transformOrigin",
+    options,
+    fn(data) {
+      const { placement, rects, middlewareData } = data;
+      const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;
+      const isArrowHidden = cannotCenterArrow;
+      const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;
+      const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;
+      const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);
+      const noArrowAlign = {
+        start: "0%",
+        center: "50%",
+        end: "100%"
+      }[placedAlign];
+      const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2;
+      const arrowYCenter = (middlewareData.arrow?.y ?? 0) + arrowHeight / 2;
+      let x = "";
+      let y = "";
+      if (placedSide === "bottom") {
+        x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
+        y = `${-arrowHeight}px`;
+      } else if (placedSide === "top") {
+        x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
+        y = `${rects.floating.height + arrowHeight}px`;
+      } else if (placedSide === "right") {
+        x = `${-arrowHeight}px`;
+        y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
+      } else if (placedSide === "left") {
+        x = `${rects.floating.width + arrowHeight}px`;
+        y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
+      }
+      return { data: {
+        x,
+        y
+      } };
+    }
+  };
+}
+function getSideAndAlignFromPlacement(placement) {
+  const [side, align = "center"] = placement.split("-");
+  return [side, align];
+}
+const sides = ["top", "right", "bottom", "left"];
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+  const firstChar = placement[0];
+  return firstChar === "t" || firstChar === "b" ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
+}
+const lrPlacement = ["left", "right"];
+const rlPlacement = ["right", "left"];
+const tbPlacement = ["top", "bottom"];
+const btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl) return isStart ? rlPlacement : lrPlacement;
+      return isStart ? lrPlacement : rlPlacement;
+    case "left":
+    case "right":
+      return isStart ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  const side = getSide(placement);
+  return oppositeSideMap[side] + placement.slice(side.length);
+}
+function expandPaddingObject(padding) {
+  var _padding$top, _padding$right, _padding$bottom, _padding$left;
+  return {
+    top: (_padding$top = padding.top) != null ? _padding$top : 0,
+    right: (_padding$right = padding.right) != null ? _padding$right : 0,
+    bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
+    left: (_padding$left = padding.left) != null ? _padding$left : 0
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  let {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === "y";
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
+    case "top":
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case "bottom":
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case "right":
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case "left":
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  const alignment = getAlignment(placement);
+  if (alignment) {
+    coords[alignmentAxis] += commonAlign * (alignment === "end" ? 1 : -1) * (rtl && isVertical ? -1 : 1);
+  }
+  return coords;
+}
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x,
+    y,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    x,
+    y,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
+  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) && await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
+    x: 1,
+    y: 1
+  };
+  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
+  return {
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+  };
+}
+const MAX_RESET_COUNT = 50;
+const computePosition$1 = async (reference, floating, config) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config;
+  const platformWithDetectOverflow = platform2.detectOverflow ? platform2 : {
+    ...platform2,
+    detectOverflow
+  };
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
+  let rects = await platform2.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let resetCount = 0;
+  const middlewareData = {};
+  for (let i = 0; i < middleware.length; i++) {
+    const currentMiddleware = middleware[i];
+    if (!currentMiddleware) {
+      continue;
+    }
+    const {
+      name,
+      fn
+    } = currentMiddleware;
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platformWithDetectOverflow,
+      elements: {
+        reference,
+        floating
+      }
+    });
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData[name] = {
+      ...middlewareData[name],
+      ...data
+    };
+    if (reset && resetCount < MAX_RESET_COUNT) {
+      resetCount++;
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform2.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+      }
+      i = -1;
+    }
+  }
+  return {
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
+  };
+};
+const arrow$2 = (options) => ({
+  name: "arrow",
+  options,
+  async fn(state) {
+    const {
+      x,
+      y,
+      placement,
+      rects,
+      platform: platform2,
+      elements,
+      middlewareData
+    } = state;
+    const {
+      element,
+      padding = 0
+    } = evaluate(options, state) || {};
+    if (element == null) {
+      return {};
+    }
+    const paddingObject = getPaddingObject(padding);
+    const coords = {
+      x,
+      y
+    };
+    const axis = getAlignmentAxis(placement);
+    const length = getAxisLength(axis);
+    const arrowDimensions = await platform2.getDimensions(element);
+    const isYAxis = axis === "y";
+    const minProp = isYAxis ? "top" : "left";
+    const maxProp = isYAxis ? "bottom" : "right";
+    const clientProp = isYAxis ? "clientHeight" : "clientWidth";
+    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+    const startDiff = coords[axis] - rects.reference[axis];
+    const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
+    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+    if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
+      clientSize = elements.floating[clientProp] || rects.floating[length];
+    }
+    const centerToReference = endDiff / 2 - startDiff / 2;
+    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+    const max2 = clientSize - arrowDimensions[length] - maxPadding;
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset2 = clamp(minPadding, center, max2);
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < minPadding ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < minPadding ? center - minPadding : center - max2 : 0;
+    return {
+      [axis]: coords[axis] + alignmentOffset,
+      data: {
+        [axis]: offset2,
+        centerOffset: center - offset2 - alignmentOffset,
+        ...shouldAddOffset && {
+          alignmentOffset
+        }
+      },
+      reset: shouldAddOffset
+    };
+  }
+});
+const flip$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "flip",
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements2 = [initialPlacement, ...fallbackPlacements];
+      const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides2 = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements2[nextIndex];
+        if (nextPlacement) {
+          const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
+          if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
+          // overflows the main axis.
+          overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
+            return {
+              data: {
+                index: nextIndex,
+                overflows: overflowsData
+              },
+              reset: {
+                placement: nextPlacement
+              }
+            };
+          }
+        }
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
+            case "bestFit": {
+              var _overflowsData$filter2;
+              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+                if (hasFallbackAxisSideDirection) {
+                  const currentSideAxis = getSideAxis(d.placement);
+                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  currentSideAxis === "y";
+                }
+                return true;
+              }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              if (placement2) {
+                resetPlacement = placement2;
+              }
+              break;
+            }
+            case "initialPlacement":
+              resetPlacement = initialPlacement;
+              break;
+          }
+        }
+        if (placement !== resetPlacement) {
+          return {
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+      }
+      return {};
+    }
+  };
+};
+function getSideOffsets(overflow, rect) {
+  return {
+    top: overflow.top - rect.height,
+    right: overflow.right - rect.width,
+    bottom: overflow.bottom - rect.height,
+    left: overflow.left - rect.width
+  };
+}
+function isAnySideFullyClipped(overflow) {
+  return sides.some((side) => overflow[side] >= 0);
+}
+const hide$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "hide",
+    options,
+    async fn(state) {
+      const {
+        rects,
+        platform: platform2
+      } = state;
+      const {
+        strategy = "referenceHidden",
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      switch (strategy) {
+        case "referenceHidden": {
+          const overflow = await platform2.detectOverflow(state, {
+            ...detectOverflowOptions,
+            elementContext: "reference"
+          });
+          const offsets = getSideOffsets(overflow, rects.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: offsets,
+              referenceHidden: isAnySideFullyClipped(offsets)
+            }
+          };
+        }
+        case "escaped": {
+          const overflow = await platform2.detectOverflow(state, {
+            ...detectOverflowOptions,
+            altBoundary: true
+          });
+          const offsets = getSideOffsets(overflow, rects.floating);
+          return {
+            data: {
+              escapedOffsets: offsets,
+              escaped: isAnySideFullyClipped(offsets)
+            }
+          };
+        }
+        default: {
+          return {};
+        }
+      }
+    }
+  };
+};
+const originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+  const {
+    placement,
+    platform: platform2,
+    elements
+  } = state;
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === "y";
+  const mainAxisMulti = originSides.has(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
+  let {
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: rawValue.mainAxis || 0,
+    crossAxis: rawValue.crossAxis || 0,
+    alignmentAxis: rawValue.alignmentAxis
+  };
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
+  } : {
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
+  };
+}
+const offset$1 = function(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
+    name: "offset",
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
+      const {
+        x,
+        y,
+        placement,
+        middlewareData
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
+      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
+        data: {
+          ...diffCoords,
+          placement
+        }
+      };
+    }
+  };
+};
+const shift$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "shift",
+    options,
+    async fn(state) {
+      const {
+        x,
+        y,
+        placement,
+        platform: platform2
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: (_ref) => {
+            let {
+              x: x2,
+              y: y2
+            } = _ref;
+            return {
+              x: x2,
+              y: y2
+            };
+          }
+        },
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
+      const crossAxis = getSideAxis(placement);
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      const clampCoord = (axis, coord) => clamp(coord + overflow[axis === "y" ? "top" : "left"], coord, coord - overflow[axis === "y" ? "bottom" : "right"]);
+      if (checkMainAxis) {
+        mainAxisCoord = clampCoord(mainAxis, mainAxisCoord);
+      }
+      if (checkCrossAxis) {
+        crossAxisCoord = clampCoord(crossAxis, crossAxisCoord);
+      }
+      const limitedCoords = limiter.fn({
+        ...state,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      });
+      return {
+        ...limitedCoords,
+        data: {
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y,
+          enabled: {
+            [mainAxis]: checkMainAxis,
+            [crossAxis]: checkCrossAxis
+          }
+        }
+      };
+    }
+  };
+};
+const limitShift$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    options,
+    fn(state) {
+      var _rawOffset$mainAxis, _rawOffset$crossAxis;
+      const {
+        x,
+        y,
+        placement,
+        rects,
+        middlewareData
+      } = state;
+      const {
+        offset: offset2 = 0,
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const crossAxis = getSideAxis(placement);
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      const rawOffset = evaluate(offset2, state);
+      const computedOffset = typeof rawOffset === "number" ? {
+        mainAxis: rawOffset,
+        crossAxis: 0
+      } : {
+        mainAxis: (_rawOffset$mainAxis = rawOffset.mainAxis) != null ? _rawOffset$mainAxis : 0,
+        crossAxis: (_rawOffset$crossAxis = rawOffset.crossAxis) != null ? _rawOffset$crossAxis : 0
+      };
+      if (checkMainAxis) {
+        const len = mainAxis === "y" ? "height" : "width";
+        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+        if (mainAxisCoord < limitMin) {
+          mainAxisCoord = limitMin;
+        } else if (mainAxisCoord > limitMax) {
+          mainAxisCoord = limitMax;
+        }
+      }
+      if (checkCrossAxis) {
+        var _middlewareData$offse, _middlewareData$offse2;
+        const len = mainAxis === "y" ? "width" : "height";
+        const isOriginSide = originSides.has(getSide(placement));
+        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+        if (crossAxisCoord < limitMin) {
+          crossAxisCoord = limitMin;
+        } else if (crossAxisCoord > limitMax) {
+          crossAxisCoord = limitMax;
+        }
+      }
+      return {
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      };
+    }
+  };
+};
+const size$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "size",
+    options,
+    async fn(state) {
+      const {
+        placement,
+        rects,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        apply = () => {
+        },
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
+      const side = getSide(placement);
+      const alignment = getAlignment(placement);
+      const isYAxis = getSideAxis(placement) === "y";
+      const {
+        width,
+        height
+      } = rects.floating;
+      let heightSide;
+      let widthSide;
+      if (side === "top" || side === "bottom") {
+        heightSide = side;
+        widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
+      } else {
+        widthSide = side;
+        heightSide = alignment === "end" ? "top" : "bottom";
+      }
+      const maximumClippingHeight = height - overflow.top - overflow.bottom;
+      const maximumClippingWidth = width - overflow.left - overflow.right;
+      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
+      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
+      const shiftData = state.middlewareData.shift;
+      const noShift = !shiftData;
+      let availableHeight = overflowAvailableHeight;
+      let availableWidth = overflowAvailableWidth;
+      if (shiftData != null && shiftData.enabled.x) {
+        availableWidth = maximumClippingWidth;
+      }
+      if (shiftData != null && shiftData.enabled.y) {
+        availableHeight = maximumClippingHeight;
+      }
+      if (noShift && !alignment) {
+        if (isYAxis) {
+          availableWidth = width - 2 * max(overflow.left, overflow.right);
+        } else {
+          availableHeight = height - 2 * max(overflow.top, overflow.bottom);
+        }
+      }
+      await apply({
+        ...state,
+        availableWidth,
+        availableHeight
+      });
+      const nextDimensions = await platform2.getDimensions(elements.floating);
+      if (width !== nextDimensions.width || height !== nextDimensions.height) {
+        return {
+          reset: {
+            rects: true
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
+function getNodeName(node) {
+  if (isNode()) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || void 0;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode() ? node.ownerDocument : node.document) || (void 0).document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  {
+    return false;
+  }
+}
+function isElement(value) {
+  {
+    return false;
+  }
+}
+function isHTMLElement(value) {
+  {
+    return false;
+  }
+}
+function isShadowRoot(value) {
+  {
+    return false;
+  }
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
+}
+function isTableElement(element) {
+  return /^(table|td|th)$/.test(getNodeName(element));
+}
+function isTopLayer(element) {
+  try {
+    if (element.matches(":popover-open")) {
+      return true;
+    }
+  } catch (_e) {
+  }
+  try {
+    return element.matches(":modal");
+  } catch (_e) {
+    return false;
+  }
+}
+const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
+const containRe = /paint|layout|strict|content/;
+const isNotNone = (value) => !!value && value !== "none";
+let isWebKitValue;
+function isContainingBlock(elementOrCss) {
+  const css = isElement() ? getComputedStyle$1(elementOrCss) : elementOrCss;
+  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement() && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (isWebKitValue == null) {
+    isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
+  }
+  return isWebKitValue;
+}
+function isLastTraversableNode(node) {
+  return /^(html|body|#document)$/.test(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement()) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot() && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  return isShadowRoot() ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return (node.ownerDocument || node).body;
+  }
+  if (isHTMLElement() && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  } else {
+    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+  }
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+function getCssDimensions(element) {
+  const css = getComputedStyle$1(element);
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement();
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+function unwrapElement$1(element) {
+  return !isElement() ? element.contextElement : element;
+}
+function getScale(element) {
+  const domElement = unwrapElement$1(element);
+  if (!isHTMLElement()) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
+  };
+}
+const noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  return !!floatingOffsetParent && isFixed && floatingOffsetParent === getWindow(element);
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement$1(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement()) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement && offsetParent) {
+    const win = getWindow(domElement);
+    const offsetWin = isElement() ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win;
+    let currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetWin !== currentWin) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle$1(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += left;
+      y += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
+  });
+}
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  if (!rect) {
+    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+  }
+  return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+  const htmlRect = documentElement.getBoundingClientRect();
+  const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
+  const y = htmlRect.top + scroll.scrollTop;
+  return {
+    x,
+    y
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === "fixed";
+  const documentElement = getDocumentElement(offsetParent);
+  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  const isOffsetParentAnElement = isHTMLElement();
+  if (isOffsetParentAnElement || !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+  };
+}
+function getClientRects(element) {
+  return element.getClientRects ? Array.from(element.getClientRects()) : [];
+}
+function getDocumentRect(html) {
+  const scroll = getNodeScroll(html);
+  const body = html.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(html);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle$1(body).direction === "rtl") {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+const SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy, rootBoundary) {
+  if (rootBoundary === void 0) {
+    rootBoundary = "viewport";
+  }
+  const isLayoutViewport = rootBoundary === "layoutViewport";
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+  if (visualViewport) {
+    const layoutRelativeClientCoords = !isWebKit() || strategy === "fixed";
+    if (isLayoutViewport) {
+      if (!layoutRelativeClientCoords) {
+        x = -visualViewport.offsetLeft;
+        y = -visualViewport.offsetTop;
+      }
+    } else {
+      width = visualViewport.width;
+      height = visualViewport.height;
+      if (layoutRelativeClientCoords) {
+        x = visualViewport.offsetLeft;
+        y = visualViewport.offsetTop;
+      }
+    }
+  }
+  const windowScrollbarX = getWindowScrollBarX(html);
+  if (windowScrollbarX <= 0) {
+    const doc = html.ownerDocument;
+    const body = doc.body;
+    const bodyStyles = getComputedStyle(body);
+    const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+    const reservedWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+    const gutter = getComputedStyle(html).scrollbarGutter === "stable both-edges" ? reservedWidth / 2 : reservedWidth;
+    if (gutter <= SCROLLBAR_MAX) {
+      width -= gutter;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = getScale(element);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x = left * scale.x;
+  const y = top * scale.y;
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let rect;
+  if (clippingAncestor === "viewport" || clippingAncestor === "layoutViewport") {
+    rect = getViewportRect(element, strategy, clippingAncestor);
+  } else if (clippingAncestor === "document") {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement()) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y,
+      width: clippingAncestor.width,
+      height: clippingAncestor.height
+    };
+  }
+  return rectToClientRect(rect);
+}
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let result = getOverflowAncestors(element, [], false).filter((el) => isElement() && getNodeName(el) !== "body");
+  let lastKeptComputedStyle = null;
+  const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+  while (isElement() && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle$1(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    const lastPosition = lastKeptComputedStyle ? lastKeptComputedStyle.position : elementIsFixed ? "fixed" : "";
+    const shouldDropCurrentNode = !currentNodeIsContaining && (lastPosition === "fixed" || lastPosition === "absolute" && computedStyle.position === "static");
+    if (shouldDropCurrentNode) {
+      result = result.filter((ancestor) => ancestor !== currentNode);
+    } else {
+      lastKeptComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
+  let top = firstRect.top;
+  let right = firstRect.right;
+  let bottom = firstRect.bottom;
+  let left = firstRect.left;
+  for (let i = 1; i < clippingAncestors.length; i++) {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
+    top = max(rect.top, top);
+    right = min(rect.right, right);
+    bottom = min(rect.bottom, bottom);
+    left = max(rect.left, left);
+  }
+  return {
+    width: right - left,
+    height: bottom - top,
+    x: left,
+    y: top
+  };
+}
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement();
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === "fixed";
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  if (!isOffsetParentAnElement && documentElement) {
+    offsets.x = getWindowScrollBarX(documentElement);
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  return {
+    x,
+    y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isStaticPositioned(element) {
+  return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement() || getComputedStyle$1(element).position === "fixed") {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  let rawOffsetParent = element.offsetParent;
+  if (getDocumentElement(element) === rawOffsetParent) {
+    rawOffsetParent = rawOffsetParent.ownerDocument.body;
+  }
+  return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+  const win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement()) {
+    let svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement() && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
+      }
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
+  }
+  return offsetParent || getContainingBlock(element) || win;
+}
+const getElementRects = async function(data) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
+  const floatingDimensions = await getDimensionsFn(data.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
+  };
+};
+function isRTL(element) {
+  return getComputedStyle$1(element).direction === "rtl";
+}
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function rectsAreEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function observeMove(element, onMove, ancestorResize) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const elementRectForRootMargin = element.getBoundingClientRect();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = elementRectForRootMargin;
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (!rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
+        return refresh();
+      }
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 1e3);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      isFirstUpdate = false;
+    }
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (_e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  const win = getWindow(element);
+  const handleResize = () => refresh(ancestorResize);
+  win.addEventListener("resize", handleResize);
+  refresh(true);
+  return () => {
+    win.removeEventListener("resize", handleResize);
+    cleanup();
+  };
+}
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === "function",
+    layoutShift = typeof IntersectionObserver === "function",
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement$1(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
+  ancestors.forEach((ancestor) => {
+    ancestorScroll && ancestor.addEventListener("scroll", update);
+    ancestorResize && ancestor.addEventListener("resize", update);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update, ancestorResize) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver((_ref) => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+        });
+      }
+      update();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    if (floating) {
+      resizeObserver.observe(floating);
+    }
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
+      update();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update();
+  return () => {
+    var _resizeObserver2;
+    ancestors.forEach((ancestor) => {
+      ancestorScroll && ancestor.removeEventListener("scroll", update);
+      ancestorResize && ancestor.removeEventListener("resize", update);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+const offset = offset$1;
+const shift = shift$1;
+const flip = flip$1;
+const size = size$1;
+const hide = hide$1;
+const arrow$1 = arrow$2;
+const limitShift = limitShift$1;
+const computePosition = (reference, floating, options) => {
+  const cache = /* @__PURE__ */ new Map();
+  const mergedOptions = options != null ? options : {};
+  const platformWithCache = {
+    ...platform,
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
+function isComponentPublicInstance(target) {
+  return target != null && typeof target === "object" && "$el" in target;
+}
+function unwrapElement(target) {
+  if (isComponentPublicInstance(target)) {
+    const element = target.$el;
+    return isNode() && getNodeName(element) === "#comment" ? null : element;
+  }
+  return target;
+}
+function toValue(source) {
+  return typeof source === "function" ? source() : unref(source);
+}
+function arrow(options) {
+  return {
+    name: "arrow",
+    options,
+    fn(args) {
+      const element = unwrapElement(toValue(options.element));
+      if (element == null) {
+        return {};
+      }
+      return arrow$1({
+        element,
+        padding: options.padding
+      }).fn(args);
+    }
+  };
+}
+function getDPR(element) {
+  {
+    return 1;
+  }
+}
+function roundByDPR(element, value) {
+  const dpr = getDPR();
+  return Math.round(value * dpr) / dpr;
+}
+function useFloating(reference, floating, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const whileElementsMountedOption = options.whileElementsMounted;
+  const openOption = computed(() => {
+    var _toValue;
+    return (_toValue = toValue(options.open)) != null ? _toValue : true;
+  });
+  const middlewareOption = computed(() => toValue(options.middleware));
+  const placementOption = computed(() => {
+    var _toValue2;
+    return (_toValue2 = toValue(options.placement)) != null ? _toValue2 : "bottom";
+  });
+  const strategyOption = computed(() => {
+    var _toValue3;
+    return (_toValue3 = toValue(options.strategy)) != null ? _toValue3 : "absolute";
+  });
+  const transformOption = computed(() => {
+    var _toValue4;
+    return (_toValue4 = toValue(options.transform)) != null ? _toValue4 : true;
+  });
+  const referenceElement = computed(() => unwrapElement(reference.value));
+  const floatingElement = computed(() => unwrapElement(floating.value));
+  const x = ref(0);
+  const y = ref(0);
+  const strategy = ref(strategyOption.value);
+  const placement = ref(placementOption.value);
+  const middlewareData = shallowRef({});
+  const isPositioned = ref(false);
+  const floatingStyles = computed(() => {
+    const initialStyles = {
+      position: strategy.value,
+      left: "0",
+      top: "0"
+    };
+    if (!floatingElement.value) {
+      return initialStyles;
+    }
+    const xVal = roundByDPR(floatingElement.value, x.value);
+    const yVal = roundByDPR(floatingElement.value, y.value);
+    if (transformOption.value) {
+      return {
+        ...initialStyles,
+        transform: "translate(" + xVal + "px, " + yVal + "px)",
+        ...getDPR(floatingElement.value) >= 1.5 && {
+          willChange: "transform"
+        }
+      };
+    }
+    return {
+      position: strategy.value,
+      left: xVal + "px",
+      top: yVal + "px"
+    };
+  });
+  let whileElementsMountedCleanup;
+  function update() {
+    if (referenceElement.value == null || floatingElement.value == null) {
+      return;
+    }
+    const open = openOption.value;
+    computePosition(referenceElement.value, floatingElement.value, {
+      middleware: middlewareOption.value,
+      placement: placementOption.value,
+      strategy: strategyOption.value
+    }).then((position) => {
+      x.value = position.x;
+      y.value = position.y;
+      strategy.value = position.strategy;
+      placement.value = position.placement;
+      middlewareData.value = position.middlewareData;
+      isPositioned.value = open !== false;
+    });
+  }
+  function cleanup() {
+    if (typeof whileElementsMountedCleanup === "function") {
+      whileElementsMountedCleanup();
+      whileElementsMountedCleanup = void 0;
+    }
+  }
+  function attach() {
+    cleanup();
+    if (whileElementsMountedOption === void 0) {
+      update();
+      return;
+    }
+    if (referenceElement.value != null && floatingElement.value != null) {
+      whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
+      return;
+    }
+  }
+  function reset() {
+    if (!openOption.value) {
+      isPositioned.value = false;
+    }
+  }
+  watch([middlewareOption, placementOption, strategyOption, openOption], update, {
+    flush: "sync"
+  });
+  watch([referenceElement, floatingElement], attach, {
+    flush: "sync"
+  });
+  watch(openOption, reset, {
+    flush: "sync"
+  });
+  if (getCurrentScope()) {
+    onScopeDispose(cleanup);
+  }
+  return {
+    x: shallowReadonly(x),
+    y: shallowReadonly(y),
+    strategy: shallowReadonly(strategy),
+    placement: shallowReadonly(placement),
+    middlewareData: shallowReadonly(middlewareData),
+    isPositioned: shallowReadonly(isPositioned),
+    floatingStyles,
+    update
+  };
+}
+const PopperContentPropsDefaultValue = {
+  side: "bottom",
+  sideOffset: 0,
+  sideFlip: true,
+  align: "center",
+  alignOffset: 0,
+  alignFlip: true,
+  arrowPadding: 0,
+  hideShiftedArrow: true,
+  avoidCollisions: true,
+  collisionBoundary: () => [],
+  collisionPadding: 0,
+  sticky: "partial",
+  hideWhenDetached: false,
+  positionStrategy: "fixed",
+  updatePositionStrategy: "optimized",
+  prioritizePosition: false
+};
+const [injectPopperContentContext, providePopperContentContext] = /* @__PURE__ */ createContext("PopperContent");
+var PopperContent_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  inheritAttrs: false,
+  __name: "PopperContent",
+  props: /* @__PURE__ */ mergeDefaults({
+    side: {
+      type: null,
+      required: false
+    },
+    sideOffset: {
+      type: Number,
+      required: false
+    },
+    sideFlip: {
+      type: Boolean,
+      required: false
+    },
+    align: {
+      type: null,
+      required: false
+    },
+    alignOffset: {
+      type: Number,
+      required: false
+    },
+    alignFlip: {
+      type: Boolean,
+      required: false
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: false
+    },
+    collisionBoundary: {
+      type: null,
+      required: false
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: false
+    },
+    arrowPadding: {
+      type: Number,
+      required: false
+    },
+    hideShiftedArrow: {
+      type: Boolean,
+      required: false
+    },
+    sticky: {
+      type: String,
+      required: false
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: false
+    },
+    positionStrategy: {
+      type: String,
+      required: false
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: false
+    },
+    disableUpdateOnLayoutShift: {
+      type: Boolean,
+      required: false
+    },
+    prioritizePosition: {
+      type: Boolean,
+      required: false
+    },
+    reference: {
+      type: null,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  }, { ...PopperContentPropsDefaultValue }),
+  emits: ["placed"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const rootContext = injectPopperRootContext();
+    const { forwardRef, currentElement: contentElement } = useForwardExpose();
+    const floatingRef = ref();
+    const arrow$12 = ref();
+    const { width: arrowWidth, height: arrowHeight } = useSize();
+    const desiredPlacement = computed(() => props.side + (props.align !== "center" ? `-${props.align}` : ""));
+    const collisionPadding = computed(() => {
+      return typeof props.collisionPadding === "number" ? props.collisionPadding : {
+        top: 0,
+        right: 0,
+        bottom: 0,
+        left: 0,
+        ...props.collisionPadding
+      };
+    });
+    const boundary = computed(() => {
+      return Array.isArray(props.collisionBoundary) ? props.collisionBoundary : [props.collisionBoundary];
+    });
+    const detectOverflowOptions = computed(() => {
+      return {
+        padding: collisionPadding.value,
+        boundary: boundary.value.filter(isNotNull),
+        altBoundary: boundary.value.length > 0
+      };
+    });
+    const flipOptions = computed(() => {
+      return {
+        mainAxis: props.sideFlip,
+        crossAxis: props.alignFlip
+      };
+    });
+    const computedMiddleware = computedEager(() => {
+      return [
+        offset({
+          mainAxis: props.sideOffset + arrowHeight.value,
+          alignmentAxis: props.alignOffset
+        }),
+        props.prioritizePosition && props.avoidCollisions && flip({
+          ...detectOverflowOptions.value,
+          ...flipOptions.value
+        }),
+        props.avoidCollisions && shift({
+          mainAxis: true,
+          crossAxis: !!props.prioritizePosition,
+          limiter: props.sticky === "partial" ? limitShift() : void 0,
+          ...detectOverflowOptions.value
+        }),
+        !props.prioritizePosition && props.avoidCollisions && flip({
+          ...detectOverflowOptions.value,
+          ...flipOptions.value
+        }),
+        size({
+          ...detectOverflowOptions.value,
+          apply: ({ elements, rects, availableWidth, availableHeight }) => {
+            const { width: anchorWidth, height: anchorHeight } = rects.reference;
+            const contentStyle = elements.floating.style;
+            contentStyle.setProperty("--reka-popper-available-width", `${availableWidth}px`);
+            contentStyle.setProperty("--reka-popper-available-height", `${availableHeight}px`);
+            contentStyle.setProperty("--reka-popper-anchor-width", `${anchorWidth}px`);
+            contentStyle.setProperty("--reka-popper-anchor-height", `${anchorHeight}px`);
+          }
+        }),
+        arrow$12.value && arrow({
+          element: arrow$12.value,
+          padding: props.arrowPadding
+        }),
+        transformOrigin({
+          arrowWidth: arrowWidth.value,
+          arrowHeight: arrowHeight.value
+        }),
+        props.hideWhenDetached && hide({
+          strategy: "referenceHidden",
+          ...detectOverflowOptions.value
+        })
+      ];
+    });
+    const reference = computed(() => props.reference ?? rootContext.anchor.value);
+    const { floatingStyles, placement, isPositioned, middlewareData } = useFloating(reference, floatingRef, {
+      strategy: props.positionStrategy,
+      placement: desiredPlacement,
+      whileElementsMounted: (...args) => {
+        const cleanup = autoUpdate(...args, {
+          layoutShift: !props.disableUpdateOnLayoutShift,
+          animationFrame: props.updatePositionStrategy === "always"
+        });
+        return cleanup;
+      },
+      middleware: computedMiddleware
+    });
+    const placedSide = computed(() => getSideAndAlignFromPlacement(placement.value)[0]);
+    const placedAlign = computed(() => getSideAndAlignFromPlacement(placement.value)[1]);
+    watchPostEffect(() => {
+      if (isPositioned.value) emits("placed");
+    });
+    const shouldHideArrow = computed(() => {
+      const cannotCenterArrow = middlewareData.value.arrow?.centerOffset !== 0;
+      return props.hideShiftedArrow && cannotCenterArrow;
+    });
+    const contentZIndex = ref("");
+    watchEffect(() => {
+      if (contentElement.value) contentZIndex.value = (void 0).getComputedStyle(contentElement.value).zIndex;
+    });
+    const arrowX = computed(() => middlewareData.value.arrow?.x ?? 0);
+    const arrowY = computed(() => middlewareData.value.arrow?.y ?? 0);
+    providePopperContentContext({
+      placedSide,
+      onArrowChange: (element) => arrow$12.value = element,
+      arrowX,
+      arrowY,
+      shouldHideArrow
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "floatingRef",
+        ref: floatingRef,
+        "data-reka-popper-content-wrapper": "",
+        style: normalizeStyle({
+          ...unref(floatingStyles),
+          transform: unref(isPositioned) ? unref(floatingStyles).transform : "translate(0, -200%)",
+          minWidth: "max-content",
+          zIndex: contentZIndex.value,
+          ["--reka-popper-transform-origin"]: [unref(middlewareData).transformOrigin?.x, unref(middlewareData).transformOrigin?.y].join(" "),
+          ...unref(middlewareData).hide?.referenceHidden && {
+            visibility: "hidden",
+            pointerEvents: "none"
+          }
+        })
+      }, [createVNode(unref(Primitive), mergeProps({ ref: unref(forwardRef) }, _ctx.$attrs, {
+        "as-child": props.asChild,
+        as: _ctx.as,
+        "data-side": placedSide.value,
+        "data-align": placedAlign.value,
+        style: { animation: !unref(isPositioned) ? "none" : void 0 }
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, [
+        "as-child",
+        "as",
+        "data-side",
+        "data-align",
+        "style"
+      ])], 4);
+    };
+  }
+});
+var PopperContent_default = PopperContent_vue_vue_type_script_setup_true_lang_default;
+const OPPOSITE_SIDE = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+};
+var PopperArrow_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  inheritAttrs: false,
+  __name: "PopperArrow",
+  props: {
+    width: {
+      type: Number,
+      required: false
+    },
+    height: {
+      type: Number,
+      required: false
+    },
+    rounded: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "svg"
+    }
+  },
+  setup(__props) {
+    const { forwardRef } = useForwardExpose();
+    const contentContext = injectPopperContentContext();
+    const baseSide = computed(() => OPPOSITE_SIDE[contentContext.placedSide.value]);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", {
+        ref: (el) => {
+          unref(contentContext).onArrowChange(el ?? void 0);
+          return void 0;
+        },
+        style: normalizeStyle({
+          position: "absolute",
+          left: unref(contentContext).arrowX?.value ? `${unref(contentContext).arrowX?.value}px` : void 0,
+          top: unref(contentContext).arrowY?.value ? `${unref(contentContext).arrowY?.value}px` : void 0,
+          [baseSide.value]: 0,
+          transformOrigin: {
+            top: "",
+            right: "0 0",
+            bottom: "center 0",
+            left: "100% 0"
+          }[unref(contentContext).placedSide.value],
+          transform: {
+            top: "translateY(100%)",
+            right: "translateY(50%) rotate(90deg) translateX(-50%)",
+            bottom: `rotate(180deg)`,
+            left: "translateY(50%) rotate(-90deg) translateX(50%)"
+          }[unref(contentContext).placedSide.value],
+          visibility: unref(contentContext).shouldHideArrow.value ? "hidden" : void 0
+        })
+      }, [createVNode(Arrow_default, mergeProps(_ctx.$attrs, {
+        ref: unref(forwardRef),
+        style: { display: "block" },
+        as: _ctx.as,
+        "as-child": _ctx.asChild,
+        rounded: _ctx.rounded,
+        width: _ctx.width,
+        height: _ctx.height
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, [
+        "as",
+        "as-child",
+        "rounded",
+        "width",
+        "height"
+      ])], 4);
+    };
+  }
+});
+var PopperArrow_default = PopperArrow_vue_vue_type_script_setup_true_lang_default;
+function pointerDownOutside(e, options = {}) {
+  const originalEvent = e.detail.originalEvent;
+  const target = originalEvent.target;
+  if (!target?.isConnected) {
+    e.preventDefault();
+    return;
+  }
+  if (options.scrollable) {
+    if (originalEvent.offsetX > target.clientWidth || originalEvent.offsetY > target.clientHeight) {
+      e.preventDefault();
+    }
+  }
+}
+const theme = {
+  "slots": {
+    "overlay": "fixed inset-0 bg-elevated/75",
+    "content": "fixed bg-default divide-y divide-default sm:ring ring-default sm:shadow-lg flex flex-col focus:outline-none",
+    "header": "flex items-center gap-1.5 p-4 sm:px-6 min-h-(--ui-header-height)",
+    "wrapper": "",
+    "body": "flex-1 overflow-y-auto p-4 sm:p-6",
+    "footer": "flex items-center gap-1.5 p-4 sm:px-6",
+    "title": "text-highlighted font-semibold",
+    "description": "mt-1 text-muted text-sm",
+    "close": "absolute top-4 end-4"
+  },
+  "variants": {
+    "side": {
+      "top": {
+        "content": ""
+      },
+      "right": {
+        "content": "max-w-md"
+      },
+      "bottom": {
+        "content": ""
+      },
+      "left": {
+        "content": "max-w-md"
+      }
+    },
+    "inset": {
+      "true": {
+        "content": "rounded-lg"
+      }
+    },
+    "transition": {
+      "true": {
+        "overlay": "data-[state=open]:animate-[fade-in_200ms_ease-out] data-[state=closed]:animate-[fade-out_200ms_ease-in]"
+      }
+    }
+  },
+  "compoundVariants": [
+    {
+      "side": "top",
+      "inset": true,
+      "class": {
+        "content": "max-h-[calc(100%-2rem)] inset-x-4 top-4"
+      }
+    },
+    {
+      "side": "top",
+      "inset": false,
+      "class": {
+        "content": "max-h-full inset-x-0 top-0"
+      }
+    },
+    {
+      "side": "right",
+      "inset": true,
+      "class": {
+        "content": "w-[calc(100%-2rem)] inset-y-4 right-4"
+      }
+    },
+    {
+      "side": "right",
+      "inset": false,
+      "class": {
+        "content": "w-full inset-y-0 right-0"
+      }
+    },
+    {
+      "side": "bottom",
+      "inset": true,
+      "class": {
+        "content": "max-h-[calc(100%-2rem)] inset-x-4 bottom-4"
+      }
+    },
+    {
+      "side": "bottom",
+      "inset": false,
+      "class": {
+        "content": "max-h-full inset-x-0 bottom-0"
+      }
+    },
+    {
+      "side": "left",
+      "inset": true,
+      "class": {
+        "content": "w-[calc(100%-2rem)] inset-y-4 left-4"
+      }
+    },
+    {
+      "side": "left",
+      "inset": false,
+      "class": {
+        "content": "w-full inset-y-0 left-0"
+      }
+    },
+    {
+      "transition": true,
+      "side": "top",
+      "class": {
+        "content": "data-[state=open]:animate-[slide-in-from-top_200ms_ease-in-out] data-[state=closed]:animate-[slide-out-to-top_200ms_ease-in-out]"
+      }
+    },
+    {
+      "transition": true,
+      "side": "right",
+      "class": {
+        "content": "data-[state=open]:animate-[slide-in-from-right_200ms_ease-in-out] data-[state=closed]:animate-[slide-out-to-right_200ms_ease-in-out]"
+      }
+    },
+    {
+      "transition": true,
+      "side": "bottom",
+      "class": {
+        "content": "data-[state=open]:animate-[slide-in-from-bottom_200ms_ease-in-out] data-[state=closed]:animate-[slide-out-to-bottom_200ms_ease-in-out]"
+      }
+    },
+    {
+      "transition": true,
+      "side": "left",
+      "class": {
+        "content": "data-[state=open]:animate-[slide-in-from-left_200ms_ease-in-out] data-[state=closed]:animate-[slide-out-to-left_200ms_ease-in-out]"
+      }
+    }
+  ]
+};
+const _sfc_main = {
+  __name: "USlideover",
+  __ssrInlineRender: true,
+  props: {
+    title: { type: String, required: false },
+    description: { type: String, required: false },
+    content: { type: Object, required: false },
+    overlay: { type: Boolean, required: false, default: true },
+    transition: { type: Boolean, required: false, default: true },
+    side: { type: null, required: false, default: "right" },
+    inset: { type: Boolean, required: false },
+    portal: { type: [Boolean, String], required: false, skipCheck: true, default: true },
+    close: { type: [Boolean, Object], required: false, default: true },
+    closeIcon: { type: null, required: false },
+    dismissible: { type: Boolean, required: false, default: true },
+    class: { type: null, required: false },
+    ui: { type: Object, required: false },
+    open: { type: Boolean, required: false },
+    defaultOpen: { type: Boolean, required: false },
+    modal: { type: Boolean, required: false, default: true }
+  },
+  emits: ["leave", "after:leave", "enter", "after:enter", "close:prevent", "update:open"],
+  setup(__props, { emit: __emit }) {
+    const _props = __props;
+    const emits = __emit;
+    const slots = useSlots();
+    const props = useComponentProps("slideover", _props);
+    const { t } = useLocale();
+    const appConfig = useAppConfig();
+    const rootProps = useForwardProps(reactivePick(props, "open", "defaultOpen", "modal"), emits);
+    const portalProps = usePortal(toRef(() => props.portal));
+    const contentProps = toRef(() => props.content);
+    const contentEvents = computed(() => {
+      if (!props.dismissible) {
+        const events = ["interactOutside", "escapeKeyDown"];
+        return events.reduce((acc, curr) => {
+          acc[curr] = (e) => {
+            e.preventDefault();
+            emits("close:prevent");
+          };
+          return acc;
+        }, {});
+      }
+      return {
+        pointerDownOutside
+      };
+    });
+    const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.slideover || {} })({
+      transition: props.transition,
+      side: props.side,
+      inset: props.inset
+    }));
+    return (_ctx, _push, _parent, _attrs) => {
+      _push(ssrRenderComponent(unref(DialogRoot_default), mergeProps(unref(rootProps), _attrs), {
+        default: withCtx(({ open, close }, _push2, _parent2, _scopeId) => {
+          if (_push2) {
+            if (!!slots.default) {
+              _push2(ssrRenderComponent(unref(DialogTrigger_default), {
+                "as-child": "",
+                class: unref(props).class
+              }, {
+                default: withCtx((_, _push3, _parent3, _scopeId2) => {
+                  if (_push3) {
+                    ssrRenderSlot(_ctx.$slots, "default", { open }, null, _push3, _parent3, _scopeId2);
+                  } else {
+                    return [
+                      renderSlot(_ctx.$slots, "default", { open })
+                    ];
+                  }
+                }),
+                _: 2
+              }, _parent2, _scopeId));
+            } else {
+              _push2(`<!---->`);
+            }
+            _push2(ssrRenderComponent(unref(DialogPortal_default), unref(portalProps), {
+              default: withCtx((_, _push3, _parent3, _scopeId2) => {
+                if (_push3) {
+                  _push3(ssrRenderComponent(unref(FieldGroupReset), null, {
+                    default: withCtx((_2, _push4, _parent4, _scopeId3) => {
+                      if (_push4) {
+                        if (unref(props).overlay) {
+                          _push4(ssrRenderComponent(unref(DialogOverlay_default), {
+                            "data-slot": "overlay",
+                            class: ui.value.overlay({ class: unref(props).ui?.overlay })
+                          }, null, _parent4, _scopeId3));
+                        } else {
+                          _push4(`<!---->`);
+                        }
+                        _push4(ssrRenderComponent(unref(DialogContent_default), mergeProps({
+                          "data-side": unref(props).side,
+                          "data-slot": "content",
+                          class: ui.value.content({ class: [!slots.default && unref(props).class, unref(props).ui?.content] })
+                        }, contentProps.value, {
+                          onEnter: ($event) => emits("enter"),
+                          onAfterEnter: ($event) => emits("after:enter"),
+                          onLeave: ($event) => emits("leave"),
+                          onAfterLeave: ($event) => emits("after:leave")
+                        }, toHandlers(contentEvents.value)), {
+                          default: withCtx((_3, _push5, _parent5, _scopeId4) => {
+                            if (_push5) {
+                              if (!unref(props).title && !slots.title || !unref(props).description && !slots.description || !!slots.content) {
+                                _push5(ssrRenderComponent(unref(VisuallyHidden_default), null, {
+                                  default: withCtx((_4, _push6, _parent6, _scopeId5) => {
+                                    if (_push6) {
+                                      if (!unref(props).title && !slots.title) {
+                                        _push6(ssrRenderComponent(unref(DialogTitle_default), null, null, _parent6, _scopeId5));
+                                      } else if (!!slots.content) {
+                                        _push6(ssrRenderComponent(unref(DialogTitle_default), null, {
+                                          default: withCtx((_5, _push7, _parent7, _scopeId6) => {
+                                            if (_push7) {
+                                              ssrRenderSlot(_ctx.$slots, "title", {}, () => {
+                                                _push7(`${ssrInterpolate(unref(props).title)}`);
+                                              }, _push7, _parent7, _scopeId6);
+                                            } else {
+                                              return [
+                                                renderSlot(_ctx.$slots, "title", {}, () => [
+                                                  createTextVNode(toDisplayString(unref(props).title), 1)
+                                                ])
+                                              ];
+                                            }
+                                          }),
+                                          _: 2
+                                        }, _parent6, _scopeId5));
+                                      } else {
+                                        _push6(`<!---->`);
+                                      }
+                                      if (!unref(props).description && !slots.description) {
+                                        _push6(ssrRenderComponent(unref(DialogDescription_default), null, null, _parent6, _scopeId5));
+                                      } else if (!!slots.content) {
+                                        _push6(ssrRenderComponent(unref(DialogDescription_default), null, {
+                                          default: withCtx((_5, _push7, _parent7, _scopeId6) => {
+                                            if (_push7) {
+                                              ssrRenderSlot(_ctx.$slots, "description", {}, () => {
+                                                _push7(`${ssrInterpolate(unref(props).description)}`);
+                                              }, _push7, _parent7, _scopeId6);
+                                            } else {
+                                              return [
+                                                renderSlot(_ctx.$slots, "description", {}, () => [
+                                                  createTextVNode(toDisplayString(unref(props).description), 1)
+                                                ])
+                                              ];
+                                            }
+                                          }),
+                                          _: 2
+                                        }, _parent6, _scopeId5));
+                                      } else {
+                                        _push6(`<!---->`);
+                                      }
+                                    } else {
+                                      return [
+                                        !unref(props).title && !slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 0 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 1 }, {
+                                          default: withCtx(() => [
+                                            renderSlot(_ctx.$slots, "title", {}, () => [
+                                              createTextVNode(toDisplayString(unref(props).title), 1)
+                                            ])
+                                          ]),
+                                          _: 3
+                                        })) : createCommentVNode("", true),
+                                        !unref(props).description && !slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 2 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 3 }, {
+                                          default: withCtx(() => [
+                                            renderSlot(_ctx.$slots, "description", {}, () => [
+                                              createTextVNode(toDisplayString(unref(props).description), 1)
+                                            ])
+                                          ]),
+                                          _: 3
+                                        })) : createCommentVNode("", true)
+                                      ];
+                                    }
+                                  }),
+                                  _: 2
+                                }, _parent5, _scopeId4));
+                              } else {
+                                _push5(`<!---->`);
+                              }
+                              ssrRenderSlot(_ctx.$slots, "content", { close }, () => {
+                                if (!!slots.header || (unref(props).title || !!slots.title) || (unref(props).description || !!slots.description) || (unref(props).close || !!slots.close)) {
+                                  _push5(`<div data-slot="header" class="${ssrRenderClass(ui.value.header({ class: unref(props).ui?.header }))}"${_scopeId4}>`);
+                                  ssrRenderSlot(_ctx.$slots, "header", { close }, () => {
+                                    if (unref(props).title || !!slots.title || unref(props).description || !!slots.description) {
+                                      _push5(`<div data-slot="wrapper" class="${ssrRenderClass(ui.value.wrapper({ class: unref(props).ui?.wrapper }))}"${_scopeId4}>`);
+                                      if (unref(props).title || !!slots.title) {
+                                        _push5(ssrRenderComponent(unref(DialogTitle_default), {
+                                          "data-slot": "title",
+                                          class: ui.value.title({ class: unref(props).ui?.title })
+                                        }, {
+                                          default: withCtx((_4, _push6, _parent6, _scopeId5) => {
+                                            if (_push6) {
+                                              ssrRenderSlot(_ctx.$slots, "title", {}, () => {
+                                                _push6(`${ssrInterpolate(unref(props).title)}`);
+                                              }, _push6, _parent6, _scopeId5);
+                                            } else {
+                                              return [
+                                                renderSlot(_ctx.$slots, "title", {}, () => [
+                                                  createTextVNode(toDisplayString(unref(props).title), 1)
+                                                ])
+                                              ];
+                                            }
+                                          }),
+                                          _: 2
+                                        }, _parent5, _scopeId4));
+                                      } else {
+                                        _push5(`<!---->`);
+                                      }
+                                      if (unref(props).description || !!slots.description) {
+                                        _push5(ssrRenderComponent(unref(DialogDescription_default), {
+                                          "data-slot": "description",
+                                          class: ui.value.description({ class: unref(props).ui?.description })
+                                        }, {
+                                          default: withCtx((_4, _push6, _parent6, _scopeId5) => {
+                                            if (_push6) {
+                                              ssrRenderSlot(_ctx.$slots, "description", {}, () => {
+                                                _push6(`${ssrInterpolate(unref(props).description)}`);
+                                              }, _push6, _parent6, _scopeId5);
+                                            } else {
+                                              return [
+                                                renderSlot(_ctx.$slots, "description", {}, () => [
+                                                  createTextVNode(toDisplayString(unref(props).description), 1)
+                                                ])
+                                              ];
+                                            }
+                                          }),
+                                          _: 2
+                                        }, _parent5, _scopeId4));
+                                      } else {
+                                        _push5(`<!---->`);
+                                      }
+                                      _push5(`</div>`);
+                                    } else {
+                                      _push5(`<!---->`);
+                                    }
+                                    ssrRenderSlot(_ctx.$slots, "actions", {}, null, _push5, _parent5, _scopeId4);
+                                    if (unref(props).close || !!slots.close) {
+                                      _push5(ssrRenderComponent(unref(DialogClose_default), { "as-child": "" }, {
+                                        default: withCtx((_4, _push6, _parent6, _scopeId5) => {
+                                          if (_push6) {
+                                            ssrRenderSlot(_ctx.$slots, "close", { ui: ui.value }, () => {
+                                              if (unref(props).close) {
+                                                _push6(ssrRenderComponent(_sfc_main$8, mergeProps({
+                                                  icon: unref(props).closeIcon || unref(appConfig).ui.icons.close,
+                                                  color: "neutral",
+                                                  variant: "ghost",
+                                                  "aria-label": unref(t)("slideover.close")
+                                                }, typeof unref(props).close === "object" ? unref(props).close : {}, {
+                                                  "data-slot": "close",
+                                                  class: ui.value.close({ class: unref(props).ui?.close })
+                                                }), null, _parent6, _scopeId5));
+                                              } else {
+                                                _push6(`<!---->`);
+                                              }
+                                            }, _push6, _parent6, _scopeId5);
+                                          } else {
+                                            return [
+                                              renderSlot(_ctx.$slots, "close", { ui: ui.value }, () => [
+                                                unref(props).close ? (openBlock(), createBlock(_sfc_main$8, mergeProps({
+                                                  key: 0,
+                                                  icon: unref(props).closeIcon || unref(appConfig).ui.icons.close,
+                                                  color: "neutral",
+                                                  variant: "ghost",
+                                                  "aria-label": unref(t)("slideover.close")
+                                                }, typeof unref(props).close === "object" ? unref(props).close : {}, {
+                                                  "data-slot": "close",
+                                                  class: ui.value.close({ class: unref(props).ui?.close })
+                                                }), null, 16, ["icon", "aria-label", "class"])) : createCommentVNode("", true)
+                                              ])
+                                            ];
+                                          }
+                                        }),
+                                        _: 2
+                                      }, _parent5, _scopeId4));
+                                    } else {
+                                      _push5(`<!---->`);
+                                    }
+                                  }, _push5, _parent5, _scopeId4);
+                                  _push5(`</div>`);
+                                } else {
+                                  _push5(`<!---->`);
+                                }
+                                _push5(`<div data-slot="body" class="${ssrRenderClass(ui.value.body({ class: unref(props).ui?.body }))}"${_scopeId4}>`);
+                                ssrRenderSlot(_ctx.$slots, "body", { close }, null, _push5, _parent5, _scopeId4);
+                                _push5(`</div>`);
+                                if (!!slots.footer) {
+                                  _push5(`<div data-slot="footer" class="${ssrRenderClass(ui.value.footer({ class: unref(props).ui?.footer }))}"${_scopeId4}>`);
+                                  ssrRenderSlot(_ctx.$slots, "footer", { close }, null, _push5, _parent5, _scopeId4);
+                                  _push5(`</div>`);
+                                } else {
+                                  _push5(`<!---->`);
+                                }
+                              }, _push5, _parent5, _scopeId4);
+                            } else {
+                              return [
+                                !unref(props).title && !slots.title || !unref(props).description && !slots.description || !!slots.content ? (openBlock(), createBlock(unref(VisuallyHidden_default), { key: 0 }, {
+                                  default: withCtx(() => [
+                                    !unref(props).title && !slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 0 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 1 }, {
+                                      default: withCtx(() => [
+                                        renderSlot(_ctx.$slots, "title", {}, () => [
+                                          createTextVNode(toDisplayString(unref(props).title), 1)
+                                        ])
+                                      ]),
+                                      _: 3
+                                    })) : createCommentVNode("", true),
+                                    !unref(props).description && !slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 2 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 3 }, {
+                                      default: withCtx(() => [
+                                        renderSlot(_ctx.$slots, "description", {}, () => [
+                                          createTextVNode(toDisplayString(unref(props).description), 1)
+                                        ])
+                                      ]),
+                                      _: 3
+                                    })) : createCommentVNode("", true)
+                                  ]),
+                                  _: 3
+                                })) : createCommentVNode("", true),
+                                renderSlot(_ctx.$slots, "content", { close }, () => [
+                                  !!slots.header || (unref(props).title || !!slots.title) || (unref(props).description || !!slots.description) || (unref(props).close || !!slots.close) ? (openBlock(), createBlock("div", {
+                                    key: 0,
+                                    "data-slot": "header",
+                                    class: ui.value.header({ class: unref(props).ui?.header })
+                                  }, [
+                                    renderSlot(_ctx.$slots, "header", { close }, () => [
+                                      unref(props).title || !!slots.title || unref(props).description || !!slots.description ? (openBlock(), createBlock("div", {
+                                        key: 0,
+                                        "data-slot": "wrapper",
+                                        class: ui.value.wrapper({ class: unref(props).ui?.wrapper })
+                                      }, [
+                                        unref(props).title || !!slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), {
+                                          key: 0,
+                                          "data-slot": "title",
+                                          class: ui.value.title({ class: unref(props).ui?.title })
+                                        }, {
+                                          default: withCtx(() => [
+                                            renderSlot(_ctx.$slots, "title", {}, () => [
+                                              createTextVNode(toDisplayString(unref(props).title), 1)
+                                            ])
+                                          ]),
+                                          _: 3
+                                        }, 8, ["class"])) : createCommentVNode("", true),
+                                        unref(props).description || !!slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), {
+                                          key: 1,
+                                          "data-slot": "description",
+                                          class: ui.value.description({ class: unref(props).ui?.description })
+                                        }, {
+                                          default: withCtx(() => [
+                                            renderSlot(_ctx.$slots, "description", {}, () => [
+                                              createTextVNode(toDisplayString(unref(props).description), 1)
+                                            ])
+                                          ]),
+                                          _: 3
+                                        }, 8, ["class"])) : createCommentVNode("", true)
+                                      ], 2)) : createCommentVNode("", true),
+                                      renderSlot(_ctx.$slots, "actions"),
+                                      unref(props).close || !!slots.close ? (openBlock(), createBlock(unref(DialogClose_default), {
+                                        key: 1,
+                                        "as-child": ""
+                                      }, {
+                                        default: withCtx(() => [
+                                          renderSlot(_ctx.$slots, "close", { ui: ui.value }, () => [
+                                            unref(props).close ? (openBlock(), createBlock(_sfc_main$8, mergeProps({
+                                              key: 0,
+                                              icon: unref(props).closeIcon || unref(appConfig).ui.icons.close,
+                                              color: "neutral",
+                                              variant: "ghost",
+                                              "aria-label": unref(t)("slideover.close")
+                                            }, typeof unref(props).close === "object" ? unref(props).close : {}, {
+                                              "data-slot": "close",
+                                              class: ui.value.close({ class: unref(props).ui?.close })
+                                            }), null, 16, ["icon", "aria-label", "class"])) : createCommentVNode("", true)
+                                          ])
+                                        ]),
+                                        _: 2
+                                      }, 1024)) : createCommentVNode("", true)
+                                    ])
+                                  ], 2)) : createCommentVNode("", true),
+                                  createVNode("div", {
+                                    "data-slot": "body",
+                                    class: ui.value.body({ class: unref(props).ui?.body })
+                                  }, [
+                                    renderSlot(_ctx.$slots, "body", { close })
+                                  ], 2),
+                                  !!slots.footer ? (openBlock(), createBlock("div", {
+                                    key: 1,
+                                    "data-slot": "footer",
+                                    class: ui.value.footer({ class: unref(props).ui?.footer })
+                                  }, [
+                                    renderSlot(_ctx.$slots, "footer", { close })
+                                  ], 2)) : createCommentVNode("", true)
+                                ])
+                              ];
+                            }
+                          }),
+                          _: 2
+                        }, _parent4, _scopeId3));
+                      } else {
+                        return [
+                          unref(props).overlay ? (openBlock(), createBlock(unref(DialogOverlay_default), {
+                            key: 0,
+                            "data-slot": "overlay",
+                            class: ui.value.overlay({ class: unref(props).ui?.overlay })
+                          }, null, 8, ["class"])) : createCommentVNode("", true),
+                          createVNode(unref(DialogContent_default), mergeProps({
+                            "data-side": unref(props).side,
+                            "data-slot": "content",
+                            class: ui.value.content({ class: [!slots.default && unref(props).class, unref(props).ui?.content] })
+                          }, contentProps.value, {
+                            onEnter: ($event) => emits("enter"),
+                            onAfterEnter: ($event) => emits("after:enter"),
+                            onLeave: ($event) => emits("leave"),
+                            onAfterLeave: ($event) => emits("after:leave")
+                          }, toHandlers(contentEvents.value)), {
+                            default: withCtx(() => [
+                              !unref(props).title && !slots.title || !unref(props).description && !slots.description || !!slots.content ? (openBlock(), createBlock(unref(VisuallyHidden_default), { key: 0 }, {
+                                default: withCtx(() => [
+                                  !unref(props).title && !slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 0 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 1 }, {
+                                    default: withCtx(() => [
+                                      renderSlot(_ctx.$slots, "title", {}, () => [
+                                        createTextVNode(toDisplayString(unref(props).title), 1)
+                                      ])
+                                    ]),
+                                    _: 3
+                                  })) : createCommentVNode("", true),
+                                  !unref(props).description && !slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 2 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 3 }, {
+                                    default: withCtx(() => [
+                                      renderSlot(_ctx.$slots, "description", {}, () => [
+                                        createTextVNode(toDisplayString(unref(props).description), 1)
+                                      ])
+                                    ]),
+                                    _: 3
+                                  })) : createCommentVNode("", true)
+                                ]),
+                                _: 3
+                              })) : createCommentVNode("", true),
+                              renderSlot(_ctx.$slots, "content", { close }, () => [
+                                !!slots.header || (unref(props).title || !!slots.title) || (unref(props).description || !!slots.description) || (unref(props).close || !!slots.close) ? (openBlock(), createBlock("div", {
+                                  key: 0,
+                                  "data-slot": "header",
+                                  class: ui.value.header({ class: unref(props).ui?.header })
+                                }, [
+                                  renderSlot(_ctx.$slots, "header", { close }, () => [
+                                    unref(props).title || !!slots.title || unref(props).description || !!slots.description ? (openBlock(), createBlock("div", {
+                                      key: 0,
+                                      "data-slot": "wrapper",
+                                      class: ui.value.wrapper({ class: unref(props).ui?.wrapper })
+                                    }, [
+                                      unref(props).title || !!slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), {
+                                        key: 0,
+                                        "data-slot": "title",
+                                        class: ui.value.title({ class: unref(props).ui?.title })
+                                      }, {
+                                        default: withCtx(() => [
+                                          renderSlot(_ctx.$slots, "title", {}, () => [
+                                            createTextVNode(toDisplayString(unref(props).title), 1)
+                                          ])
+                                        ]),
+                                        _: 3
+                                      }, 8, ["class"])) : createCommentVNode("", true),
+                                      unref(props).description || !!slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), {
+                                        key: 1,
+                                        "data-slot": "description",
+                                        class: ui.value.description({ class: unref(props).ui?.description })
+                                      }, {
+                                        default: withCtx(() => [
+                                          renderSlot(_ctx.$slots, "description", {}, () => [
+                                            createTextVNode(toDisplayString(unref(props).description), 1)
+                                          ])
+                                        ]),
+                                        _: 3
+                                      }, 8, ["class"])) : createCommentVNode("", true)
+                                    ], 2)) : createCommentVNode("", true),
+                                    renderSlot(_ctx.$slots, "actions"),
+                                    unref(props).close || !!slots.close ? (openBlock(), createBlock(unref(DialogClose_default), {
+                                      key: 1,
+                                      "as-child": ""
+                                    }, {
+                                      default: withCtx(() => [
+                                        renderSlot(_ctx.$slots, "close", { ui: ui.value }, () => [
+                                          unref(props).close ? (openBlock(), createBlock(_sfc_main$8, mergeProps({
+                                            key: 0,
+                                            icon: unref(props).closeIcon || unref(appConfig).ui.icons.close,
+                                            color: "neutral",
+                                            variant: "ghost",
+                                            "aria-label": unref(t)("slideover.close")
+                                          }, typeof unref(props).close === "object" ? unref(props).close : {}, {
+                                            "data-slot": "close",
+                                            class: ui.value.close({ class: unref(props).ui?.close })
+                                          }), null, 16, ["icon", "aria-label", "class"])) : createCommentVNode("", true)
+                                        ])
+                                      ]),
+                                      _: 2
+                                    }, 1024)) : createCommentVNode("", true)
+                                  ])
+                                ], 2)) : createCommentVNode("", true),
+                                createVNode("div", {
+                                  "data-slot": "body",
+                                  class: ui.value.body({ class: unref(props).ui?.body })
+                                }, [
+                                  renderSlot(_ctx.$slots, "body", { close })
+                                ], 2),
+                                !!slots.footer ? (openBlock(), createBlock("div", {
+                                  key: 1,
+                                  "data-slot": "footer",
+                                  class: ui.value.footer({ class: unref(props).ui?.footer })
+                                }, [
+                                  renderSlot(_ctx.$slots, "footer", { close })
+                                ], 2)) : createCommentVNode("", true)
+                              ])
+                            ]),
+                            _: 2
+                          }, 1040, ["data-side", "class", "onEnter", "onAfterEnter", "onLeave", "onAfterLeave"])
+                        ];
+                      }
+                    }),
+                    _: 2
+                  }, _parent3, _scopeId2));
+                } else {
+                  return [
+                    createVNode(unref(FieldGroupReset), null, {
+                      default: withCtx(() => [
+                        unref(props).overlay ? (openBlock(), createBlock(unref(DialogOverlay_default), {
+                          key: 0,
+                          "data-slot": "overlay",
+                          class: ui.value.overlay({ class: unref(props).ui?.overlay })
+                        }, null, 8, ["class"])) : createCommentVNode("", true),
+                        createVNode(unref(DialogContent_default), mergeProps({
+                          "data-side": unref(props).side,
+                          "data-slot": "content",
+                          class: ui.value.content({ class: [!slots.default && unref(props).class, unref(props).ui?.content] })
+                        }, contentProps.value, {
+                          onEnter: ($event) => emits("enter"),
+                          onAfterEnter: ($event) => emits("after:enter"),
+                          onLeave: ($event) => emits("leave"),
+                          onAfterLeave: ($event) => emits("after:leave")
+                        }, toHandlers(contentEvents.value)), {
+                          default: withCtx(() => [
+                            !unref(props).title && !slots.title || !unref(props).description && !slots.description || !!slots.content ? (openBlock(), createBlock(unref(VisuallyHidden_default), { key: 0 }, {
+                              default: withCtx(() => [
+                                !unref(props).title && !slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 0 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 1 }, {
+                                  default: withCtx(() => [
+                                    renderSlot(_ctx.$slots, "title", {}, () => [
+                                      createTextVNode(toDisplayString(unref(props).title), 1)
+                                    ])
+                                  ]),
+                                  _: 3
+                                })) : createCommentVNode("", true),
+                                !unref(props).description && !slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 2 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 3 }, {
+                                  default: withCtx(() => [
+                                    renderSlot(_ctx.$slots, "description", {}, () => [
+                                      createTextVNode(toDisplayString(unref(props).description), 1)
+                                    ])
+                                  ]),
+                                  _: 3
+                                })) : createCommentVNode("", true)
+                              ]),
+                              _: 3
+                            })) : createCommentVNode("", true),
+                            renderSlot(_ctx.$slots, "content", { close }, () => [
+                              !!slots.header || (unref(props).title || !!slots.title) || (unref(props).description || !!slots.description) || (unref(props).close || !!slots.close) ? (openBlock(), createBlock("div", {
+                                key: 0,
+                                "data-slot": "header",
+                                class: ui.value.header({ class: unref(props).ui?.header })
+                              }, [
+                                renderSlot(_ctx.$slots, "header", { close }, () => [
+                                  unref(props).title || !!slots.title || unref(props).description || !!slots.description ? (openBlock(), createBlock("div", {
+                                    key: 0,
+                                    "data-slot": "wrapper",
+                                    class: ui.value.wrapper({ class: unref(props).ui?.wrapper })
+                                  }, [
+                                    unref(props).title || !!slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), {
+                                      key: 0,
+                                      "data-slot": "title",
+                                      class: ui.value.title({ class: unref(props).ui?.title })
+                                    }, {
+                                      default: withCtx(() => [
+                                        renderSlot(_ctx.$slots, "title", {}, () => [
+                                          createTextVNode(toDisplayString(unref(props).title), 1)
+                                        ])
+                                      ]),
+                                      _: 3
+                                    }, 8, ["class"])) : createCommentVNode("", true),
+                                    unref(props).description || !!slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), {
+                                      key: 1,
+                                      "data-slot": "description",
+                                      class: ui.value.description({ class: unref(props).ui?.description })
+                                    }, {
+                                      default: withCtx(() => [
+                                        renderSlot(_ctx.$slots, "description", {}, () => [
+                                          createTextVNode(toDisplayString(unref(props).description), 1)
+                                        ])
+                                      ]),
+                                      _: 3
+                                    }, 8, ["class"])) : createCommentVNode("", true)
+                                  ], 2)) : createCommentVNode("", true),
+                                  renderSlot(_ctx.$slots, "actions"),
+                                  unref(props).close || !!slots.close ? (openBlock(), createBlock(unref(DialogClose_default), {
+                                    key: 1,
+                                    "as-child": ""
+                                  }, {
+                                    default: withCtx(() => [
+                                      renderSlot(_ctx.$slots, "close", { ui: ui.value }, () => [
+                                        unref(props).close ? (openBlock(), createBlock(_sfc_main$8, mergeProps({
+                                          key: 0,
+                                          icon: unref(props).closeIcon || unref(appConfig).ui.icons.close,
+                                          color: "neutral",
+                                          variant: "ghost",
+                                          "aria-label": unref(t)("slideover.close")
+                                        }, typeof unref(props).close === "object" ? unref(props).close : {}, {
+                                          "data-slot": "close",
+                                          class: ui.value.close({ class: unref(props).ui?.close })
+                                        }), null, 16, ["icon", "aria-label", "class"])) : createCommentVNode("", true)
+                                      ])
+                                    ]),
+                                    _: 2
+                                  }, 1024)) : createCommentVNode("", true)
+                                ])
+                              ], 2)) : createCommentVNode("", true),
+                              createVNode("div", {
+                                "data-slot": "body",
+                                class: ui.value.body({ class: unref(props).ui?.body })
+                              }, [
+                                renderSlot(_ctx.$slots, "body", { close })
+                              ], 2),
+                              !!slots.footer ? (openBlock(), createBlock("div", {
+                                key: 1,
+                                "data-slot": "footer",
+                                class: ui.value.footer({ class: unref(props).ui?.footer })
+                              }, [
+                                renderSlot(_ctx.$slots, "footer", { close })
+                              ], 2)) : createCommentVNode("", true)
+                            ])
+                          ]),
+                          _: 2
+                        }, 1040, ["data-side", "class", "onEnter", "onAfterEnter", "onLeave", "onAfterLeave"])
+                      ]),
+                      _: 2
+                    }, 1024)
+                  ];
+                }
+              }),
+              _: 2
+            }, _parent2, _scopeId));
+          } else {
+            return [
+              !!slots.default ? (openBlock(), createBlock(unref(DialogTrigger_default), {
+                key: 0,
+                "as-child": "",
+                class: unref(props).class
+              }, {
+                default: withCtx(() => [
+                  renderSlot(_ctx.$slots, "default", { open })
+                ]),
+                _: 2
+              }, 1032, ["class"])) : createCommentVNode("", true),
+              createVNode(unref(DialogPortal_default), unref(portalProps), {
+                default: withCtx(() => [
+                  createVNode(unref(FieldGroupReset), null, {
+                    default: withCtx(() => [
+                      unref(props).overlay ? (openBlock(), createBlock(unref(DialogOverlay_default), {
+                        key: 0,
+                        "data-slot": "overlay",
+                        class: ui.value.overlay({ class: unref(props).ui?.overlay })
+                      }, null, 8, ["class"])) : createCommentVNode("", true),
+                      createVNode(unref(DialogContent_default), mergeProps({
+                        "data-side": unref(props).side,
+                        "data-slot": "content",
+                        class: ui.value.content({ class: [!slots.default && unref(props).class, unref(props).ui?.content] })
+                      }, contentProps.value, {
+                        onEnter: ($event) => emits("enter"),
+                        onAfterEnter: ($event) => emits("after:enter"),
+                        onLeave: ($event) => emits("leave"),
+                        onAfterLeave: ($event) => emits("after:leave")
+                      }, toHandlers(contentEvents.value)), {
+                        default: withCtx(() => [
+                          !unref(props).title && !slots.title || !unref(props).description && !slots.description || !!slots.content ? (openBlock(), createBlock(unref(VisuallyHidden_default), { key: 0 }, {
+                            default: withCtx(() => [
+                              !unref(props).title && !slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 0 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogTitle_default), { key: 1 }, {
+                                default: withCtx(() => [
+                                  renderSlot(_ctx.$slots, "title", {}, () => [
+                                    createTextVNode(toDisplayString(unref(props).title), 1)
+                                  ])
+                                ]),
+                                _: 3
+                              })) : createCommentVNode("", true),
+                              !unref(props).description && !slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 2 })) : !!slots.content ? (openBlock(), createBlock(unref(DialogDescription_default), { key: 3 }, {
+                                default: withCtx(() => [
+                                  renderSlot(_ctx.$slots, "description", {}, () => [
+                                    createTextVNode(toDisplayString(unref(props).description), 1)
+                                  ])
+                                ]),
+                                _: 3
+                              })) : createCommentVNode("", true)
+                            ]),
+                            _: 3
+                          })) : createCommentVNode("", true),
+                          renderSlot(_ctx.$slots, "content", { close }, () => [
+                            !!slots.header || (unref(props).title || !!slots.title) || (unref(props).description || !!slots.description) || (unref(props).close || !!slots.close) ? (openBlock(), createBlock("div", {
+                              key: 0,
+                              "data-slot": "header",
+                              class: ui.value.header({ class: unref(props).ui?.header })
+                            }, [
+                              renderSlot(_ctx.$slots, "header", { close }, () => [
+                                unref(props).title || !!slots.title || unref(props).description || !!slots.description ? (openBlock(), createBlock("div", {
+                                  key: 0,
+                                  "data-slot": "wrapper",
+                                  class: ui.value.wrapper({ class: unref(props).ui?.wrapper })
+                                }, [
+                                  unref(props).title || !!slots.title ? (openBlock(), createBlock(unref(DialogTitle_default), {
+                                    key: 0,
+                                    "data-slot": "title",
+                                    class: ui.value.title({ class: unref(props).ui?.title })
+                                  }, {
+                                    default: withCtx(() => [
+                                      renderSlot(_ctx.$slots, "title", {}, () => [
+                                        createTextVNode(toDisplayString(unref(props).title), 1)
+                                      ])
+                                    ]),
+                                    _: 3
+                                  }, 8, ["class"])) : createCommentVNode("", true),
+                                  unref(props).description || !!slots.description ? (openBlock(), createBlock(unref(DialogDescription_default), {
+                                    key: 1,
+                                    "data-slot": "description",
+                                    class: ui.value.description({ class: unref(props).ui?.description })
+                                  }, {
+                                    default: withCtx(() => [
+                                      renderSlot(_ctx.$slots, "description", {}, () => [
+                                        createTextVNode(toDisplayString(unref(props).description), 1)
+                                      ])
+                                    ]),
+                                    _: 3
+                                  }, 8, ["class"])) : createCommentVNode("", true)
+                                ], 2)) : createCommentVNode("", true),
+                                renderSlot(_ctx.$slots, "actions"),
+                                unref(props).close || !!slots.close ? (openBlock(), createBlock(unref(DialogClose_default), {
+                                  key: 1,
+                                  "as-child": ""
+                                }, {
+                                  default: withCtx(() => [
+                                    renderSlot(_ctx.$slots, "close", { ui: ui.value }, () => [
+                                      unref(props).close ? (openBlock(), createBlock(_sfc_main$8, mergeProps({
+                                        key: 0,
+                                        icon: unref(props).closeIcon || unref(appConfig).ui.icons.close,
+                                        color: "neutral",
+                                        variant: "ghost",
+                                        "aria-label": unref(t)("slideover.close")
+                                      }, typeof unref(props).close === "object" ? unref(props).close : {}, {
+                                        "data-slot": "close",
+                                        class: ui.value.close({ class: unref(props).ui?.close })
+                                      }), null, 16, ["icon", "aria-label", "class"])) : createCommentVNode("", true)
+                                    ])
+                                  ]),
+                                  _: 2
+                                }, 1024)) : createCommentVNode("", true)
+                              ])
+                            ], 2)) : createCommentVNode("", true),
+                            createVNode("div", {
+                              "data-slot": "body",
+                              class: ui.value.body({ class: unref(props).ui?.body })
+                            }, [
+                              renderSlot(_ctx.$slots, "body", { close })
+                            ], 2),
+                            !!slots.footer ? (openBlock(), createBlock("div", {
+                              key: 1,
+                              "data-slot": "footer",
+                              class: ui.value.footer({ class: unref(props).ui?.footer })
+                            }, [
+                              renderSlot(_ctx.$slots, "footer", { close })
+                            ], 2)) : createCommentVNode("", true)
+                          ])
+                        ]),
+                        _: 2
+                      }, 1040, ["data-side", "class", "onEnter", "onAfterEnter", "onLeave", "onAfterLeave"])
+                    ]),
+                    _: 2
+                  }, 1024)
+                ]),
+                _: 2
+              }, 1040)
+            ];
+          }
+        }),
+        _: 3
+      }, _parent));
+    };
+  }
+};
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+  const ssrContext = useSSRContext();
+  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("../node_modules/.pnpm/@nuxt+ui@4.9.0_fc567bb539fc22c96f06ec9e35286506/node_modules/@nuxt/ui/dist/runtime/components/Slideover.vue");
+  return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+
+export { DismissableLayer_default as D, FocusScope_default as F, PopperRoot_default as P, _sfc_main as _, useId as a, PopperAnchor_default as b, useForwardPropsEmits as c, PopperArrow_default as d, useFocusGuards as e, useBodyScrollLock as f, useHideOthers as g, focusFirst as h, PopperContent_default as i, DialogTrigger_default as j, DialogPortal_default as k, DialogTitle_default as l, DialogDescription_default as m, DialogRoot_default as n, DialogContent_default as o, pointerDownOutside as p, DialogClose_default as q, DialogOverlay_default as r, useDirection as u };
+//# sourceMappingURL=Slideover-KOfskX1l.mjs.map