clawmini 0.0.1

package/web/.svelte-kit/output/server/entries/pages/_layout.svelte.js

@@ -0,0 +1,3944 @@
+import { s as setContext, g as getContext, d as derived, a as attributes, c as clsx, b as bind_props, p as props_id, e as attr, f as spread_props, o as on, h as escape_html, i as stringify, j as attr_class, k as sanitize_props, l as slot, m as ensure_array_like } from "../../chunks/root.js";
+import "clsx";
+import { c as cn, B as Button, I as Icon$1 } from "../../chunks/Icon.js";
+import { M as MediaQuery, c as createSubscriber, d as defaultWindow, a as createId, D as DialogTriggerState, b as boxWith, m as mergeProps, s as simpleBox, C as Context, e as attachRef, u as useId, w as watch, f as cssToStyleObj, i as isNotNull, g as styleToString, h as getWindow, S as Scroll_lock, F as Focus_scope, E as Escape_layer, j as Dismissible_layer, T as Text_selection_layer, k as getDocument, l as isElement, P as PresenceManager, n as DOMContext, o as isFocusVisible, p as boolToEmptyStrOrUndef, q as createBitsAttrs, r as noop, t as Portal, I as Icon, v as Dialog, x as Dialog_overlay, y as Dialog_content, z as Dialog_close, X, A as Dialog_title, B as Dialog_description, G as Bot, H as Dialog$1, J as Dialog_content$1, K as Dialog_header, L as Dialog_title$1, N as Dialog_description$1, O as Dialog_footer } from "../../chunks/bot.js";
+import { computePosition, offset, shift, limitShift, flip, size, arrow, hide } from "@floating-ui/dom";
+import { tv } from "tailwind-variants";
+import { p as page } from "../../chunks/index.js";
+import { I as Input, P as Plus } from "../../chunks/plus.js";
+import { i as invalidate, g as goto } from "../../chunks/client.js";
+const DEFAULT_MOBILE_BREAKPOINT = 768;
+class IsMobile extends MediaQuery {
+  constructor(breakpoint = DEFAULT_MOBILE_BREAKPOINT) {
+    super(`max-width: ${breakpoint - 1}px`);
+  }
+}
+const SIDEBAR_COOKIE_NAME = "sidebar:state";
+const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7;
+const SIDEBAR_WIDTH = "16rem";
+const SIDEBAR_WIDTH_MOBILE = "18rem";
+const SIDEBAR_WIDTH_ICON = "3rem";
+const SIDEBAR_KEYBOARD_SHORTCUT = "b";
+class SidebarState {
+  props;
+  #open = derived(() => this.props.open());
+  get open() {
+    return this.#open();
+  }
+  set open($$value) {
+    return this.#open($$value);
+  }
+  openMobile = false;
+  setOpen;
+  #isMobile;
+  #state = derived(() => this.open ? "expanded" : "collapsed");
+  get state() {
+    return this.#state();
+  }
+  set state($$value) {
+    return this.#state($$value);
+  }
+  constructor(props) {
+    this.setOpen = props.setOpen;
+    this.#isMobile = new IsMobile();
+    this.props = props;
+  }
+  // Convenience getter for checking if the sidebar is mobile
+  // without this, we would need to use `sidebar.isMobile.current` everywhere
+  get isMobile() {
+    return this.#isMobile.current;
+  }
+  // Event handler to apply to the `<svelte:window>`
+  handleShortcutKeydown = (e) => {
+    if (e.key === SIDEBAR_KEYBOARD_SHORTCUT && (e.metaKey || e.ctrlKey)) {
+      e.preventDefault();
+      this.toggle();
+    }
+  };
+  setOpenMobile = (value) => {
+    this.openMobile = value;
+  };
+  toggle = () => {
+    return this.#isMobile.current ? this.openMobile = !this.openMobile : this.setOpen(!this.open);
+  };
+}
+const SYMBOL_KEY = "scn-sidebar";
+function setSidebar(props) {
+  return setContext(Symbol.for(SYMBOL_KEY), new SidebarState(props));
+}
+function useSidebar() {
+  return getContext(Symbol.for(SYMBOL_KEY));
+}
+function Sidebar_content($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<div${attributes({
+      "data-slot": "sidebar-content",
+      "data-sidebar": "content",
+      class: clsx(cn("flex min-h-0 flex-1 flex-col gap-2 overflow-auto group-data-[collapsible=icon]:overflow-hidden", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar_group_content($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<div${attributes({
+      "data-slot": "sidebar-group-content",
+      "data-sidebar": "group-content",
+      class: clsx(cn("w-full text-sm", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar_group_label($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      children,
+      child,
+      class: className,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const mergedProps = derived(() => ({
+      class: cn("text-sidebar-foreground/70 ring-sidebar-ring flex h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium outline-hidden transition-[margin,opacity] duration-200 ease-linear focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0", "group-data-[collapsible=icon]:-mt-8 group-data-[collapsible=icon]:opacity-0", className),
+      "data-slot": "sidebar-group-label",
+      "data-sidebar": "group-label",
+      ...restProps
+    }));
+    if (child) {
+      $$renderer2.push("<!--[0-->");
+      child($$renderer2, { props: mergedProps() });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<div${attributes({ ...mergedProps() })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></div>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar_group($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<div${attributes({
+      "data-slot": "sidebar-group",
+      "data-sidebar": "group",
+      class: clsx(cn("relative flex w-full min-w-0 flex-col p-2", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar_header($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<div${attributes({
+      "data-slot": "sidebar-header",
+      "data-sidebar": "header",
+      class: clsx(cn("flex flex-col gap-2 p-2", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar_inset($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<main${attributes({
+      "data-slot": "sidebar-inset",
+      class: clsx(cn("bg-background relative flex w-full flex-1 flex-col", "md:peer-data-[variant=inset]:m-2 md:peer-data-[variant=inset]:ms-0 md:peer-data-[variant=inset]:rounded-xl md:peer-data-[variant=inset]:shadow-sm md:peer-data-[variant=inset]:peer-data-[state=collapsed]:ms-2", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></main>`);
+    bind_props($$props, { ref });
+  });
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function get$1(value) {
+  if (isFunction(value)) {
+    return value();
+  }
+  return value;
+}
+class ElementSize {
+  // no need to use `$state` here since we are using createSubscriber
+  #size = { width: 0, height: 0 };
+  #observed = false;
+  #options;
+  #node;
+  #window;
+  // we use a derived here to extract the width so that if the width doesn't change we don't get a state update
+  // which we would get if we would just use a getter since the version of the subscriber will be changing
+  #width = derived(() => {
+    this.#subscribe()?.();
+    return this.getSize().width;
+  });
+  // we use a derived here to extract the height so that if the height doesn't change we don't get a state update
+  // which we would get if we would just use a getter since the version of the subscriber will be changing
+  #height = derived(() => {
+    this.#subscribe()?.();
+    return this.getSize().height;
+  });
+  // we need to use a derived here because the class will be created before the node is bound to the ref
+  #subscribe = derived(() => {
+    const node$ = get$1(this.#node);
+    if (!node$) return;
+    return createSubscriber();
+  });
+  constructor(node, options = { box: "border-box" }) {
+    this.#window = options.window ?? defaultWindow;
+    this.#options = options;
+    this.#node = node;
+    this.#size = { width: 0, height: 0 };
+  }
+  calculateSize() {
+    const element = get$1(this.#node);
+    if (!element || !this.#window) {
+      return;
+    }
+    const offsetWidth = element.offsetWidth;
+    const offsetHeight = element.offsetHeight;
+    if (this.#options.box === "border-box") {
+      return { width: offsetWidth, height: offsetHeight };
+    }
+    const style = this.#window.getComputedStyle(element);
+    const paddingWidth = parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
+    const paddingHeight = parseFloat(style.paddingTop) + parseFloat(style.paddingBottom);
+    const borderWidth = parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
+    const borderHeight = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
+    const contentWidth = offsetWidth - paddingWidth - borderWidth;
+    const contentHeight = offsetHeight - paddingHeight - borderHeight;
+    return { width: contentWidth, height: contentHeight };
+  }
+  getSize() {
+    return this.#observed ? this.#size : this.calculateSize() ?? this.#size;
+  }
+  get current() {
+    this.#subscribe()?.();
+    return this.getSize();
+  }
+  get width() {
+    return this.#width();
+  }
+  get height() {
+    return this.#height();
+  }
+}
+function onDestroyEffect(fn) {
+}
+function Dialog_trigger$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const uid = props_id($$renderer2);
+    let {
+      id = createId(uid),
+      ref = null,
+      children,
+      child,
+      disabled = false,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const triggerState = DialogTriggerState.create({
+      id: boxWith(() => id),
+      ref: boxWith(() => ref, (v) => ref = v),
+      disabled: boxWith(() => Boolean(disabled))
+    });
+    const mergedProps = derived(() => mergeProps(restProps, triggerState.props));
+    if (child) {
+      $$renderer2.push("<!--[0-->");
+      child($$renderer2, { props: mergedProps() });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<button${attributes({ ...mergedProps() })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></button>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function get(valueOrGetValue) {
+  return typeof valueOrGetValue === "function" ? valueOrGetValue() : valueOrGetValue;
+}
+function getDPR(element) {
+  if (typeof window === "undefined") return 1;
+  const win = element.ownerDocument.defaultView || window;
+  return win.devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+  const dpr = getDPR(element);
+  return Math.round(value * dpr) / dpr;
+}
+function getFloatingContentCSSVars(name) {
+  return {
+    [`--bits-${name}-content-transform-origin`]: `var(--bits-floating-transform-origin)`,
+    [`--bits-${name}-content-available-width`]: `var(--bits-floating-available-width)`,
+    [`--bits-${name}-content-available-height`]: `var(--bits-floating-available-height)`,
+    [`--bits-${name}-anchor-width`]: `var(--bits-floating-anchor-width)`,
+    [`--bits-${name}-anchor-height`]: `var(--bits-floating-anchor-height)`
+  };
+}
+function useFloating(options) {
+  const openOption = derived(() => get(options.open) ?? true);
+  const middlewareOption = derived(() => get(options.middleware));
+  const transformOption = derived(() => get(options.transform) ?? true);
+  const placementOption = derived(() => get(options.placement) ?? "bottom");
+  const strategyOption = derived(() => get(options.strategy) ?? "absolute");
+  const sideOffsetOption = derived(() => get(options.sideOffset) ?? 0);
+  const alignOffsetOption = derived(() => get(options.alignOffset) ?? 0);
+  const reference = options.reference;
+  let x = 0;
+  let y = 0;
+  const floating = simpleBox(null);
+  let strategy = strategyOption();
+  let placement = placementOption();
+  let middlewareData = {};
+  let isPositioned = false;
+  const floatingStyles = derived(() => {
+    const xVal = floating.current ? roundByDPR(floating.current, x) : x;
+    const yVal = floating.current ? roundByDPR(floating.current, y) : y;
+    if (transformOption()) {
+      return {
+        position: strategy,
+        left: "0",
+        top: "0",
+        transform: `translate(${xVal}px, ${yVal}px)`,
+        ...floating.current && getDPR(floating.current) >= 1.5 && { willChange: "transform" }
+      };
+    }
+    return { position: strategy, left: `${xVal}px`, top: `${yVal}px` };
+  });
+  function update() {
+    if (reference.current === null || floating.current === null) return;
+    computePosition(reference.current, floating.current, {
+      middleware: middlewareOption(),
+      placement: placementOption(),
+      strategy: strategyOption()
+    }).then((position) => {
+      const referenceNode = reference.current;
+      const referenceHidden = isReferenceHidden(referenceNode);
+      if (referenceHidden) {
+        middlewareData = {
+          ...middlewareData,
+          hide: {
+            // oxlint-disable-next-line no-explicit-any
+            ...middlewareData.hide,
+            referenceHidden: true
+          }
+        };
+        return;
+      }
+      if (!openOption() && x !== 0 && y !== 0) {
+        const maxExpectedOffset = Math.max(Math.abs(sideOffsetOption()), Math.abs(alignOffsetOption()), 15);
+        if (position.x <= maxExpectedOffset && position.y <= maxExpectedOffset) return;
+      }
+      x = position.x;
+      y = position.y;
+      strategy = position.strategy;
+      placement = position.placement;
+      middlewareData = position.middlewareData;
+      isPositioned = true;
+    });
+  }
+  return {
+    floating,
+    reference,
+    get strategy() {
+      return strategy;
+    },
+    get placement() {
+      return placement;
+    },
+    get middlewareData() {
+      return middlewareData;
+    },
+    get isPositioned() {
+      return isPositioned;
+    },
+    get floatingStyles() {
+      return floatingStyles();
+    },
+    get update() {
+      return update;
+    }
+  };
+}
+function isReferenceHidden(node) {
+  if (!(node instanceof Element)) return false;
+  if (!node.isConnected) return true;
+  if (node instanceof HTMLElement && node.hidden) return true;
+  return node.getClientRects().length === 0;
+}
+const OPPOSITE_SIDE = { top: "bottom", right: "left", bottom: "top", left: "right" };
+const FloatingRootContext = new Context("Floating.Root");
+const FloatingContentContext = new Context("Floating.Content");
+const FloatingTooltipRootContext = new Context("Floating.Root");
+class FloatingRootState {
+  static create(tooltip = false) {
+    return tooltip ? FloatingTooltipRootContext.set(new FloatingRootState()) : FloatingRootContext.set(new FloatingRootState());
+  }
+  anchorNode = simpleBox(null);
+  customAnchorNode = simpleBox(null);
+  triggerNode = simpleBox(null);
+  constructor() {
+  }
+}
+class FloatingContentState {
+  static create(opts, tooltip = false) {
+    return tooltip ? FloatingContentContext.set(new FloatingContentState(opts, FloatingTooltipRootContext.get())) : FloatingContentContext.set(new FloatingContentState(opts, FloatingRootContext.get()));
+  }
+  opts;
+  root;
+  // nodes
+  contentRef = simpleBox(null);
+  wrapperRef = simpleBox(null);
+  arrowRef = simpleBox(null);
+  contentAttachment = attachRef(this.contentRef);
+  wrapperAttachment = attachRef(this.wrapperRef);
+  arrowAttachment = attachRef(this.arrowRef);
+  // ids
+  arrowId = simpleBox(useId());
+  #transformedStyle = derived(() => {
+    if (typeof this.opts.style === "string") return cssToStyleObj(this.opts.style);
+    if (!this.opts.style) return {};
+  });
+  #updatePositionStrategy = void 0;
+  #arrowSize = new ElementSize(() => this.arrowRef.current ?? void 0);
+  #arrowWidth = derived(() => this.#arrowSize?.width ?? 0);
+  #arrowHeight = derived(() => this.#arrowSize?.height ?? 0);
+  #desiredPlacement = derived(() => this.opts.side?.current + (this.opts.align.current !== "center" ? `-${this.opts.align.current}` : ""));
+  #boundary = derived(() => Array.isArray(this.opts.collisionBoundary.current) ? this.opts.collisionBoundary.current : [this.opts.collisionBoundary.current]);
+  #hasExplicitBoundaries = derived(() => this.#boundary().length > 0);
+  get hasExplicitBoundaries() {
+    return this.#hasExplicitBoundaries();
+  }
+  set hasExplicitBoundaries($$value) {
+    return this.#hasExplicitBoundaries($$value);
+  }
+  #detectOverflowOptions = derived(() => ({
+    padding: this.opts.collisionPadding.current,
+    boundary: this.#boundary().filter(isNotNull),
+    altBoundary: this.hasExplicitBoundaries
+  }));
+  get detectOverflowOptions() {
+    return this.#detectOverflowOptions();
+  }
+  set detectOverflowOptions($$value) {
+    return this.#detectOverflowOptions($$value);
+  }
+  #availableWidth = void 0;
+  #availableHeight = void 0;
+  #anchorWidth = void 0;
+  #anchorHeight = void 0;
+  #middleware = derived(() => [
+    offset({
+      mainAxis: this.opts.sideOffset.current + this.#arrowHeight(),
+      alignmentAxis: this.opts.alignOffset.current
+    }),
+    this.opts.avoidCollisions.current && shift({
+      mainAxis: true,
+      crossAxis: false,
+      limiter: this.opts.sticky.current === "partial" ? limitShift() : void 0,
+      ...this.detectOverflowOptions
+    }),
+    this.opts.avoidCollisions.current && flip({ ...this.detectOverflowOptions }),
+    size({
+      ...this.detectOverflowOptions,
+      apply: ({ rects, availableWidth, availableHeight }) => {
+        const { width: anchorWidth, height: anchorHeight } = rects.reference;
+        this.#availableWidth = availableWidth;
+        this.#availableHeight = availableHeight;
+        this.#anchorWidth = anchorWidth;
+        this.#anchorHeight = anchorHeight;
+      }
+    }),
+    this.arrowRef.current && arrow({
+      element: this.arrowRef.current,
+      padding: this.opts.arrowPadding.current
+    }),
+    transformOrigin({
+      arrowWidth: this.#arrowWidth(),
+      arrowHeight: this.#arrowHeight()
+    }),
+    this.opts.hideWhenDetached.current && hide({ strategy: "referenceHidden", ...this.detectOverflowOptions })
+  ].filter(Boolean));
+  get middleware() {
+    return this.#middleware();
+  }
+  set middleware($$value) {
+    return this.#middleware($$value);
+  }
+  floating;
+  #placedSide = derived(() => getSideFromPlacement(this.floating.placement));
+  get placedSide() {
+    return this.#placedSide();
+  }
+  set placedSide($$value) {
+    return this.#placedSide($$value);
+  }
+  #placedAlign = derived(() => getAlignFromPlacement(this.floating.placement));
+  get placedAlign() {
+    return this.#placedAlign();
+  }
+  set placedAlign($$value) {
+    return this.#placedAlign($$value);
+  }
+  #arrowX = derived(() => this.floating.middlewareData.arrow?.x ?? 0);
+  get arrowX() {
+    return this.#arrowX();
+  }
+  set arrowX($$value) {
+    return this.#arrowX($$value);
+  }
+  #arrowY = derived(() => this.floating.middlewareData.arrow?.y ?? 0);
+  get arrowY() {
+    return this.#arrowY();
+  }
+  set arrowY($$value) {
+    return this.#arrowY($$value);
+  }
+  #cannotCenterArrow = derived(() => this.floating.middlewareData.arrow?.centerOffset !== 0);
+  get cannotCenterArrow() {
+    return this.#cannotCenterArrow();
+  }
+  set cannotCenterArrow($$value) {
+    return this.#cannotCenterArrow($$value);
+  }
+  contentZIndex;
+  #arrowBaseSide = derived(() => OPPOSITE_SIDE[this.placedSide]);
+  get arrowBaseSide() {
+    return this.#arrowBaseSide();
+  }
+  set arrowBaseSide($$value) {
+    return this.#arrowBaseSide($$value);
+  }
+  #wrapperProps = derived(() => ({
+    id: this.opts.wrapperId.current,
+    "data-bits-floating-content-wrapper": "",
+    style: {
+      ...this.floating.floatingStyles,
+      transform: this.floating.isPositioned ? this.floating.floatingStyles.transform : "translate(0, -200%)",
+      minWidth: "max-content",
+      zIndex: this.contentZIndex,
+      "--bits-floating-transform-origin": `${this.floating.middlewareData.transformOrigin?.x} ${this.floating.middlewareData.transformOrigin?.y}`,
+      "--bits-floating-available-width": `${this.#availableWidth}px`,
+      "--bits-floating-available-height": `${this.#availableHeight}px`,
+      "--bits-floating-anchor-width": `${this.#anchorWidth}px`,
+      "--bits-floating-anchor-height": `${this.#anchorHeight}px`,
+      ...this.floating.middlewareData.hide?.referenceHidden && { visibility: "hidden", "pointer-events": "none" },
+      ...this.#transformedStyle()
+    },
+    dir: this.opts.dir.current,
+    ...this.wrapperAttachment
+  }));
+  get wrapperProps() {
+    return this.#wrapperProps();
+  }
+  set wrapperProps($$value) {
+    return this.#wrapperProps($$value);
+  }
+  #props = derived(() => ({
+    "data-side": this.placedSide,
+    "data-align": this.placedAlign,
+    style: styleToString({ ...this.#transformedStyle() }),
+    ...this.contentAttachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+  #arrowStyle = derived(() => ({
+    position: "absolute",
+    left: this.arrowX ? `${this.arrowX}px` : void 0,
+    top: this.arrowY ? `${this.arrowY}px` : void 0,
+    [this.arrowBaseSide]: 0,
+    "transform-origin": { top: "", right: "0 0", bottom: "center 0", left: "100% 0" }[this.placedSide],
+    transform: {
+      top: "translateY(100%)",
+      right: "translateY(50%) rotate(90deg) translateX(-50%)",
+      bottom: "rotate(180deg)",
+      left: "translateY(50%) rotate(-90deg) translateX(50%)"
+    }[this.placedSide],
+    visibility: this.cannotCenterArrow ? "hidden" : void 0
+  }));
+  get arrowStyle() {
+    return this.#arrowStyle();
+  }
+  set arrowStyle($$value) {
+    return this.#arrowStyle($$value);
+  }
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.#updatePositionStrategy = opts.updatePositionStrategy;
+    if (opts.customAnchor) {
+      this.root.customAnchorNode.current = opts.customAnchor.current;
+    }
+    watch(() => opts.customAnchor.current, (customAnchor) => {
+      this.root.customAnchorNode.current = customAnchor;
+    });
+    this.floating = useFloating({
+      strategy: () => this.opts.strategy.current,
+      placement: () => this.#desiredPlacement(),
+      middleware: () => this.middleware,
+      reference: this.root.anchorNode,
+      open: () => this.opts.enabled.current,
+      sideOffset: () => this.opts.sideOffset.current,
+      alignOffset: () => this.opts.alignOffset.current
+    });
+    watch(() => this.contentRef.current, (contentNode) => {
+      if (!contentNode || !this.opts.enabled.current) return;
+      const win = getWindow(contentNode);
+      const rafId = win.requestAnimationFrame(() => {
+        if (this.contentRef.current !== contentNode || !this.opts.enabled.current) return;
+        const zIndex = win.getComputedStyle(contentNode).zIndex;
+        if (zIndex !== this.contentZIndex) {
+          this.contentZIndex = zIndex;
+        }
+      });
+      return () => {
+        win.cancelAnimationFrame(rafId);
+      };
+    });
+  }
+}
+class FloatingArrowState {
+  static create(opts) {
+    return new FloatingArrowState(opts, FloatingContentContext.get());
+  }
+  opts;
+  content;
+  constructor(opts, content) {
+    this.opts = opts;
+    this.content = content;
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    style: this.content.arrowStyle,
+    "data-side": this.content.placedSide,
+    ...this.content.arrowAttachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+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];
+}
+function getSideFromPlacement(placement) {
+  return getSideAndAlignFromPlacement(placement)[0];
+}
+function getAlignFromPlacement(placement) {
+  return getSideAndAlignFromPlacement(placement)[1];
+}
+function Floating_layer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { children, tooltip = false } = $$props;
+    FloatingRootState.create(tooltip);
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+function Arrow($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id = useId(),
+      children,
+      child,
+      width = 10,
+      height = 5,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const mergedProps = derived(() => mergeProps(restProps, { id }));
+    if (child) {
+      $$renderer2.push("<!--[0-->");
+      child($$renderer2, { props: mergedProps() });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<span${attributes({ ...mergedProps() })}>`);
+      if (children) {
+        $$renderer2.push("<!--[0-->");
+        children?.($$renderer2);
+        $$renderer2.push(`<!---->`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        $$renderer2.push(`<svg${attr("width", width)}${attr("height", height)} viewBox="0 0 30 10" preserveAspectRatio="none" data-arrow=""><polygon points="0,0 30,0 15,10" fill="currentColor"></polygon></svg>`);
+      }
+      $$renderer2.push(`<!--]--></span>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+function Floating_layer_arrow($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { id = useId(), ref = null, $$slots, $$events, ...restProps } = $$props;
+    const arrowState = FloatingArrowState.create({
+      id: boxWith(() => id),
+      ref: boxWith(() => ref, (v) => ref = v)
+    });
+    const mergedProps = derived(() => mergeProps(restProps, arrowState.props));
+    Arrow($$renderer2, spread_props([mergedProps()]));
+    bind_props($$props, { ref });
+  });
+}
+function Floating_layer_content($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      content,
+      side = "bottom",
+      sideOffset = 0,
+      align = "center",
+      alignOffset = 0,
+      id,
+      arrowPadding = 0,
+      avoidCollisions = true,
+      collisionBoundary = [],
+      collisionPadding = 0,
+      hideWhenDetached = false,
+      onPlaced = () => {
+      },
+      sticky = "partial",
+      updatePositionStrategy = "optimized",
+      strategy = "fixed",
+      dir = "ltr",
+      style = {},
+      wrapperId = useId(),
+      customAnchor = null,
+      enabled,
+      tooltip = false
+    } = $$props;
+    const contentState = FloatingContentState.create(
+      {
+        side: boxWith(() => side),
+        sideOffset: boxWith(() => sideOffset),
+        align: boxWith(() => align),
+        alignOffset: boxWith(() => alignOffset),
+        id: boxWith(() => id),
+        arrowPadding: boxWith(() => arrowPadding),
+        avoidCollisions: boxWith(() => avoidCollisions),
+        collisionBoundary: boxWith(() => collisionBoundary),
+        collisionPadding: boxWith(() => collisionPadding),
+        hideWhenDetached: boxWith(() => hideWhenDetached),
+        onPlaced: boxWith(() => onPlaced),
+        sticky: boxWith(() => sticky),
+        updatePositionStrategy: boxWith(() => updatePositionStrategy),
+        strategy: boxWith(() => strategy),
+        dir: boxWith(() => dir),
+        style: boxWith(() => style),
+        enabled: boxWith(() => enabled),
+        wrapperId: boxWith(() => wrapperId),
+        customAnchor: boxWith(() => customAnchor)
+      },
+      tooltip
+    );
+    const mergedProps = derived(() => mergeProps(contentState.wrapperProps, { style: { pointerEvents: "auto" } }));
+    content?.($$renderer2, { props: contentState.props, wrapperProps: mergedProps() });
+    $$renderer2.push(`<!---->`);
+  });
+}
+function Floating_layer_content_static($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { content } = $$props;
+    content?.($$renderer2, { props: {}, wrapperProps: {} });
+    $$renderer2.push(`<!---->`);
+  });
+}
+function Popper_content($$renderer, $$props) {
+  let {
+    content,
+    isStatic = false,
+    onPlaced,
+    $$slots,
+    $$events,
+    ...restProps
+  } = $$props;
+  if (isStatic) {
+    $$renderer.push("<!--[0-->");
+    Floating_layer_content_static($$renderer, { content });
+  } else {
+    $$renderer.push("<!--[-1-->");
+    Floating_layer_content($$renderer, spread_props([{ content, onPlaced }, restProps]));
+  }
+  $$renderer.push(`<!--]-->`);
+}
+function Popper_layer_inner($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      popper,
+      onEscapeKeydown,
+      escapeKeydownBehavior,
+      preventOverflowTextSelection,
+      id,
+      onPointerDown,
+      onPointerUp,
+      side,
+      sideOffset,
+      align,
+      alignOffset,
+      arrowPadding,
+      avoidCollisions,
+      collisionBoundary,
+      collisionPadding,
+      sticky,
+      hideWhenDetached,
+      updatePositionStrategy,
+      strategy,
+      dir,
+      preventScroll,
+      wrapperId,
+      style,
+      onPlaced,
+      onInteractOutside,
+      onCloseAutoFocus,
+      onOpenAutoFocus,
+      onFocusOutside,
+      interactOutsideBehavior = "close",
+      loop,
+      trapFocus = true,
+      isValidEvent = () => false,
+      customAnchor = null,
+      isStatic = false,
+      enabled,
+      ref,
+      tooltip = false,
+      contentPointerEvents = "auto",
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    {
+      let content = function($$renderer3, { props: floatingProps, wrapperProps }) {
+        if (restProps.forceMount && enabled) {
+          $$renderer3.push("<!--[0-->");
+          Scroll_lock($$renderer3, { preventScroll });
+        } else if (!restProps.forceMount) {
+          $$renderer3.push("<!--[1-->");
+          Scroll_lock($$renderer3, { preventScroll });
+        } else {
+          $$renderer3.push("<!--[-1-->");
+        }
+        $$renderer3.push(`<!--]--> `);
+        {
+          let focusScope = function($$renderer4, { props: focusScopeProps }) {
+            Escape_layer($$renderer4, {
+              onEscapeKeydown,
+              escapeKeydownBehavior,
+              enabled,
+              ref,
+              children: ($$renderer5) => {
+                {
+                  let children = function($$renderer6, { props: dismissibleProps }) {
+                    Text_selection_layer($$renderer6, {
+                      id,
+                      preventOverflowTextSelection,
+                      onPointerDown,
+                      onPointerUp,
+                      enabled,
+                      ref,
+                      children: ($$renderer7) => {
+                        popper?.($$renderer7, {
+                          props: mergeProps(restProps, floatingProps, dismissibleProps, focusScopeProps, { style: { pointerEvents: contentPointerEvents } }),
+                          wrapperProps
+                        });
+                        $$renderer7.push(`<!---->`);
+                      }
+                    });
+                  };
+                  Dismissible_layer($$renderer5, {
+                    id,
+                    onInteractOutside,
+                    onFocusOutside,
+                    interactOutsideBehavior,
+                    isValidEvent,
+                    enabled,
+                    ref,
+                    children
+                  });
+                }
+              }
+            });
+          };
+          Focus_scope($$renderer3, {
+            onOpenAutoFocus,
+            onCloseAutoFocus,
+            loop,
+            enabled,
+            trapFocus,
+            forceMount: restProps.forceMount,
+            ref,
+            focusScope
+          });
+        }
+        $$renderer3.push(`<!---->`);
+      };
+      Popper_content($$renderer2, {
+        isStatic,
+        id,
+        side,
+        sideOffset,
+        align,
+        alignOffset,
+        arrowPadding,
+        avoidCollisions,
+        collisionBoundary,
+        collisionPadding,
+        sticky,
+        hideWhenDetached,
+        updatePositionStrategy,
+        strategy,
+        dir,
+        wrapperId,
+        style,
+        onPlaced,
+        customAnchor,
+        enabled,
+        tooltip,
+        content,
+        $$slots: { content: true }
+      });
+    }
+  });
+}
+function Popper_layer($$renderer, $$props) {
+  let {
+    popper,
+    open,
+    onEscapeKeydown,
+    escapeKeydownBehavior,
+    preventOverflowTextSelection,
+    id,
+    onPointerDown,
+    onPointerUp,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    arrowPadding,
+    avoidCollisions,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    hideWhenDetached,
+    updatePositionStrategy,
+    strategy,
+    dir,
+    preventScroll,
+    wrapperId,
+    style,
+    onPlaced,
+    onInteractOutside,
+    onCloseAutoFocus,
+    onOpenAutoFocus,
+    onFocusOutside,
+    interactOutsideBehavior = "close",
+    loop,
+    trapFocus = true,
+    isValidEvent = () => false,
+    customAnchor = null,
+    isStatic = false,
+    ref,
+    shouldRender,
+    $$slots,
+    $$events,
+    ...restProps
+  } = $$props;
+  if (shouldRender) {
+    $$renderer.push("<!--[0-->");
+    Popper_layer_inner($$renderer, spread_props([
+      {
+        popper,
+        onEscapeKeydown,
+        escapeKeydownBehavior,
+        preventOverflowTextSelection,
+        id,
+        onPointerDown,
+        onPointerUp,
+        side,
+        sideOffset,
+        align,
+        alignOffset,
+        arrowPadding,
+        avoidCollisions,
+        collisionBoundary,
+        collisionPadding,
+        sticky,
+        hideWhenDetached,
+        updatePositionStrategy,
+        strategy,
+        dir,
+        preventScroll,
+        wrapperId,
+        style,
+        onPlaced,
+        customAnchor,
+        isStatic,
+        enabled: open,
+        onInteractOutside,
+        onCloseAutoFocus,
+        onOpenAutoFocus,
+        interactOutsideBehavior,
+        loop,
+        trapFocus,
+        isValidEvent,
+        onFocusOutside,
+        forceMount: false,
+        ref
+      },
+      restProps
+    ]));
+  } else {
+    $$renderer.push("<!--[-1-->");
+  }
+  $$renderer.push(`<!--]-->`);
+}
+function Popper_layer_force_mount($$renderer, $$props) {
+  let {
+    popper,
+    onEscapeKeydown,
+    escapeKeydownBehavior,
+    preventOverflowTextSelection,
+    id,
+    onPointerDown,
+    onPointerUp,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    arrowPadding,
+    avoidCollisions,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    hideWhenDetached,
+    updatePositionStrategy,
+    strategy,
+    dir,
+    preventScroll,
+    wrapperId,
+    style,
+    onPlaced,
+    onInteractOutside,
+    onCloseAutoFocus,
+    onOpenAutoFocus,
+    onFocusOutside,
+    interactOutsideBehavior = "close",
+    loop,
+    trapFocus = true,
+    isValidEvent = () => false,
+    customAnchor = null,
+    isStatic = false,
+    enabled,
+    $$slots,
+    $$events,
+    ...restProps
+  } = $$props;
+  Popper_layer_inner($$renderer, spread_props([
+    {
+      popper,
+      onEscapeKeydown,
+      escapeKeydownBehavior,
+      preventOverflowTextSelection,
+      id,
+      onPointerDown,
+      onPointerUp,
+      side,
+      sideOffset,
+      align,
+      alignOffset,
+      arrowPadding,
+      avoidCollisions,
+      collisionBoundary,
+      collisionPadding,
+      sticky,
+      hideWhenDetached,
+      updatePositionStrategy,
+      strategy,
+      dir,
+      preventScroll,
+      wrapperId,
+      style,
+      onPlaced,
+      customAnchor,
+      isStatic,
+      enabled,
+      onInteractOutside,
+      onCloseAutoFocus,
+      onOpenAutoFocus,
+      interactOutsideBehavior,
+      loop,
+      trapFocus,
+      isValidEvent,
+      onFocusOutside
+    },
+    restProps,
+    { forceMount: true }
+  ]));
+}
+function isPointInPolygon(point, polygon) {
+  const [x, y] = point;
+  let isInside = false;
+  const length = polygon.length;
+  for (let i = 0, j = length - 1; i < length; j = i++) {
+    const [xi, yi] = polygon[i] ?? [0, 0];
+    const [xj, yj] = polygon[j] ?? [0, 0];
+    const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;
+    if (intersect) {
+      isInside = !isInside;
+    }
+  }
+  return isInside;
+}
+function isInsideRect(point, rect) {
+  return point[0] >= rect.left && point[0] <= rect.right && point[1] >= rect.top && point[1] <= rect.bottom;
+}
+function getSide(triggerRect, contentRect) {
+  const triggerCenterX = triggerRect.left + triggerRect.width / 2;
+  const triggerCenterY = triggerRect.top + triggerRect.height / 2;
+  const contentCenterX = contentRect.left + contentRect.width / 2;
+  const contentCenterY = contentRect.top + contentRect.height / 2;
+  const deltaX = contentCenterX - triggerCenterX;
+  const deltaY = contentCenterY - triggerCenterY;
+  if (Math.abs(deltaX) > Math.abs(deltaY)) {
+    return deltaX > 0 ? "right" : "left";
+  }
+  return deltaY > 0 ? "bottom" : "top";
+}
+class SafePolygon {
+  #opts;
+  #buffer;
+  #transitIntentTimeout;
+  // tracks the cursor position when leaving trigger or content
+  #exitPoint = null;
+  // tracks what we're moving toward: "content" when leaving trigger, "trigger" when leaving content
+  #exitTarget = null;
+  #transitTargets = [];
+  #trackedTriggerNode = null;
+  #leaveFallbackRafId = null;
+  #transitIntentTimeoutId = null;
+  #cancelLeaveFallback() {
+    if (this.#leaveFallbackRafId !== null) {
+      cancelAnimationFrame(this.#leaveFallbackRafId);
+      this.#leaveFallbackRafId = null;
+    }
+  }
+  #scheduleLeaveFallback() {
+    this.#cancelLeaveFallback();
+    this.#leaveFallbackRafId = requestAnimationFrame(() => {
+      this.#leaveFallbackRafId = null;
+      if (!this.#exitPoint || !this.#exitTarget) return;
+      this.#clearTracking();
+      this.#opts.onPointerExit();
+    });
+  }
+  #cancelTransitIntentTimeout() {
+    if (this.#transitIntentTimeoutId !== null) {
+      clearTimeout(this.#transitIntentTimeoutId);
+      this.#transitIntentTimeoutId = null;
+    }
+  }
+  #scheduleTransitIntentTimeout() {
+    if (this.#transitIntentTimeout === null) return;
+    this.#cancelTransitIntentTimeout();
+    this.#transitIntentTimeoutId = window.setTimeout(
+      () => {
+        this.#transitIntentTimeoutId = null;
+        if (!this.#exitPoint || !this.#exitTarget) return;
+        this.#clearTracking();
+        this.#opts.onPointerExit();
+      },
+      this.#transitIntentTimeout
+    );
+  }
+  constructor(opts) {
+    this.#opts = opts;
+    this.#buffer = opts.buffer ?? 1;
+    const transitIntentTimeout = opts.transitIntentTimeout;
+    this.#transitIntentTimeout = typeof transitIntentTimeout === "number" && transitIntentTimeout > 0 ? transitIntentTimeout : null;
+    watch([opts.triggerNode, opts.contentNode, opts.enabled], ([triggerNode, contentNode, enabled]) => {
+      if (!triggerNode || !contentNode || !enabled) {
+        this.#trackedTriggerNode = null;
+        this.#clearTracking();
+        return;
+      }
+      if (this.#trackedTriggerNode && this.#trackedTriggerNode !== triggerNode) {
+        this.#clearTracking();
+      }
+      this.#trackedTriggerNode = triggerNode;
+      const doc = getDocument(triggerNode);
+      const handlePointerMove = (e) => {
+        this.#onPointerMove([e.clientX, e.clientY], triggerNode, contentNode);
+      };
+      const handleTriggerLeave = (e) => {
+        const target = e.relatedTarget;
+        if (isElement(target) && contentNode.contains(target)) {
+          return;
+        }
+        const ignoredTargets = this.#opts.ignoredTargets?.() ?? [];
+        if (isElement(target) && ignoredTargets.some((n) => n === target || n.contains(target))) {
+          return;
+        }
+        this.#transitTargets = isElement(target) && ignoredTargets.length > 0 ? ignoredTargets.filter((n) => target.contains(n)) : [];
+        this.#exitPoint = [e.clientX, e.clientY];
+        this.#exitTarget = "content";
+        this.#scheduleLeaveFallback();
+      };
+      const handleTriggerEnter = () => {
+        this.#clearTracking();
+      };
+      const handleContentEnter = () => {
+        this.#clearTracking();
+      };
+      const handleContentLeave = (e) => {
+        const target = e.relatedTarget;
+        if (isElement(target) && triggerNode.contains(target)) {
+          return;
+        }
+        this.#exitPoint = [e.clientX, e.clientY];
+        this.#exitTarget = "trigger";
+        this.#scheduleLeaveFallback();
+      };
+      return [
+        on(doc, "pointermove", handlePointerMove),
+        on(triggerNode, "pointerleave", handleTriggerLeave),
+        on(triggerNode, "pointerenter", handleTriggerEnter),
+        on(contentNode, "pointerenter", handleContentEnter),
+        on(contentNode, "pointerleave", handleContentLeave)
+      ].reduce(
+        (acc, cleanup) => () => {
+          acc();
+          cleanup();
+        },
+        () => {
+        }
+      );
+    });
+  }
+  #onPointerMove(clientPoint, triggerNode, contentNode) {
+    if (!this.#exitPoint || !this.#exitTarget) return;
+    this.#cancelLeaveFallback();
+    this.#scheduleTransitIntentTimeout();
+    const triggerRect = triggerNode.getBoundingClientRect();
+    const contentRect = contentNode.getBoundingClientRect();
+    if (this.#exitTarget === "content" && isInsideRect(clientPoint, contentRect)) {
+      this.#clearTracking();
+      return;
+    }
+    if (this.#exitTarget === "trigger" && isInsideRect(clientPoint, triggerRect)) {
+      this.#clearTracking();
+      return;
+    }
+    if (this.#exitTarget === "content" && this.#transitTargets.length > 0) {
+      for (const transitTarget of this.#transitTargets) {
+        const transitRect = transitTarget.getBoundingClientRect();
+        if (isInsideRect(clientPoint, transitRect)) return;
+        const transitSide = getSide(triggerRect, transitRect);
+        const transitCorridor = this.#getCorridorPolygon(triggerRect, transitRect, transitSide);
+        if (transitCorridor && isPointInPolygon(clientPoint, transitCorridor)) return;
+      }
+    }
+    const side = getSide(triggerRect, contentRect);
+    const corridorPoly = this.#getCorridorPolygon(triggerRect, contentRect, side);
+    if (corridorPoly && isPointInPolygon(clientPoint, corridorPoly)) {
+      return;
+    }
+    const targetRect = this.#exitTarget === "content" ? contentRect : triggerRect;
+    const safePoly = this.#getSafePolygon(this.#exitPoint, targetRect, side, this.#exitTarget);
+    if (isPointInPolygon(clientPoint, safePoly)) {
+      return;
+    }
+    this.#clearTracking();
+    this.#opts.onPointerExit();
+  }
+  #clearTracking() {
+    this.#exitPoint = null;
+    this.#exitTarget = null;
+    this.#transitTargets = [];
+    this.#cancelLeaveFallback();
+    this.#cancelTransitIntentTimeout();
+  }
+  /**
+   * Creates a rectangular corridor between trigger and content
+   * This prevents closing when cursor is in the gap between them
+   */
+  #getCorridorPolygon(triggerRect, contentRect, side) {
+    const buffer = this.#buffer;
+    switch (side) {
+      case "top":
+        return [
+          [
+            Math.min(triggerRect.left, contentRect.left) - buffer,
+            triggerRect.top
+          ],
+          [
+            Math.min(triggerRect.left, contentRect.left) - buffer,
+            contentRect.bottom
+          ],
+          [
+            Math.max(triggerRect.right, contentRect.right) + buffer,
+            contentRect.bottom
+          ],
+          [
+            Math.max(triggerRect.right, contentRect.right) + buffer,
+            triggerRect.top
+          ]
+        ];
+      case "bottom":
+        return [
+          [
+            Math.min(triggerRect.left, contentRect.left) - buffer,
+            triggerRect.bottom
+          ],
+          [
+            Math.min(triggerRect.left, contentRect.left) - buffer,
+            contentRect.top
+          ],
+          [
+            Math.max(triggerRect.right, contentRect.right) + buffer,
+            contentRect.top
+          ],
+          [
+            Math.max(triggerRect.right, contentRect.right) + buffer,
+            triggerRect.bottom
+          ]
+        ];
+      case "left":
+        return [
+          [
+            triggerRect.left,
+            Math.min(triggerRect.top, contentRect.top) - buffer
+          ],
+          [
+            contentRect.right,
+            Math.min(triggerRect.top, contentRect.top) - buffer
+          ],
+          [
+            contentRect.right,
+            Math.max(triggerRect.bottom, contentRect.bottom) + buffer
+          ],
+          [
+            triggerRect.left,
+            Math.max(triggerRect.bottom, contentRect.bottom) + buffer
+          ]
+        ];
+      case "right":
+        return [
+          [
+            triggerRect.right,
+            Math.min(triggerRect.top, contentRect.top) - buffer
+          ],
+          [
+            contentRect.left,
+            Math.min(triggerRect.top, contentRect.top) - buffer
+          ],
+          [
+            contentRect.left,
+            Math.max(triggerRect.bottom, contentRect.bottom) + buffer
+          ],
+          [
+            triggerRect.right,
+            Math.max(triggerRect.bottom, contentRect.bottom) + buffer
+          ]
+        ];
+    }
+  }
+  /**
+   * Creates a triangular/trapezoidal safe zone from the exit point to the target
+   */
+  #getSafePolygon(exitPoint, targetRect, side, exitTarget) {
+    const buffer = this.#buffer * 4;
+    const [x, y] = exitPoint;
+    const effectiveSide = exitTarget === "trigger" ? this.#flipSide(side) : side;
+    switch (effectiveSide) {
+      case "top":
+        return [
+          [x - buffer, y + buffer],
+          [x + buffer, y + buffer],
+          [targetRect.right + buffer, targetRect.bottom],
+          [targetRect.right + buffer, targetRect.top],
+          [targetRect.left - buffer, targetRect.top],
+          [targetRect.left - buffer, targetRect.bottom]
+        ];
+      case "bottom":
+        return [
+          [x - buffer, y - buffer],
+          [x + buffer, y - buffer],
+          [targetRect.right + buffer, targetRect.top],
+          [targetRect.right + buffer, targetRect.bottom],
+          [targetRect.left - buffer, targetRect.bottom],
+          [targetRect.left - buffer, targetRect.top]
+        ];
+      case "left":
+        return [
+          [x + buffer, y - buffer],
+          [x + buffer, y + buffer],
+          [targetRect.right, targetRect.bottom + buffer],
+          [targetRect.left, targetRect.bottom + buffer],
+          [targetRect.left, targetRect.top - buffer],
+          [targetRect.right, targetRect.top - buffer]
+        ];
+      case "right":
+        return [
+          [x - buffer, y - buffer],
+          [x - buffer, y + buffer],
+          [targetRect.left, targetRect.bottom + buffer],
+          [targetRect.right, targetRect.bottom + buffer],
+          [targetRect.right, targetRect.top - buffer],
+          [targetRect.left, targetRect.top - buffer]
+        ];
+    }
+  }
+  #flipSide(side) {
+    switch (side) {
+      case "top":
+        return "bottom";
+      case "bottom":
+        return "top";
+      case "left":
+        return "right";
+      case "right":
+        return "left";
+    }
+  }
+}
+class TimeoutFn {
+  #interval;
+  #cb;
+  #timer = null;
+  constructor(cb, interval) {
+    this.#cb = cb;
+    this.#interval = interval;
+    this.stop = this.stop.bind(this);
+    this.start = this.start.bind(this);
+    onDestroyEffect(this.stop);
+  }
+  #clear() {
+    if (this.#timer !== null) {
+      window.clearTimeout(this.#timer);
+      this.#timer = null;
+    }
+  }
+  stop() {
+    this.#clear();
+  }
+  start(...args) {
+    this.#clear();
+    this.#timer = window.setTimeout(() => {
+      this.#timer = null;
+      this.#cb(...args);
+    }, this.#interval);
+  }
+}
+const tooltipAttrs = createBitsAttrs({ component: "tooltip", parts: ["content", "trigger"] });
+const TooltipProviderContext = new Context("Tooltip.Provider");
+const TooltipRootContext = new Context("Tooltip.Root");
+class TooltipTriggerRegistryState {
+  triggers = /* @__PURE__ */ new Map();
+  activeTriggerId = null;
+  #activeTriggerNode = derived(() => {
+    const activeTriggerId = this.activeTriggerId;
+    if (activeTriggerId === null) return null;
+    return this.triggers.get(activeTriggerId)?.node ?? null;
+  });
+  get activeTriggerNode() {
+    return this.#activeTriggerNode();
+  }
+  set activeTriggerNode($$value) {
+    return this.#activeTriggerNode($$value);
+  }
+  #activePayload = derived(() => {
+    const activeTriggerId = this.activeTriggerId;
+    if (activeTriggerId === null) return null;
+    return this.triggers.get(activeTriggerId)?.payload ?? null;
+  });
+  get activePayload() {
+    return this.#activePayload();
+  }
+  set activePayload($$value) {
+    return this.#activePayload($$value);
+  }
+  register = (record) => {
+    const next = new Map(this.triggers);
+    next.set(record.id, record);
+    this.triggers = next;
+    this.#coerceActiveTrigger();
+  };
+  update = (record) => {
+    const next = new Map(this.triggers);
+    next.set(record.id, record);
+    this.triggers = next;
+    this.#coerceActiveTrigger();
+  };
+  unregister = (id) => {
+    if (!this.triggers.has(id)) return;
+    const next = new Map(this.triggers);
+    next.delete(id);
+    this.triggers = next;
+    if (this.activeTriggerId === id) {
+      this.activeTriggerId = null;
+    }
+  };
+  setActiveTrigger = (id) => {
+    if (id === null) {
+      this.activeTriggerId = null;
+      return;
+    }
+    if (!this.triggers.has(id)) {
+      this.activeTriggerId = null;
+      return;
+    }
+    this.activeTriggerId = id;
+  };
+  get = (id) => {
+    return this.triggers.get(id);
+  };
+  has = (id) => {
+    return this.triggers.has(id);
+  };
+  getFirstTriggerId = () => {
+    const firstEntry = this.triggers.entries().next();
+    if (firstEntry.done) return null;
+    return firstEntry.value[0];
+  };
+  #coerceActiveTrigger = () => {
+    const activeTriggerId = this.activeTriggerId;
+    if (activeTriggerId === null) return;
+    if (!this.triggers.has(activeTriggerId)) {
+      this.activeTriggerId = null;
+    }
+  };
+}
+class TooltipProviderState {
+  static create(opts) {
+    return TooltipProviderContext.set(new TooltipProviderState(opts));
+  }
+  opts;
+  isOpenDelayed = true;
+  isPointerInTransit = simpleBox(false);
+  #timerFn;
+  #openTooltip = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.#timerFn = new TimeoutFn(
+      () => {
+        this.isOpenDelayed = true;
+      },
+      this.opts.skipDelayDuration.current
+    );
+  }
+  #startTimer = () => {
+    const skipDuration = this.opts.skipDelayDuration.current;
+    if (skipDuration === 0) {
+      this.isOpenDelayed = true;
+      return;
+    } else {
+      this.#timerFn.start();
+    }
+  };
+  #clearTimer = () => {
+    this.#timerFn.stop();
+  };
+  onOpen = (tooltip) => {
+    if (this.#openTooltip && this.#openTooltip !== tooltip) {
+      this.#openTooltip.handleClose();
+    }
+    this.#clearTimer();
+    this.isOpenDelayed = false;
+    this.#openTooltip = tooltip;
+  };
+  onClose = (tooltip) => {
+    if (this.#openTooltip === tooltip) {
+      this.#openTooltip = null;
+    }
+    this.#startTimer();
+  };
+  isTooltipOpen = (tooltip) => {
+    return this.#openTooltip === tooltip;
+  };
+}
+class TooltipRootState {
+  static create(opts) {
+    return TooltipRootContext.set(new TooltipRootState(opts, TooltipProviderContext.get()));
+  }
+  opts;
+  provider;
+  #delayDuration = derived(() => this.opts.delayDuration.current ?? this.provider.opts.delayDuration.current);
+  get delayDuration() {
+    return this.#delayDuration();
+  }
+  set delayDuration($$value) {
+    return this.#delayDuration($$value);
+  }
+  #disableHoverableContent = derived(() => this.opts.disableHoverableContent.current ?? this.provider.opts.disableHoverableContent.current);
+  get disableHoverableContent() {
+    return this.#disableHoverableContent();
+  }
+  set disableHoverableContent($$value) {
+    return this.#disableHoverableContent($$value);
+  }
+  #disableCloseOnTriggerClick = derived(() => this.opts.disableCloseOnTriggerClick.current ?? this.provider.opts.disableCloseOnTriggerClick.current);
+  get disableCloseOnTriggerClick() {
+    return this.#disableCloseOnTriggerClick();
+  }
+  set disableCloseOnTriggerClick($$value) {
+    return this.#disableCloseOnTriggerClick($$value);
+  }
+  #disabled = derived(() => this.opts.disabled.current ?? this.provider.opts.disabled.current);
+  get disabled() {
+    return this.#disabled();
+  }
+  set disabled($$value) {
+    return this.#disabled($$value);
+  }
+  #ignoreNonKeyboardFocus = derived(() => this.opts.ignoreNonKeyboardFocus.current ?? this.provider.opts.ignoreNonKeyboardFocus.current);
+  get ignoreNonKeyboardFocus() {
+    return this.#ignoreNonKeyboardFocus();
+  }
+  set ignoreNonKeyboardFocus($$value) {
+    return this.#ignoreNonKeyboardFocus($$value);
+  }
+  registry;
+  tether;
+  contentNode = null;
+  contentPresence;
+  #wasOpenDelayed = false;
+  #timerFn;
+  #stateAttr = derived(() => {
+    if (!this.opts.open.current) return "closed";
+    return this.#wasOpenDelayed ? "delayed-open" : "instant-open";
+  });
+  get stateAttr() {
+    return this.#stateAttr();
+  }
+  set stateAttr($$value) {
+    return this.#stateAttr($$value);
+  }
+  constructor(opts, provider) {
+    this.opts = opts;
+    this.provider = provider;
+    this.tether = opts.tether.current?.state ?? null;
+    this.registry = this.tether?.registry ?? new TooltipTriggerRegistryState();
+    this.#timerFn = new TimeoutFn(
+      () => {
+        this.#wasOpenDelayed = true;
+        this.opts.open.current = true;
+      },
+      this.delayDuration ?? 0
+    );
+    if (this.tether) {
+      this.tether.root = this;
+    }
+    this.contentPresence = new PresenceManager({
+      open: this.opts.open,
+      ref: boxWith(() => this.contentNode),
+      onComplete: () => {
+        this.opts.onOpenChangeComplete.current(this.opts.open.current);
+      }
+    });
+    watch(() => this.delayDuration, () => {
+      if (this.delayDuration === void 0) return;
+      this.#timerFn = new TimeoutFn(
+        () => {
+          this.#wasOpenDelayed = true;
+          this.opts.open.current = true;
+        },
+        this.delayDuration
+      );
+    });
+    watch(
+      () => this.opts.open.current,
+      (isOpen) => {
+        if (isOpen) {
+          this.ensureActiveTrigger();
+          this.provider.onOpen(this);
+        } else {
+          this.provider.onClose(this);
+        }
+      },
+      { lazy: true }
+    );
+    watch(() => this.opts.triggerId.current, (triggerId) => {
+      if (triggerId === this.registry.activeTriggerId) return;
+      this.registry.setActiveTrigger(triggerId);
+    });
+    watch(() => this.registry.activeTriggerId, (activeTriggerId) => {
+      if (this.opts.triggerId.current === activeTriggerId) return;
+      this.opts.triggerId.current = activeTriggerId;
+    });
+  }
+  handleOpen = () => {
+    this.#timerFn.stop();
+    this.#wasOpenDelayed = false;
+    this.ensureActiveTrigger();
+    this.opts.open.current = true;
+  };
+  handleClose = () => {
+    this.#timerFn.stop();
+    this.opts.open.current = false;
+  };
+  #handleDelayedOpen = () => {
+    this.#timerFn.stop();
+    const shouldSkipDelay = !this.provider.isOpenDelayed;
+    const delayDuration = this.delayDuration ?? 0;
+    if (shouldSkipDelay || delayDuration === 0) {
+      this.#wasOpenDelayed = false;
+      this.opts.open.current = true;
+    } else {
+      this.#timerFn.start();
+    }
+  };
+  onTriggerEnter = (triggerId) => {
+    this.setActiveTrigger(triggerId);
+    this.#handleDelayedOpen();
+  };
+  onTriggerLeave = () => {
+    if (this.disableHoverableContent) {
+      this.handleClose();
+    } else {
+      this.#timerFn.stop();
+    }
+  };
+  ensureActiveTrigger = () => {
+    if (this.registry.activeTriggerId !== null && this.registry.has(this.registry.activeTriggerId)) {
+      return;
+    }
+    if (this.opts.triggerId.current !== null && this.registry.has(this.opts.triggerId.current)) {
+      this.registry.setActiveTrigger(this.opts.triggerId.current);
+      return;
+    }
+    const firstTriggerId = this.registry.getFirstTriggerId();
+    this.registry.setActiveTrigger(firstTriggerId);
+  };
+  setActiveTrigger = (triggerId) => {
+    this.registry.setActiveTrigger(triggerId);
+  };
+  registerTrigger = (trigger) => {
+    this.registry.register(trigger);
+    if (trigger.disabled && this.registry.activeTriggerId === trigger.id && this.opts.open.current) {
+      this.handleClose();
+    }
+  };
+  updateTrigger = (trigger) => {
+    this.registry.update(trigger);
+    if (trigger.disabled && this.registry.activeTriggerId === trigger.id && this.opts.open.current) {
+      this.handleClose();
+    }
+  };
+  unregisterTrigger = (id) => {
+    const isActive = this.registry.activeTriggerId === id;
+    this.registry.unregister(id);
+    if (isActive && this.opts.open.current) {
+      this.handleClose();
+    }
+  };
+  isActiveTrigger = (triggerId) => {
+    return this.registry.activeTriggerId === triggerId;
+  };
+  get triggerNode() {
+    return this.registry.activeTriggerNode;
+  }
+  get activePayload() {
+    return this.registry.activePayload;
+  }
+  get activeTriggerId() {
+    return this.registry.activeTriggerId;
+  }
+}
+class TooltipTriggerState {
+  static create(opts) {
+    if (opts.tether.current) {
+      return new TooltipTriggerState(opts, null, opts.tether.current.state);
+    }
+    return new TooltipTriggerState(opts, TooltipRootContext.get(), null);
+  }
+  opts;
+  root;
+  tether;
+  attachment;
+  #isPointerDown = simpleBox(false);
+  #hasPointerMoveOpened = false;
+  domContext;
+  #transitCheckTimeout = null;
+  #mounted = false;
+  #lastRegisteredId = null;
+  constructor(opts, root, tether) {
+    this.opts = opts;
+    this.root = root;
+    this.tether = tether;
+    this.domContext = new DOMContext(opts.ref);
+    this.attachment = attachRef(this.opts.ref, (v) => this.#register(v));
+    watch(() => this.opts.id.current, () => {
+      this.#register(this.opts.ref.current);
+    });
+    watch(() => this.opts.payload.current, () => {
+      this.#register(this.opts.ref.current);
+    });
+    watch(() => this.opts.disabled.current, () => {
+      this.#register(this.opts.ref.current);
+    });
+  }
+  #getRoot = () => {
+    return this.tether?.root ?? this.root;
+  };
+  #isDisabled = () => {
+    const root = this.#getRoot();
+    return this.opts.disabled.current || Boolean(root?.disabled);
+  };
+  #register = (node) => {
+    if (!this.#mounted) return;
+    const id = this.opts.id.current;
+    const payload = this.opts.payload.current;
+    const disabled = this.opts.disabled.current;
+    if (this.#lastRegisteredId && this.#lastRegisteredId !== id) {
+      const root2 = this.#getRoot();
+      if (this.tether) {
+        this.tether.registry.unregister(this.#lastRegisteredId);
+      } else {
+        root2?.unregisterTrigger(this.#lastRegisteredId);
+      }
+    }
+    const triggerRecord = { id, node, payload, disabled };
+    const root = this.#getRoot();
+    if (this.tether) {
+      if (this.tether.registry.has(id)) {
+        this.tether.registry.update(triggerRecord);
+      } else {
+        this.tether.registry.register(triggerRecord);
+      }
+      if (disabled && this.tether.registry.activeTriggerId === id && root?.opts.open.current) {
+        root.handleClose();
+      }
+    } else {
+      if (root?.registry.has(id)) {
+        root.updateTrigger(triggerRecord);
+      } else {
+        root?.registerTrigger(triggerRecord);
+      }
+    }
+    this.#lastRegisteredId = id;
+  };
+  #clearTransitCheck = () => {
+    if (this.#transitCheckTimeout !== null) {
+      clearTimeout(this.#transitCheckTimeout);
+      this.#transitCheckTimeout = null;
+    }
+  };
+  handlePointerUp = () => {
+    this.#isPointerDown.current = false;
+  };
+  #onpointerup = () => {
+    if (this.#isDisabled()) return;
+    this.#isPointerDown.current = false;
+  };
+  #onpointerdown = () => {
+    if (this.#isDisabled()) return;
+    this.#isPointerDown.current = true;
+    this.domContext.getDocument().addEventListener(
+      "pointerup",
+      () => {
+        this.handlePointerUp();
+      },
+      { once: true }
+    );
+  };
+  #onpointerenter = (e) => {
+    const root = this.#getRoot();
+    if (!root) return;
+    if (this.#isDisabled()) {
+      if (root.opts.open.current) {
+        root.handleClose();
+      }
+      return;
+    }
+    if (e.pointerType === "touch") return;
+    if (root.provider.isPointerInTransit.current) {
+      this.#clearTransitCheck();
+      this.#transitCheckTimeout = window.setTimeout(
+        () => {
+          if (root.provider.isPointerInTransit.current) {
+            root.provider.isPointerInTransit.current = false;
+            root.onTriggerEnter(this.opts.id.current);
+            this.#hasPointerMoveOpened = true;
+          }
+        },
+        250
+      );
+      return;
+    }
+    root.onTriggerEnter(this.opts.id.current);
+    this.#hasPointerMoveOpened = true;
+  };
+  #onpointermove = (e) => {
+    const root = this.#getRoot();
+    if (!root) return;
+    if (this.#isDisabled()) {
+      if (root.opts.open.current) {
+        root.handleClose();
+      }
+      return;
+    }
+    if (e.pointerType === "touch") return;
+    if (this.#hasPointerMoveOpened) return;
+    this.#clearTransitCheck();
+    root.provider.isPointerInTransit.current = false;
+    root.onTriggerEnter(this.opts.id.current);
+    this.#hasPointerMoveOpened = true;
+  };
+  #onpointerleave = (e) => {
+    const root = this.#getRoot();
+    if (!root) return;
+    if (this.#isDisabled()) return;
+    this.#clearTransitCheck();
+    if (!root.isActiveTrigger(this.opts.id.current)) {
+      this.#hasPointerMoveOpened = false;
+      return;
+    }
+    const relatedTarget = e.relatedTarget;
+    if (isElement(relatedTarget)) {
+      for (const record of root.registry.triggers.values()) {
+        if (record.node !== relatedTarget) continue;
+        if (root.provider.opts.skipDelayDuration.current > 0) {
+          this.#hasPointerMoveOpened = false;
+          return;
+        }
+        root.handleClose();
+        this.#hasPointerMoveOpened = false;
+        return;
+      }
+    }
+    root.onTriggerLeave();
+    this.#hasPointerMoveOpened = false;
+  };
+  #onfocus = (e) => {
+    const root = this.#getRoot();
+    if (!root) return;
+    if (this.#isPointerDown.current) return;
+    if (this.#isDisabled()) {
+      if (root.opts.open.current) {
+        root.handleClose();
+      }
+      return;
+    }
+    if (root.ignoreNonKeyboardFocus && !isFocusVisible(e.currentTarget)) return;
+    root.setActiveTrigger(this.opts.id.current);
+    root.handleOpen();
+  };
+  #onblur = () => {
+    const root = this.#getRoot();
+    if (!root || this.#isDisabled()) return;
+    root.handleClose();
+  };
+  #onclick = () => {
+    const root = this.#getRoot();
+    if (!root || root.disableCloseOnTriggerClick || this.#isDisabled()) return;
+    root.handleClose();
+  };
+  #props = derived(() => {
+    const root = this.#getRoot();
+    const isOpenForTrigger = Boolean(root?.opts.open.current && root.isActiveTrigger(this.opts.id.current));
+    const isDisabled = this.#isDisabled();
+    return {
+      id: this.opts.id.current,
+      "aria-describedby": isOpenForTrigger ? root?.contentNode?.id : void 0,
+      "data-state": isOpenForTrigger ? root?.stateAttr : "closed",
+      "data-disabled": boolToEmptyStrOrUndef(isDisabled),
+      "data-delay-duration": `${root?.delayDuration ?? 0}`,
+      [tooltipAttrs.trigger]: "",
+      tabindex: isDisabled ? void 0 : this.opts.tabindex.current,
+      disabled: this.opts.disabled.current,
+      onpointerup: this.#onpointerup,
+      onpointerdown: this.#onpointerdown,
+      onpointerenter: this.#onpointerenter,
+      onpointermove: this.#onpointermove,
+      onpointerleave: this.#onpointerleave,
+      onfocus: this.#onfocus,
+      onblur: this.#onblur,
+      onclick: this.#onclick,
+      ...this.attachment
+    };
+  });
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class TooltipContentState {
+  static create(opts) {
+    return new TooltipContentState(opts, TooltipRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.attachment = attachRef(this.opts.ref, (v) => this.root.contentNode = v);
+    new SafePolygon({
+      triggerNode: () => this.root.triggerNode,
+      contentNode: () => this.root.contentNode,
+      enabled: () => this.root.opts.open.current && !this.root.disableHoverableContent,
+      transitIntentTimeout: 180,
+      ignoredTargets: () => {
+        if (this.root.provider.opts.skipDelayDuration.current === 0) return [];
+        const nodes = [];
+        const activeTriggerNode = this.root.triggerNode;
+        for (const record of this.root.registry.triggers.values()) {
+          if (record.node && record.node !== activeTriggerNode) {
+            nodes.push(record.node);
+          }
+        }
+        return nodes;
+      },
+      onPointerExit: () => {
+        if (this.root.provider.isTooltipOpen(this.root)) {
+          this.root.handleClose();
+        }
+      }
+    });
+  }
+  onInteractOutside = (e) => {
+    if (isElement(e.target) && this.root.triggerNode?.contains(e.target) && this.root.disableCloseOnTriggerClick) {
+      e.preventDefault();
+      return;
+    }
+    this.opts.onInteractOutside.current(e);
+    if (e.defaultPrevented) return;
+    this.root.handleClose();
+  };
+  onEscapeKeydown = (e) => {
+    this.opts.onEscapeKeydown.current?.(e);
+    if (e.defaultPrevented) return;
+    this.root.handleClose();
+  };
+  onOpenAutoFocus = (e) => {
+    e.preventDefault();
+  };
+  onCloseAutoFocus = (e) => {
+    e.preventDefault();
+  };
+  get shouldRender() {
+    return this.root.contentPresence.shouldRender;
+  }
+  #snippetProps = derived(() => ({ open: this.root.opts.open.current }));
+  get snippetProps() {
+    return this.#snippetProps();
+  }
+  set snippetProps($$value) {
+    return this.#snippetProps($$value);
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    "data-state": this.root.stateAttr,
+    "data-disabled": boolToEmptyStrOrUndef(this.root.disabled),
+    style: { outline: "none" },
+    [tooltipAttrs.content]: "",
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+  popperProps = {
+    onInteractOutside: this.onInteractOutside,
+    onEscapeKeydown: this.onEscapeKeydown,
+    onOpenAutoFocus: this.onOpenAutoFocus,
+    onCloseAutoFocus: this.onCloseAutoFocus
+  };
+}
+function Tooltip$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      open = false,
+      triggerId = null,
+      onOpenChange = noop,
+      onOpenChangeComplete = noop,
+      disabled,
+      delayDuration,
+      disableCloseOnTriggerClick,
+      disableHoverableContent,
+      ignoreNonKeyboardFocus,
+      tether,
+      children
+    } = $$props;
+    const rootState = TooltipRootState.create({
+      open: boxWith(() => open, (v) => {
+        open = v;
+        onOpenChange(v);
+      }),
+      triggerId: boxWith(() => triggerId, (v) => {
+        triggerId = v;
+      }),
+      delayDuration: boxWith(() => delayDuration),
+      disableCloseOnTriggerClick: boxWith(() => disableCloseOnTriggerClick),
+      disableHoverableContent: boxWith(() => disableHoverableContent),
+      ignoreNonKeyboardFocus: boxWith(() => ignoreNonKeyboardFocus),
+      disabled: boxWith(() => disabled),
+      onOpenChangeComplete: boxWith(() => onOpenChangeComplete),
+      tether: boxWith(() => tether)
+    });
+    Floating_layer($$renderer2, {
+      tooltip: true,
+      children: ($$renderer3) => {
+        children?.($$renderer3, {
+          open: rootState.opts.open.current,
+          triggerId: rootState.activeTriggerId,
+          payload: rootState.activePayload
+        });
+        $$renderer3.push(`<!---->`);
+      }
+    });
+    bind_props($$props, { open, triggerId });
+  });
+}
+function Tooltip_content$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const uid = props_id($$renderer2);
+    let {
+      children,
+      child,
+      id = createId(uid),
+      ref = null,
+      side = "top",
+      sideOffset = 0,
+      align = "center",
+      avoidCollisions = true,
+      arrowPadding = 0,
+      sticky = "partial",
+      strategy,
+      hideWhenDetached = false,
+      customAnchor,
+      collisionPadding = 0,
+      onInteractOutside = noop,
+      onEscapeKeydown = noop,
+      forceMount = false,
+      style,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const contentState = TooltipContentState.create({
+      id: boxWith(() => id),
+      ref: boxWith(() => ref, (v) => ref = v),
+      onInteractOutside: boxWith(() => onInteractOutside),
+      onEscapeKeydown: boxWith(() => onEscapeKeydown)
+    });
+    const floatingProps = derived(() => ({
+      side,
+      sideOffset,
+      align,
+      avoidCollisions,
+      arrowPadding,
+      sticky,
+      hideWhenDetached,
+      collisionPadding,
+      strategy,
+      customAnchor: customAnchor ?? contentState.root.triggerNode
+    }));
+    const mergedProps = derived(() => mergeProps(restProps, floatingProps(), contentState.props));
+    if (forceMount) {
+      $$renderer2.push("<!--[0-->");
+      {
+        let popper = function($$renderer3, { props, wrapperProps }) {
+          const finalProps = mergeProps(props, { style: getFloatingContentCSSVars("tooltip") }, { style });
+          if (child) {
+            $$renderer3.push("<!--[0-->");
+            child($$renderer3, {
+              props: finalProps,
+              wrapperProps,
+              ...contentState.snippetProps
+            });
+            $$renderer3.push(`<!---->`);
+          } else {
+            $$renderer3.push("<!--[-1-->");
+            $$renderer3.push(`<div${attributes({ ...wrapperProps })}><div${attributes({ ...finalProps })}>`);
+            children?.($$renderer3);
+            $$renderer3.push(`<!----></div></div>`);
+          }
+          $$renderer3.push(`<!--]-->`);
+        };
+        Popper_layer_force_mount($$renderer2, spread_props([
+          mergedProps(),
+          contentState.popperProps,
+          {
+            enabled: contentState.root.opts.open.current,
+            id,
+            trapFocus: false,
+            loop: false,
+            preventScroll: false,
+            forceMount: true,
+            ref: contentState.opts.ref,
+            tooltip: true,
+            shouldRender: contentState.shouldRender,
+            contentPointerEvents: contentState.root.disableHoverableContent ? "none" : "auto",
+            popper,
+            $$slots: { popper: true }
+          }
+        ]));
+      }
+    } else if (!forceMount) {
+      $$renderer2.push("<!--[1-->");
+      {
+        let popper = function($$renderer3, { props, wrapperProps }) {
+          const finalProps = mergeProps(props, { style: getFloatingContentCSSVars("tooltip") }, { style });
+          if (child) {
+            $$renderer3.push("<!--[0-->");
+            child($$renderer3, {
+              props: finalProps,
+              wrapperProps,
+              ...contentState.snippetProps
+            });
+            $$renderer3.push(`<!---->`);
+          } else {
+            $$renderer3.push("<!--[-1-->");
+            $$renderer3.push(`<div${attributes({ ...wrapperProps })}><div${attributes({ ...finalProps })}>`);
+            children?.($$renderer3);
+            $$renderer3.push(`<!----></div></div>`);
+          }
+          $$renderer3.push(`<!--]-->`);
+        };
+        Popper_layer($$renderer2, spread_props([
+          mergedProps(),
+          contentState.popperProps,
+          {
+            open: contentState.root.opts.open.current,
+            id,
+            trapFocus: false,
+            loop: false,
+            preventScroll: false,
+            forceMount: false,
+            ref: contentState.opts.ref,
+            tooltip: true,
+            shouldRender: contentState.shouldRender,
+            contentPointerEvents: contentState.root.disableHoverableContent ? "none" : "auto",
+            popper,
+            $$slots: { popper: true }
+          }
+        ]));
+      }
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Tooltip_trigger$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const uid = props_id($$renderer2);
+    let {
+      children,
+      child,
+      id = createId(uid),
+      disabled = false,
+      payload,
+      tether,
+      type = "button",
+      tabindex = 0,
+      ref = null,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const triggerState = TooltipTriggerState.create({
+      id: boxWith(() => id),
+      disabled: boxWith(() => disabled ?? false),
+      tabindex: boxWith(() => tabindex ?? 0),
+      payload: boxWith(() => payload),
+      tether: boxWith(() => tether),
+      ref: boxWith(() => ref, (v) => ref = v)
+    });
+    const mergedProps = derived(() => mergeProps(restProps, triggerState.props, { type }));
+    if (child) {
+      $$renderer2.push("<!--[0-->");
+      child($$renderer2, { props: mergedProps() });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<button${attributes({ ...mergedProps() })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></button>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Tooltip_arrow($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { ref = null, $$slots, $$events, ...restProps } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      Floating_layer_arrow($$renderer3, spread_props([
+        restProps,
+        {
+          get ref() {
+            return ref;
+          },
+          set ref($$value) {
+            ref = $$value;
+            $$settled = false;
+          }
+        }
+      ]));
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Tooltip_provider$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      children,
+      delayDuration = 700,
+      disableCloseOnTriggerClick = false,
+      disableHoverableContent = false,
+      disabled = false,
+      ignoreNonKeyboardFocus = false,
+      skipDelayDuration = 300
+    } = $$props;
+    TooltipProviderState.create({
+      delayDuration: boxWith(() => delayDuration),
+      disableCloseOnTriggerClick: boxWith(() => disableCloseOnTriggerClick),
+      disableHoverableContent: boxWith(() => disableHoverableContent),
+      disabled: boxWith(() => disabled),
+      ignoreNonKeyboardFocus: boxWith(() => ignoreNonKeyboardFocus),
+      skipDelayDuration: boxWith(() => skipDelayDuration)
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+function Tooltip($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { open = false, $$slots, $$events, ...restProps } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Tooltip$1) {
+        $$renderer3.push("<!--[-->");
+        Tooltip$1($$renderer3, spread_props([
+          restProps,
+          {
+            get open() {
+              return open;
+            },
+            set open($$value) {
+              open = $$value;
+              $$settled = false;
+            }
+          }
+        ]));
+        $$renderer3.push("<!--]-->");
+      } else {
+        $$renderer3.push("<!--[!-->");
+        $$renderer3.push("<!--]-->");
+      }
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { open });
+  });
+}
+function Tooltip_trigger($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { ref = null, $$slots, $$events, ...restProps } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Tooltip_trigger$1) {
+        $$renderer3.push("<!--[-->");
+        Tooltip_trigger$1($$renderer3, spread_props([
+          { "data-slot": "tooltip-trigger" },
+          restProps,
+          {
+            get ref() {
+              return ref;
+            },
+            set ref($$value) {
+              ref = $$value;
+              $$settled = false;
+            }
+          }
+        ]));
+        $$renderer3.push("<!--]-->");
+      } else {
+        $$renderer3.push("<!--[!-->");
+        $$renderer3.push("<!--]-->");
+      }
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Tooltip_portal($$renderer, $$props) {
+  let { $$slots, $$events, ...restProps } = $$props;
+  if (Portal) {
+    $$renderer.push("<!--[-->");
+    Portal($$renderer, spread_props([restProps]));
+    $$renderer.push("<!--]-->");
+  } else {
+    $$renderer.push("<!--[!-->");
+    $$renderer.push("<!--]-->");
+  }
+}
+function Tooltip_content($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      sideOffset = 0,
+      side = "top",
+      children,
+      arrowClasses,
+      portalProps,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      Tooltip_portal($$renderer3, spread_props([
+        portalProps,
+        {
+          children: ($$renderer4) => {
+            if (Tooltip_content$1) {
+              $$renderer4.push("<!--[-->");
+              Tooltip_content$1($$renderer4, spread_props([
+                {
+                  "data-slot": "tooltip-content",
+                  sideOffset,
+                  side,
+                  class: cn("bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-end-2 data-[side=right]:slide-in-from-start-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit origin-(--bits-tooltip-content-transform-origin) rounded-md px-3 py-1.5 text-xs text-balance", className)
+                },
+                restProps,
+                {
+                  get ref() {
+                    return ref;
+                  },
+                  set ref($$value) {
+                    ref = $$value;
+                    $$settled = false;
+                  },
+                  children: ($$renderer5) => {
+                    children?.($$renderer5);
+                    $$renderer5.push(`<!----> `);
+                    {
+                      let child = function($$renderer6, { props }) {
+                        $$renderer6.push(`<div${attributes({
+                          class: clsx(cn("bg-foreground z-50 size-2.5 rotate-45 rounded-[2px]", "data-[side=top]:translate-x-1/2 data-[side=top]:translate-y-[calc(-50%_+_2px)]", "data-[side=bottom]:-translate-x-1/2 data-[side=bottom]:-translate-y-[calc(-50%_+_1px)]", "data-[side=right]:translate-x-[calc(50%_+_2px)] data-[side=right]:translate-y-1/2", "data-[side=left]:-translate-y-[calc(50%_-_3px)]", arrowClasses)),
+                          ...props
+                        })}></div>`);
+                      };
+                      if (Tooltip_arrow) {
+                        $$renderer5.push("<!--[-->");
+                        Tooltip_arrow($$renderer5, { child, $$slots: { child: true } });
+                        $$renderer5.push("<!--]-->");
+                      } else {
+                        $$renderer5.push("<!--[!-->");
+                        $$renderer5.push("<!--]-->");
+                      }
+                    }
+                  },
+                  $$slots: { default: true }
+                }
+              ]));
+              $$renderer4.push("<!--]-->");
+            } else {
+              $$renderer4.push("<!--[!-->");
+              $$renderer4.push("<!--]-->");
+            }
+          },
+          $$slots: { default: true }
+        }
+      ]));
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Tooltip_provider($$renderer, $$props) {
+  let { $$slots, $$events, ...restProps } = $$props;
+  if (Tooltip_provider$1) {
+    $$renderer.push("<!--[-->");
+    Tooltip_provider$1($$renderer, spread_props([restProps]));
+    $$renderer.push("<!--]-->");
+  } else {
+    $$renderer.push("<!--[!-->");
+    $$renderer.push("<!--]-->");
+  }
+}
+const sidebarMenuButtonVariants = tv({
+  base: "peer/menu-button ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-accent-foreground active:bg-sidebar-accent active:text-sidebar-accent-foreground data-[active=true]:bg-sidebar-accent data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-start text-sm outline-hidden transition-[width,height,padding] group-has-data-[sidebar=menu-action]/menu-item:pe-8 group-data-[collapsible=icon]:size-8! group-data-[collapsible=icon]:p-2! focus-visible:ring-2 disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:font-medium [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
+  variants: {
+    variant: {
+      default: "hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
+      outline: "bg-background hover:bg-sidebar-accent hover:text-sidebar-accent-foreground shadow-[0_0_0_1px_var(--sidebar-border)] hover:shadow-[0_0_0_1px_var(--sidebar-accent)]"
+    },
+    size: {
+      default: "h-8 text-sm",
+      sm: "h-7 text-xs",
+      lg: "h-12 text-sm group-data-[collapsible=icon]:p-0!"
+    }
+  },
+  defaultVariants: { variant: "default", size: "default" }
+});
+function Sidebar_menu_button($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      child,
+      variant = "default",
+      size: size2 = "default",
+      isActive = false,
+      tooltipContent,
+      tooltipContentProps,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const sidebar = useSidebar();
+    const buttonProps = derived(() => ({
+      class: cn(sidebarMenuButtonVariants({ variant, size: size2 }), className),
+      "data-slot": "sidebar-menu-button",
+      "data-sidebar": "menu-button",
+      "data-size": size2,
+      "data-active": isActive,
+      ...restProps
+    }));
+    function Button2($$renderer3, { props }) {
+      const mergedProps = mergeProps(buttonProps(), props);
+      if (child) {
+        $$renderer3.push("<!--[0-->");
+        child($$renderer3, { props: mergedProps });
+        $$renderer3.push(`<!---->`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`<button${attributes({ ...mergedProps })}>`);
+        children?.($$renderer3);
+        $$renderer3.push(`<!----></button>`);
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    if (!tooltipContent) {
+      $$renderer2.push("<!--[0-->");
+      Button2($$renderer2, {});
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      if (Tooltip) {
+        $$renderer2.push("<!--[-->");
+        Tooltip($$renderer2, {
+          children: ($$renderer3) => {
+            {
+              let child2 = function($$renderer4, { props }) {
+                Button2($$renderer4, { props });
+              };
+              if (Tooltip_trigger) {
+                $$renderer3.push("<!--[-->");
+                Tooltip_trigger($$renderer3, { child: child2, $$slots: { child: true } });
+                $$renderer3.push("<!--]-->");
+              } else {
+                $$renderer3.push("<!--[!-->");
+                $$renderer3.push("<!--]-->");
+              }
+            }
+            $$renderer3.push(` `);
+            if (Tooltip_content) {
+              $$renderer3.push("<!--[-->");
+              Tooltip_content($$renderer3, spread_props([
+                {
+                  side: "right",
+                  align: "center",
+                  hidden: sidebar.state !== "collapsed" || sidebar.isMobile
+                },
+                tooltipContentProps,
+                {
+                  children: ($$renderer4) => {
+                    if (typeof tooltipContent === "string") {
+                      $$renderer4.push("<!--[0-->");
+                      $$renderer4.push(`${escape_html(tooltipContent)}`);
+                    } else if (tooltipContent) {
+                      $$renderer4.push("<!--[1-->");
+                      tooltipContent($$renderer4);
+                      $$renderer4.push(`<!---->`);
+                    } else {
+                      $$renderer4.push("<!--[-1-->");
+                    }
+                    $$renderer4.push(`<!--]-->`);
+                  },
+                  $$slots: { default: true }
+                }
+              ]));
+              $$renderer3.push("<!--]-->");
+            } else {
+              $$renderer3.push("<!--[!-->");
+              $$renderer3.push("<!--]-->");
+            }
+          },
+          $$slots: { default: true }
+        });
+        $$renderer2.push("<!--]-->");
+      } else {
+        $$renderer2.push("<!--[!-->");
+        $$renderer2.push("<!--]-->");
+      }
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar_menu_item($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<li${attributes({
+      "data-slot": "sidebar-menu-item",
+      "data-sidebar": "menu-item",
+      class: clsx(cn("group/menu-item relative", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></li>`);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar_menu($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<ul${attributes({
+      "data-slot": "sidebar-menu",
+      "data-sidebar": "menu",
+      class: clsx(cn("flex w-full min-w-0 flex-col gap-1", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></ul>`);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar_provider($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      open = true,
+      onOpenChange = () => {
+      },
+      class: className,
+      style,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    setSidebar({
+      open: () => open,
+      setOpen: (value) => {
+        open = value;
+        onOpenChange(value);
+        document.cookie = `${SIDEBAR_COOKIE_NAME}=${open}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}`;
+      }
+    });
+    if (Tooltip_provider) {
+      $$renderer2.push("<!--[-->");
+      Tooltip_provider($$renderer2, {
+        delayDuration: 0,
+        children: ($$renderer3) => {
+          $$renderer3.push(`<div${attributes({
+            "data-slot": "sidebar-wrapper",
+            style: `--sidebar-width: ${stringify(SIDEBAR_WIDTH)}; --sidebar-width-icon: ${stringify(SIDEBAR_WIDTH_ICON)}; ${stringify(style)}`,
+            class: clsx(cn("group/sidebar-wrapper has-data-[variant=inset]:bg-sidebar flex min-h-svh w-full", className)),
+            ...restProps
+          })}>`);
+          children?.($$renderer3);
+          $$renderer3.push(`<!----></div>`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push("<!--]-->");
+    } else {
+      $$renderer2.push("<!--[!-->");
+      $$renderer2.push("<!--]-->");
+    }
+    bind_props($$props, { ref, open });
+  });
+}
+function Panel_left($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { $$slots, $$events, ...props } = $$props;
+    const iconNode = [
+      [
+        "rect",
+        { "width": "18", "height": "18", "x": "3", "y": "3", "rx": "2" }
+      ],
+      ["path", { "d": "M9 3v18" }]
+    ];
+    Icon($$renderer2, spread_props([
+      { name: "panel-left" },
+      /**
+       * @component @name PanelLeft
+       * @description Lucide SVG icon component, renders SVG Element with children.
+       *
+       * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cmVjdCB3aWR0aD0iMTgiIGhlaWdodD0iMTgiIHg9IjMiIHk9IjMiIHJ4PSIyIiAvPgogIDxwYXRoIGQ9Ik05IDN2MTgiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/panel-left
+       * @see https://lucide.dev/guide/packages/lucide-svelte - Documentation
+       *
+       * @param {Object} props - Lucide icons props and any valid SVG attribute
+       * @returns {FunctionalComponent} Svelte component
+       *
+       */
+      props,
+      {
+        iconNode,
+        children: ($$renderer3) => {
+          props.children?.($$renderer3);
+          $$renderer3.push(`<!---->`);
+        },
+        $$slots: { default: true }
+      }
+    ]));
+  });
+}
+function Sidebar_trigger($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      onclick,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const sidebar = useSidebar();
+    Button($$renderer2, spread_props([
+      {
+        "data-sidebar": "trigger",
+        "data-slot": "sidebar-trigger",
+        variant: "ghost",
+        size: "icon",
+        class: cn("size-7", className),
+        type: "button",
+        onclick: (e) => {
+          onclick?.(e);
+          sidebar.toggle();
+        }
+      },
+      restProps,
+      {
+        children: ($$renderer3) => {
+          Panel_left($$renderer3, {});
+          $$renderer3.push(`<!----> <span class="sr-only">Toggle Sidebar</span>`);
+        },
+        $$slots: { default: true }
+      }
+    ]));
+    bind_props($$props, { ref });
+  });
+}
+function Sheet($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { open = false, $$slots, $$events, ...restProps } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Dialog) {
+        $$renderer3.push("<!--[-->");
+        Dialog($$renderer3, spread_props([
+          restProps,
+          {
+            get open() {
+              return open;
+            },
+            set open($$value) {
+              open = $$value;
+              $$settled = false;
+            }
+          }
+        ]));
+        $$renderer3.push("<!--]-->");
+      } else {
+        $$renderer3.push("<!--[!-->");
+        $$renderer3.push("<!--]-->");
+      }
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { open });
+  });
+}
+function Sheet_portal($$renderer, $$props) {
+  let { $$slots, $$events, ...restProps } = $$props;
+  if (Portal) {
+    $$renderer.push("<!--[-->");
+    Portal($$renderer, spread_props([restProps]));
+    $$renderer.push("<!--]-->");
+  } else {
+    $$renderer.push("<!--[!-->");
+    $$renderer.push("<!--]-->");
+  }
+}
+function Sheet_overlay($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Dialog_overlay) {
+        $$renderer3.push("<!--[-->");
+        Dialog_overlay($$renderer3, spread_props([
+          {
+            "data-slot": "sheet-overlay",
+            class: cn("data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50", className)
+          },
+          restProps,
+          {
+            get ref() {
+              return ref;
+            },
+            set ref($$value) {
+              ref = $$value;
+              $$settled = false;
+            }
+          }
+        ]));
+        $$renderer3.push("<!--]-->");
+      } else {
+        $$renderer3.push("<!--[!-->");
+        $$renderer3.push("<!--]-->");
+      }
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+const sheetVariants = tv({
+  base: "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out fixed z-50 flex flex-col gap-4 shadow-lg transition ease-in-out data-[state=closed]:duration-300 data-[state=open]:duration-500",
+  variants: {
+    side: {
+      top: "data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top inset-x-0 top-0 h-auto border-b",
+      bottom: "data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom inset-x-0 bottom-0 h-auto border-t",
+      left: "data-[state=closed]:slide-out-to-start data-[state=open]:slide-in-from-start inset-y-0 start-0 h-full w-3/4 border-e sm:max-w-sm",
+      right: "data-[state=closed]:slide-out-to-end data-[state=open]:slide-in-from-end inset-y-0 end-0 h-full w-3/4 border-s sm:max-w-sm"
+    }
+  },
+  defaultVariants: { side: "right" }
+});
+function Sheet_content($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      side = "right",
+      portalProps,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      Sheet_portal($$renderer3, spread_props([
+        portalProps,
+        {
+          children: ($$renderer4) => {
+            Sheet_overlay($$renderer4, {});
+            $$renderer4.push(`<!----> `);
+            if (Dialog_content) {
+              $$renderer4.push("<!--[-->");
+              Dialog_content($$renderer4, spread_props([
+                {
+                  "data-slot": "sheet-content",
+                  class: cn(sheetVariants({ side }), className)
+                },
+                restProps,
+                {
+                  get ref() {
+                    return ref;
+                  },
+                  set ref($$value) {
+                    ref = $$value;
+                    $$settled = false;
+                  },
+                  children: ($$renderer5) => {
+                    children?.($$renderer5);
+                    $$renderer5.push(`<!----> `);
+                    if (Dialog_close) {
+                      $$renderer5.push("<!--[-->");
+                      Dialog_close($$renderer5, {
+                        class: "ring-offset-background focus-visible:ring-ring absolute end-4 top-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:outline-hidden disabled:pointer-events-none",
+                        children: ($$renderer6) => {
+                          X($$renderer6, { class: "size-4" });
+                          $$renderer6.push(`<!----> <span class="sr-only">Close</span>`);
+                        },
+                        $$slots: { default: true }
+                      });
+                      $$renderer5.push("<!--]-->");
+                    } else {
+                      $$renderer5.push("<!--[!-->");
+                      $$renderer5.push("<!--]-->");
+                    }
+                  },
+                  $$slots: { default: true }
+                }
+              ]));
+              $$renderer4.push("<!--]-->");
+            } else {
+              $$renderer4.push("<!--[!-->");
+              $$renderer4.push("<!--]-->");
+            }
+          },
+          $$slots: { default: true }
+        }
+      ]));
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Sheet_header($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<div${attributes({
+      "data-slot": "sheet-header",
+      class: clsx(cn("flex flex-col gap-1.5 p-4", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    bind_props($$props, { ref });
+  });
+}
+function Sheet_title($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Dialog_title) {
+        $$renderer3.push("<!--[-->");
+        Dialog_title($$renderer3, spread_props([
+          {
+            "data-slot": "sheet-title",
+            class: cn("text-foreground font-semibold", className)
+          },
+          restProps,
+          {
+            get ref() {
+              return ref;
+            },
+            set ref($$value) {
+              ref = $$value;
+              $$settled = false;
+            }
+          }
+        ]));
+        $$renderer3.push("<!--]-->");
+      } else {
+        $$renderer3.push("<!--[!-->");
+        $$renderer3.push("<!--]-->");
+      }
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Sheet_description($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Dialog_description) {
+        $$renderer3.push("<!--[-->");
+        Dialog_description($$renderer3, spread_props([
+          {
+            "data-slot": "sheet-description",
+            class: cn("text-muted-foreground text-sm", className)
+          },
+          restProps,
+          {
+            get ref() {
+              return ref;
+            },
+            set ref($$value) {
+              ref = $$value;
+              $$settled = false;
+            }
+          }
+        ]));
+        $$renderer3.push("<!--]-->");
+      } else {
+        $$renderer3.push("<!--[!-->");
+        $$renderer3.push("<!--]-->");
+      }
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Sidebar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      side = "left",
+      variant = "sidebar",
+      collapsible = "offcanvas",
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const sidebar = useSidebar();
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (collapsible === "none") {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<div${attributes({
+          class: clsx(cn("bg-sidebar text-sidebar-foreground flex h-full w-(--sidebar-width) flex-col", className)),
+          ...restProps
+        })}>`);
+        children?.($$renderer3);
+        $$renderer3.push(`<!----></div>`);
+      } else if (sidebar.isMobile) {
+        $$renderer3.push("<!--[1-->");
+        var bind_get = () => sidebar.openMobile;
+        var bind_set = (v) => sidebar.setOpenMobile(v);
+        if (Sheet) {
+          $$renderer3.push("<!--[-->");
+          Sheet($$renderer3, spread_props([
+            {
+              get open() {
+                return bind_get();
+              },
+              set open($$value) {
+                bind_set($$value);
+              }
+            },
+            restProps,
+            {
+              children: ($$renderer4) => {
+                if (Sheet_content) {
+                  $$renderer4.push("<!--[-->");
+                  Sheet_content($$renderer4, {
+                    "data-sidebar": "sidebar",
+                    "data-slot": "sidebar",
+                    "data-mobile": "true",
+                    class: "bg-sidebar text-sidebar-foreground w-(--sidebar-width) p-0 [&>button]:hidden",
+                    style: `--sidebar-width: ${stringify(SIDEBAR_WIDTH_MOBILE)};`,
+                    side,
+                    children: ($$renderer5) => {
+                      if (Sheet_header) {
+                        $$renderer5.push("<!--[-->");
+                        Sheet_header($$renderer5, {
+                          class: "sr-only",
+                          children: ($$renderer6) => {
+                            if (Sheet_title) {
+                              $$renderer6.push("<!--[-->");
+                              Sheet_title($$renderer6, {
+                                children: ($$renderer7) => {
+                                  $$renderer7.push(`<!---->Sidebar`);
+                                },
+                                $$slots: { default: true }
+                              });
+                              $$renderer6.push("<!--]-->");
+                            } else {
+                              $$renderer6.push("<!--[!-->");
+                              $$renderer6.push("<!--]-->");
+                            }
+                            $$renderer6.push(` `);
+                            if (Sheet_description) {
+                              $$renderer6.push("<!--[-->");
+                              Sheet_description($$renderer6, {
+                                children: ($$renderer7) => {
+                                  $$renderer7.push(`<!---->Displays the mobile sidebar.`);
+                                },
+                                $$slots: { default: true }
+                              });
+                              $$renderer6.push("<!--]-->");
+                            } else {
+                              $$renderer6.push("<!--[!-->");
+                              $$renderer6.push("<!--]-->");
+                            }
+                          },
+                          $$slots: { default: true }
+                        });
+                        $$renderer5.push("<!--]-->");
+                      } else {
+                        $$renderer5.push("<!--[!-->");
+                        $$renderer5.push("<!--]-->");
+                      }
+                      $$renderer5.push(` <div class="flex h-full w-full flex-col">`);
+                      children?.($$renderer5);
+                      $$renderer5.push(`<!----></div>`);
+                    },
+                    $$slots: { default: true }
+                  });
+                  $$renderer4.push("<!--]-->");
+                } else {
+                  $$renderer4.push("<!--[!-->");
+                  $$renderer4.push("<!--]-->");
+                }
+              },
+              $$slots: { default: true }
+            }
+          ]));
+          $$renderer3.push("<!--]-->");
+        } else {
+          $$renderer3.push("<!--[!-->");
+          $$renderer3.push("<!--]-->");
+        }
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`<div class="text-sidebar-foreground group peer hidden md:block"${attr("data-state", sidebar.state)}${attr("data-collapsible", sidebar.state === "collapsed" ? collapsible : "")}${attr("data-variant", variant)}${attr("data-side", side)} data-slot="sidebar"><div data-slot="sidebar-gap"${attr_class(clsx(cn("relative w-(--sidebar-width) bg-transparent transition-[width] duration-200 ease-linear", "group-data-[collapsible=offcanvas]:w-0", "group-data-[side=right]:rotate-180", variant === "floating" || variant === "inset" ? "group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)+(--spacing(4))+2px)]" : "group-data-[collapsible=icon]:w-(--sidebar-width-icon)")))}></div> <div${attributes({
+          "data-slot": "sidebar-container",
+          class: clsx(cn(
+            "fixed inset-y-0 z-10 hidden h-svh w-(--sidebar-width) transition-[left,right,width] duration-200 ease-linear md:flex",
+            side === "left" ? "start-0 group-data-[collapsible=offcanvas]:start-[calc(var(--sidebar-width)*-1)]" : "end-0 group-data-[collapsible=offcanvas]:end-[calc(var(--sidebar-width)*-1)]",
+            variant === "floating" || variant === "inset" ? "p-2 group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)+(--spacing(4))+2px)]" : "group-data-[collapsible=icon]:w-(--sidebar-width-icon) group-data-[side=left]:border-e group-data-[side=right]:border-s",
+            className
+          )),
+          ...restProps
+        })}><div data-sidebar="sidebar" data-slot="sidebar-inner" class="bg-sidebar group-data-[variant=floating]:border-sidebar-border flex h-full w-full flex-col group-data-[variant=floating]:rounded-lg group-data-[variant=floating]:border group-data-[variant=floating]:shadow-sm">`);
+        children?.($$renderer3);
+        $$renderer3.push(`<!----></div></div></div>`);
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Dialog_trigger($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { ref = null, $$slots, $$events, ...restProps } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Dialog_trigger$1) {
+        $$renderer3.push("<!--[-->");
+        Dialog_trigger$1($$renderer3, spread_props([
+          { "data-slot": "dialog-trigger" },
+          restProps,
+          {
+            get ref() {
+              return ref;
+            },
+            set ref($$value) {
+              ref = $$value;
+              $$settled = false;
+            }
+          }
+        ]));
+        $$renderer3.push("<!--]-->");
+      } else {
+        $$renderer3.push("<!--[!-->");
+        $$renderer3.push("<!--]-->");
+      }
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Message_square($$renderer, $$props) {
+  const $$sanitized_props = sanitize_props($$props);
+  const iconNode = [
+    [
+      "path",
+      {
+        "d": "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"
+      }
+    ]
+  ];
+  Icon$1($$renderer, spread_props([
+    { name: "message-square" },
+    $$sanitized_props,
+    {
+      /**
+       * @component @name MessageSquare
+       * @description Lucide SVG icon component, renders SVG Element with children.
+       *
+       * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMjIgMTdhMiAyIDAgMCAxLTIgMkg2LjgyOGEyIDIgMCAwIDAtMS40MTQuNTg2bC0yLjIwMiAyLjIwMkEuNzEuNzEgMCAwIDEgMiAyMS4yODZWNWEyIDIgMCAwIDEgMi0yaDE2YTIgMiAwIDAgMSAyIDJ6IiAvPgo8L3N2Zz4K) - https://lucide.dev/icons/message-square
+       * @see https://lucide.dev/guide/packages/lucide-svelte - Documentation
+       *
+       * @param {Object} props - Lucide icons props and any valid SVG attribute
+       * @returns {FunctionalComponent} Svelte component
+       *
+       */
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        slot($$renderer2, $$props, "default", {});
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+function Settings($$renderer, $$props) {
+  const $$sanitized_props = sanitize_props($$props);
+  const iconNode = [
+    [
+      "path",
+      {
+        "d": "M9.671 4.136a2.34 2.34 0 0 1 4.659 0 2.34 2.34 0 0 0 3.319 1.915 2.34 2.34 0 0 1 2.33 4.033 2.34 2.34 0 0 0 0 3.831 2.34 2.34 0 0 1-2.33 4.033 2.34 2.34 0 0 0-3.319 1.915 2.34 2.34 0 0 1-4.659 0 2.34 2.34 0 0 0-3.32-1.915 2.34 2.34 0 0 1-2.33-4.033 2.34 2.34 0 0 0 0-3.831A2.34 2.34 0 0 1 6.35 6.051a2.34 2.34 0 0 0 3.319-1.915"
+      }
+    ],
+    ["circle", { "cx": "12", "cy": "12", "r": "3" }]
+  ];
+  Icon$1($$renderer, spread_props([
+    { name: "settings" },
+    $$sanitized_props,
+    {
+      /**
+       * @component @name Settings
+       * @description Lucide SVG icon component, renders SVG Element with children.
+       *
+       * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNOS42NzEgNC4xMzZhMi4zNCAyLjM0IDAgMCAxIDQuNjU5IDAgMi4zNCAyLjM0IDAgMCAwIDMuMzE5IDEuOTE1IDIuMzQgMi4zNCAwIDAgMSAyLjMzIDQuMDMzIDIuMzQgMi4zNCAwIDAgMCAwIDMuODMxIDIuMzQgMi4zNCAwIDAgMS0yLjMzIDQuMDMzIDIuMzQgMi4zNCAwIDAgMC0zLjMxOSAxLjkxNSAyLjM0IDIuMzQgMCAwIDEtNC42NTkgMCAyLjM0IDIuMzQgMCAwIDAtMy4zMi0xLjkxNSAyLjM0IDIuMzQgMCAwIDEtMi4zMy00LjAzMyAyLjM0IDIuMzQgMCAwIDAgMC0zLjgzMUEyLjM0IDIuMzQgMCAwIDEgNi4zNSA2LjA1MWEyLjM0IDIuMzQgMCAwIDAgMy4zMTktMS45MTUiIC8+CiAgPGNpcmNsZSBjeD0iMTIiIGN5PSIxMiIgcj0iMyIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/settings
+       * @see https://lucide.dev/guide/packages/lucide-svelte - Documentation
+       *
+       * @param {Object} props - Lucide icons props and any valid SVG attribute
+       * @returns {FunctionalComponent} Svelte component
+       *
+       */
+      iconNode,
+      children: ($$renderer2) => {
+        $$renderer2.push(`<!--[-->`);
+        slot($$renderer2, $$props, "default", {});
+        $$renderer2.push(`<!--]-->`);
+      },
+      $$slots: { default: true }
+    }
+  ]));
+}
+function App_sidebar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      chats,
+      agents = [],
+      currentPath = "/",
+      collapsible = "offcanvas"
+    } = $$props;
+    let newChatOpen = false;
+    let newChatName = "";
+    let selectedAgent = "";
+    let isCreating = false;
+    let errorMessage = "";
+    let showValidationError = derived(() => newChatName.length > 0 && /\s/.test(newChatName));
+    let isValidName = derived(() => newChatName.trim().length > 0 && !/\s/.test(newChatName));
+    async function createNewChat() {
+      if (!isValidName()) return;
+      const validName = newChatName.trim();
+      isCreating = true;
+      errorMessage = "";
+      try {
+        const payload = { id: validName };
+        if (selectedAgent) {
+          payload.agent = selectedAgent;
+        }
+        const res = await fetch("/api/chats", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload)
+        });
+        if (res.ok) {
+          newChatOpen = false;
+          newChatName = "";
+          selectedAgent = "";
+          errorMessage = "";
+          await invalidate("app:chats");
+          await goto(`/chats/${validName}`);
+        } else {
+          const data = await res.json();
+          errorMessage = data.error || "Failed to create chat.";
+        }
+      } catch (err) {
+        console.error(err);
+        errorMessage = "An error occurred while creating the chat.";
+      } finally {
+        isCreating = false;
+      }
+    }
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Sidebar) {
+        $$renderer3.push("<!--[-->");
+        Sidebar($$renderer3, {
+          collapsible,
+          children: ($$renderer4) => {
+            if (Sidebar_header) {
+              $$renderer4.push("<!--[-->");
+              Sidebar_header($$renderer4, {
+                children: ($$renderer5) => {
+                  $$renderer5.push(`<div class="flex items-center gap-2 p-2 px-4 text-lg font-semibold tracking-tight">`);
+                  Message_square($$renderer5, { class: "w-5 h-5" });
+                  $$renderer5.push(`<!----> Clawmini</div>`);
+                },
+                $$slots: { default: true }
+              });
+              $$renderer4.push("<!--]-->");
+            } else {
+              $$renderer4.push("<!--[!-->");
+              $$renderer4.push("<!--]-->");
+            }
+            $$renderer4.push(` `);
+            if (Sidebar_content) {
+              $$renderer4.push("<!--[-->");
+              Sidebar_content($$renderer4, {
+                children: ($$renderer5) => {
+                  if (Sidebar_group) {
+                    $$renderer5.push("<!--[-->");
+                    Sidebar_group($$renderer5, {
+                      children: ($$renderer6) => {
+                        if (Sidebar_group_label) {
+                          $$renderer6.push("<!--[-->");
+                          Sidebar_group_label($$renderer6, {
+                            children: ($$renderer7) => {
+                              $$renderer7.push(`<!---->General`);
+                            },
+                            $$slots: { default: true }
+                          });
+                          $$renderer6.push("<!--]-->");
+                        } else {
+                          $$renderer6.push("<!--[!-->");
+                          $$renderer6.push("<!--]-->");
+                        }
+                        $$renderer6.push(` `);
+                        if (Sidebar_group_content) {
+                          $$renderer6.push("<!--[-->");
+                          Sidebar_group_content($$renderer6, {
+                            children: ($$renderer7) => {
+                              if (Sidebar_menu) {
+                                $$renderer7.push("<!--[-->");
+                                Sidebar_menu($$renderer7, {
+                                  children: ($$renderer8) => {
+                                    if (Sidebar_menu_item) {
+                                      $$renderer8.push("<!--[-->");
+                                      Sidebar_menu_item($$renderer8, {
+                                        children: ($$renderer9) => {
+                                          {
+                                            let child = function($$renderer10, { props }) {
+                                              $$renderer10.push(`<a${attributes({ href: "/agents", ...props })}>`);
+                                              Bot($$renderer10, {});
+                                              $$renderer10.push(`<!----> <span>Agents</span></a>`);
+                                            };
+                                            if (Sidebar_menu_button) {
+                                              $$renderer9.push("<!--[-->");
+                                              Sidebar_menu_button($$renderer9, {
+                                                isActive: currentPath === "/agents",
+                                                child,
+                                                $$slots: { child: true }
+                                              });
+                                              $$renderer9.push("<!--]-->");
+                                            } else {
+                                              $$renderer9.push("<!--[!-->");
+                                              $$renderer9.push("<!--]-->");
+                                            }
+                                          }
+                                        },
+                                        $$slots: { default: true }
+                                      });
+                                      $$renderer8.push("<!--]-->");
+                                    } else {
+                                      $$renderer8.push("<!--[!-->");
+                                      $$renderer8.push("<!--]-->");
+                                    }
+                                  },
+                                  $$slots: { default: true }
+                                });
+                                $$renderer7.push("<!--]-->");
+                              } else {
+                                $$renderer7.push("<!--[!-->");
+                                $$renderer7.push("<!--]-->");
+                              }
+                            },
+                            $$slots: { default: true }
+                          });
+                          $$renderer6.push("<!--]-->");
+                        } else {
+                          $$renderer6.push("<!--[!-->");
+                          $$renderer6.push("<!--]-->");
+                        }
+                      },
+                      $$slots: { default: true }
+                    });
+                    $$renderer5.push("<!--]-->");
+                  } else {
+                    $$renderer5.push("<!--[!-->");
+                    $$renderer5.push("<!--]-->");
+                  }
+                  $$renderer5.push(` `);
+                  if (Sidebar_group) {
+                    $$renderer5.push("<!--[-->");
+                    Sidebar_group($$renderer5, {
+                      children: ($$renderer6) => {
+                        if (Sidebar_group_label) {
+                          $$renderer6.push("<!--[-->");
+                          Sidebar_group_label($$renderer6, {
+                            children: ($$renderer7) => {
+                              $$renderer7.push(`<!---->Chats`);
+                            },
+                            $$slots: { default: true }
+                          });
+                          $$renderer6.push("<!--]-->");
+                        } else {
+                          $$renderer6.push("<!--[!-->");
+                          $$renderer6.push("<!--]-->");
+                        }
+                        $$renderer6.push(` `);
+                        if (Sidebar_group_content) {
+                          $$renderer6.push("<!--[-->");
+                          Sidebar_group_content($$renderer6, {
+                            children: ($$renderer7) => {
+                              if (Sidebar_menu) {
+                                $$renderer7.push("<!--[-->");
+                                Sidebar_menu($$renderer7, {
+                                  children: ($$renderer8) => {
+                                    if (Sidebar_menu_item) {
+                                      $$renderer8.push("<!--[-->");
+                                      Sidebar_menu_item($$renderer8, {
+                                        children: ($$renderer9) => {
+                                          if (Dialog$1) {
+                                            $$renderer9.push("<!--[-->");
+                                            Dialog$1($$renderer9, {
+                                              get open() {
+                                                return newChatOpen;
+                                              },
+                                              set open($$value) {
+                                                newChatOpen = $$value;
+                                                $$settled = false;
+                                              },
+                                              children: ($$renderer10) => {
+                                                {
+                                                  let child = function($$renderer11, { props }) {
+                                                    if (Sidebar_menu_button) {
+                                                      $$renderer11.push("<!--[-->");
+                                                      Sidebar_menu_button($$renderer11, spread_props([
+                                                        props,
+                                                        {
+                                                          children: ($$renderer12) => {
+                                                            Plus($$renderer12, {});
+                                                            $$renderer12.push(`<!----> <span>New Chat</span>`);
+                                                          },
+                                                          $$slots: { default: true }
+                                                        }
+                                                      ]));
+                                                      $$renderer11.push("<!--]-->");
+                                                    } else {
+                                                      $$renderer11.push("<!--[!-->");
+                                                      $$renderer11.push("<!--]-->");
+                                                    }
+                                                  };
+                                                  if (Dialog_trigger) {
+                                                    $$renderer10.push("<!--[-->");
+                                                    Dialog_trigger($$renderer10, { child, $$slots: { child: true } });
+                                                    $$renderer10.push("<!--]-->");
+                                                  } else {
+                                                    $$renderer10.push("<!--[!-->");
+                                                    $$renderer10.push("<!--]-->");
+                                                  }
+                                                }
+                                                $$renderer10.push(` `);
+                                                if (Dialog_content$1) {
+                                                  $$renderer10.push("<!--[-->");
+                                                  Dialog_content$1($$renderer10, {
+                                                    class: "sm:max-w-[425px]",
+                                                    children: ($$renderer11) => {
+                                                      if (Dialog_header) {
+                                                        $$renderer11.push("<!--[-->");
+                                                        Dialog_header($$renderer11, {
+                                                          children: ($$renderer12) => {
+                                                            if (Dialog_title$1) {
+                                                              $$renderer12.push("<!--[-->");
+                                                              Dialog_title$1($$renderer12, {
+                                                                children: ($$renderer13) => {
+                                                                  $$renderer13.push(`<!---->Create New Chat`);
+                                                                },
+                                                                $$slots: { default: true }
+                                                              });
+                                                              $$renderer12.push("<!--]-->");
+                                                            } else {
+                                                              $$renderer12.push("<!--[!-->");
+                                                              $$renderer12.push("<!--]-->");
+                                                            }
+                                                            $$renderer12.push(` `);
+                                                            if (Dialog_description$1) {
+                                                              $$renderer12.push("<!--[-->");
+                                                              Dialog_description$1($$renderer12, {
+                                                                children: ($$renderer13) => {
+                                                                  $$renderer13.push(`<!---->Enter a name for the new chat and optionally select an agent.`);
+                                                                },
+                                                                $$slots: { default: true }
+                                                              });
+                                                              $$renderer12.push("<!--]-->");
+                                                            } else {
+                                                              $$renderer12.push("<!--[!-->");
+                                                              $$renderer12.push("<!--]-->");
+                                                            }
+                                                          },
+                                                          $$slots: { default: true }
+                                                        });
+                                                        $$renderer11.push("<!--]-->");
+                                                      } else {
+                                                        $$renderer11.push("<!--[!-->");
+                                                        $$renderer11.push("<!--]-->");
+                                                      }
+                                                      $$renderer11.push(` <div class="grid gap-4 py-4">`);
+                                                      if (errorMessage) {
+                                                        $$renderer11.push("<!--[0-->");
+                                                        $$renderer11.push(`<div class="bg-destructive/15 text-destructive text-sm p-3 rounded-md flex items-center">${escape_html(errorMessage)}</div>`);
+                                                      } else {
+                                                        $$renderer11.push("<!--[-1-->");
+                                                      }
+                                                      $$renderer11.push(`<!--]--> <div class="flex flex-col gap-2"><label class="text-sm font-medium leading-none" for="name">Name</label> `);
+                                                      Input($$renderer11, {
+                                                        id: "name",
+                                                        placeholder: "e.g. debugging-session",
+                                                        class: "col-span-3",
+                                                        autocomplete: "off",
+                                                        autocorrect: "off",
+                                                        autocapitalize: "off",
+                                                        spellcheck: "false",
+                                                        onkeydown: (e) => {
+                                                          if (e.key === "Enter" && !e.shiftKey) {
+                                                            e.preventDefault();
+                                                            createNewChat();
+                                                          }
+                                                        },
+                                                        get value() {
+                                                          return newChatName;
+                                                        },
+                                                        set value($$value) {
+                                                          newChatName = $$value;
+                                                          $$settled = false;
+                                                        }
+                                                      });
+                                                      $$renderer11.push(`<!----> `);
+                                                      if (showValidationError()) {
+                                                        $$renderer11.push("<!--[0-->");
+                                                        $$renderer11.push(`<p class="text-sm text-destructive">Name cannot contain spaces.</p>`);
+                                                      } else {
+                                                        $$renderer11.push("<!--[-1-->");
+                                                      }
+                                                      $$renderer11.push(`<!--]--></div> <div class="flex flex-col gap-2"><label class="text-sm font-medium leading-none" for="agent">Initial Agent (optional)</label> `);
+                                                      $$renderer11.select(
+                                                        {
+                                                          id: "agent",
+                                                          value: selectedAgent,
+                                                          class: "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50"
+                                                        },
+                                                        ($$renderer12) => {
+                                                          $$renderer12.option({ value: "" }, ($$renderer13) => {
+                                                            $$renderer13.push(`Default`);
+                                                          });
+                                                          $$renderer12.push(`<!--[-->`);
+                                                          const each_array = ensure_array_like(agents);
+                                                          for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+                                                            let agent = each_array[$$index];
+                                                            $$renderer12.option({ value: agent.id }, ($$renderer13) => {
+                                                              $$renderer13.push(`${escape_html(agent.id)}`);
+                                                            });
+                                                          }
+                                                          $$renderer12.push(`<!--]-->`);
+                                                        }
+                                                      );
+                                                      $$renderer11.push(`</div></div> `);
+                                                      if (Dialog_footer) {
+                                                        $$renderer11.push("<!--[-->");
+                                                        Dialog_footer($$renderer11, {
+                                                          children: ($$renderer12) => {
+                                                            Button($$renderer12, {
+                                                              type: "submit",
+                                                              disabled: !isValidName() || isCreating,
+                                                              onclick: createNewChat,
+                                                              children: ($$renderer13) => {
+                                                                $$renderer13.push(`<!---->${escape_html(isCreating ? "Creating..." : "Create Chat")}`);
+                                                              },
+                                                              $$slots: { default: true }
+                                                            });
+                                                          },
+                                                          $$slots: { default: true }
+                                                        });
+                                                        $$renderer11.push("<!--]-->");
+                                                      } else {
+                                                        $$renderer11.push("<!--[!-->");
+                                                        $$renderer11.push("<!--]-->");
+                                                      }
+                                                    },
+                                                    $$slots: { default: true }
+                                                  });
+                                                  $$renderer10.push("<!--]-->");
+                                                } else {
+                                                  $$renderer10.push("<!--[!-->");
+                                                  $$renderer10.push("<!--]-->");
+                                                }
+                                              },
+                                              $$slots: { default: true }
+                                            });
+                                            $$renderer9.push("<!--]-->");
+                                          } else {
+                                            $$renderer9.push("<!--[!-->");
+                                            $$renderer9.push("<!--]-->");
+                                          }
+                                        },
+                                        $$slots: { default: true }
+                                      });
+                                      $$renderer8.push("<!--]-->");
+                                    } else {
+                                      $$renderer8.push("<!--[!-->");
+                                      $$renderer8.push("<!--]-->");
+                                    }
+                                    $$renderer8.push(` <!--[-->`);
+                                    const each_array_1 = ensure_array_like(chats);
+                                    for (let $$index_1 = 0, $$length = each_array_1.length; $$index_1 < $$length; $$index_1++) {
+                                      let chat = each_array_1[$$index_1];
+                                      if (Sidebar_menu_item) {
+                                        $$renderer8.push("<!--[-->");
+                                        Sidebar_menu_item($$renderer8, {
+                                          children: ($$renderer9) => {
+                                            {
+                                              let child = function($$renderer10, { props }) {
+                                                $$renderer10.push(`<a${attributes({ href: `/chats/${stringify(chat)}`, ...props })}>`);
+                                                Message_square($$renderer10, {});
+                                                $$renderer10.push(`<!----> <span data-testid="chat-link">${escape_html(chat)}</span></a>`);
+                                              };
+                                              if (Sidebar_menu_button) {
+                                                $$renderer9.push("<!--[-->");
+                                                Sidebar_menu_button($$renderer9, {
+                                                  isActive: currentPath === `/chats/${chat}`,
+                                                  child,
+                                                  $$slots: { child: true }
+                                                });
+                                                $$renderer9.push("<!--]-->");
+                                              } else {
+                                                $$renderer9.push("<!--[!-->");
+                                                $$renderer9.push("<!--]-->");
+                                              }
+                                            }
+                                          },
+                                          $$slots: { default: true }
+                                        });
+                                        $$renderer8.push("<!--]-->");
+                                      } else {
+                                        $$renderer8.push("<!--[!-->");
+                                        $$renderer8.push("<!--]-->");
+                                      }
+                                    }
+                                    $$renderer8.push(`<!--]-->`);
+                                  },
+                                  $$slots: { default: true }
+                                });
+                                $$renderer7.push("<!--]-->");
+                              } else {
+                                $$renderer7.push("<!--[!-->");
+                                $$renderer7.push("<!--]-->");
+                              }
+                            },
+                            $$slots: { default: true }
+                          });
+                          $$renderer6.push("<!--]-->");
+                        } else {
+                          $$renderer6.push("<!--[!-->");
+                          $$renderer6.push("<!--]-->");
+                        }
+                      },
+                      $$slots: { default: true }
+                    });
+                    $$renderer5.push("<!--]-->");
+                  } else {
+                    $$renderer5.push("<!--[!-->");
+                    $$renderer5.push("<!--]-->");
+                  }
+                },
+                $$slots: { default: true }
+              });
+              $$renderer4.push("<!--]-->");
+            } else {
+              $$renderer4.push("<!--[!-->");
+              $$renderer4.push("<!--]-->");
+            }
+          },
+          $$slots: { default: true }
+        });
+        $$renderer3.push("<!--]-->");
+      } else {
+        $$renderer3.push("<!--[!-->");
+        $$renderer3.push("<!--]-->");
+      }
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+  });
+}
+const appState = { verbosityLevel: "default" };
+function _layout($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { data, children } = $$props;
+    if (Sidebar_provider) {
+      $$renderer2.push("<!--[-->");
+      Sidebar_provider($$renderer2, {
+        class: "h-[100dvh] overflow-hidden",
+        children: ($$renderer3) => {
+          App_sidebar($$renderer3, {
+            chats: data.chats,
+            agents: data.agents,
+            currentPath: page.url.pathname
+          });
+          $$renderer3.push(`<!----> `);
+          if (Sidebar_inset) {
+            $$renderer3.push("<!--[-->");
+            Sidebar_inset($$renderer3, {
+              children: ($$renderer4) => {
+                $$renderer4.push(`<header class="flex h-14 shrink-0 items-center gap-2 border-b bg-background px-4">`);
+                if (Sidebar_trigger) {
+                  $$renderer4.push("<!--[-->");
+                  Sidebar_trigger($$renderer4, {});
+                  $$renderer4.push("<!--]-->");
+                } else {
+                  $$renderer4.push("<!--[!-->");
+                  $$renderer4.push("<!--]-->");
+                }
+                $$renderer4.push(` <div class="w-full flex items-center justify-between"><div class="font-semibold text-sm">`);
+                if (page.url.pathname.startsWith("/chats/")) {
+                  $$renderer4.push("<!--[0-->");
+                  $$renderer4.push(`${escape_html(page.url.pathname.replace("/chats/", "").replace("/settings", ""))}`);
+                } else {
+                  $$renderer4.push("<!--[-1-->");
+                  $$renderer4.push(`Home`);
+                }
+                $$renderer4.push(`<!--]--></div> <div class="flex items-center gap-4">`);
+                if (page.url.pathname.startsWith("/chats/") && !page.url.pathname.endsWith("/settings")) {
+                  $$renderer4.push("<!--[0-->");
+                  $$renderer4.push(`<a${attr("href", `${stringify(page.url.pathname)}/settings`)} class="text-muted-foreground hover:text-foreground transition-colors" title="Chat Settings">`);
+                  Settings($$renderer4, { class: "w-5 h-5" });
+                  $$renderer4.push(`<!----></a>`);
+                } else {
+                  $$renderer4.push("<!--[-1-->");
+                }
+                $$renderer4.push(`<!--]--> <div class="flex items-center gap-2"><button id="verbosity-toggle" type="button" class="flex items-center justify-center p-2 rounded-md hover:bg-muted transition-colors"${attr("aria-label", `Verbosity level: ${appState.verbosityLevel}`)}${attr("title", `Verbosity: ${appState.verbosityLevel}`)}>`);
+                {
+                  $$renderer4.push("<!--[0-->");
+                  Message_square($$renderer4, { class: "w-5 h-5 text-muted-foreground" });
+                }
+                $$renderer4.push(`<!--]--></button></div></div></div></header> <main class="flex flex-1 flex-col overflow-hidden bg-muted/20">`);
+                children($$renderer4);
+                $$renderer4.push(`<!----></main>`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer3.push("<!--]-->");
+          } else {
+            $$renderer3.push("<!--[!-->");
+            $$renderer3.push("<!--]-->");
+          }
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push("<!--]-->");
+    } else {
+      $$renderer2.push("<!--[!-->");
+      $$renderer2.push("<!--]-->");
+    }
+  });
+}
+export {
+  _layout as default
+};