claude-mux 0.7.0

package/web/.svelte-kit/adapter-bun/chunks/alert-dialog-description.js

@@ -0,0 +1,2670 @@
+import { ac as ATTACHMENT_KEY, a5 as derived, a7 as bind_props, a9 as props_id, a6 as attributes, a8 as spread_props, aa as clsx$1 } from "./index2.js";
+import { c as cn, b as buttonVariants } from "./button.js";
+import { clsx } from "clsx";
+import { h as hasContext, g as getContext, s as setContext, r as run, c as getAllContexts } from "./context.js";
+import { t as tick, m as mount, u as unmount } from "./sessions.svelte.js";
+import { o as on } from "./events.js";
+import { tabbable, focusable, isFocusable } from "tabbable";
+import parse from "style-to-object";
+function createAttachmentKey() {
+  return Symbol(ATTACHMENT_KEY);
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+const CLASS_VALUE_PRIMITIVE_TYPES = ["string", "number", "bigint", "boolean"];
+function isClassValue(value) {
+  if (value === null || value === void 0)
+    return true;
+  if (CLASS_VALUE_PRIMITIVE_TYPES.includes(typeof value))
+    return true;
+  if (Array.isArray(value))
+    return value.every((item) => isClassValue(item));
+  if (typeof value === "object") {
+    if (Object.getPrototypeOf(value) !== Object.prototype)
+      return false;
+    return true;
+  }
+  return false;
+}
+const BoxSymbol = /* @__PURE__ */ Symbol("box");
+const isWritableSymbol = /* @__PURE__ */ Symbol("is-writable");
+function boxWith(getter, setter) {
+  const derived2 = getter();
+  if (setter) {
+    return {
+      [BoxSymbol]: true,
+      [isWritableSymbol]: true,
+      get current() {
+        return derived2;
+      },
+      set current(v) {
+        setter(v);
+      }
+    };
+  }
+  return {
+    [BoxSymbol]: true,
+    get current() {
+      return getter();
+    }
+  };
+}
+function isBox(value) {
+  return isObject(value) && BoxSymbol in value;
+}
+function simpleBox(initialValue) {
+  let current = initialValue;
+  return {
+    [BoxSymbol]: true,
+    [isWritableSymbol]: true,
+    get current() {
+      return current;
+    },
+    set current(v) {
+      current = v;
+    }
+  };
+}
+function composeHandlers(...handlers) {
+  return function(e) {
+    for (const handler of handlers) {
+      if (!handler)
+        continue;
+      if (e.defaultPrevented)
+        return;
+      if (typeof handler === "function") {
+        handler.call(this, e);
+      } else {
+        handler.current?.call(this, e);
+      }
+    }
+  };
+}
+const NUMBER_CHAR_RE = /\d/;
+const STR_SPLITTERS = ["-", "_", "/", "."];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char))
+    return void 0;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str) {
+  const parts = [];
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = STR_SPLITTERS.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function pascalCase(str) {
+  if (!str)
+    return "";
+  return splitByCase(str).map((p) => upperFirst(p)).join("");
+}
+function camelCase(str) {
+  return lowerFirst(pascalCase(str || ""));
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function cssToStyleObj(css) {
+  if (!css)
+    return {};
+  const styleObj = {};
+  function iterator(name, value) {
+    if (name.startsWith("-moz-") || name.startsWith("-webkit-") || name.startsWith("-ms-") || name.startsWith("-o-")) {
+      styleObj[pascalCase(name)] = value;
+      return;
+    }
+    if (name.startsWith("--")) {
+      styleObj[name] = value;
+      return;
+    }
+    styleObj[camelCase(name)] = value;
+  }
+  parse(css, iterator);
+  return styleObj;
+}
+function executeCallbacks(...callbacks) {
+  return (...args) => {
+    for (const callback of callbacks) {
+      if (typeof callback === "function") {
+        callback(...args);
+      }
+    }
+  };
+}
+function createParser(matcher, replacer) {
+  const regex = RegExp(matcher, "g");
+  return (str) => {
+    if (typeof str !== "string") {
+      throw new TypeError(`expected an argument of type string, but got ${typeof str}`);
+    }
+    if (!str.match(regex))
+      return str;
+    return str.replace(regex, replacer);
+  };
+}
+const camelToKebab = createParser(/[A-Z]/, (match) => `-${match.toLowerCase()}`);
+function styleToCSS(styleObj) {
+  if (!styleObj || typeof styleObj !== "object" || Array.isArray(styleObj)) {
+    throw new TypeError(`expected an argument of type object, but got ${typeof styleObj}`);
+  }
+  return Object.keys(styleObj).map((property) => `${camelToKebab(property)}: ${styleObj[property]};`).join("\n");
+}
+function styleToString(style = {}) {
+  return styleToCSS(style).replace("\n", " ");
+}
+const EVENT_LIST = [
+  "onabort",
+  "onanimationcancel",
+  "onanimationend",
+  "onanimationiteration",
+  "onanimationstart",
+  "onauxclick",
+  "onbeforeinput",
+  "onbeforetoggle",
+  "onblur",
+  "oncancel",
+  "oncanplay",
+  "oncanplaythrough",
+  "onchange",
+  "onclick",
+  "onclose",
+  "oncompositionend",
+  "oncompositionstart",
+  "oncompositionupdate",
+  "oncontextlost",
+  "oncontextmenu",
+  "oncontextrestored",
+  "oncopy",
+  "oncuechange",
+  "oncut",
+  "ondblclick",
+  "ondrag",
+  "ondragend",
+  "ondragenter",
+  "ondragleave",
+  "ondragover",
+  "ondragstart",
+  "ondrop",
+  "ondurationchange",
+  "onemptied",
+  "onended",
+  "onerror",
+  "onfocus",
+  "onfocusin",
+  "onfocusout",
+  "onformdata",
+  "ongotpointercapture",
+  "oninput",
+  "oninvalid",
+  "onkeydown",
+  "onkeypress",
+  "onkeyup",
+  "onload",
+  "onloadeddata",
+  "onloadedmetadata",
+  "onloadstart",
+  "onlostpointercapture",
+  "onmousedown",
+  "onmouseenter",
+  "onmouseleave",
+  "onmousemove",
+  "onmouseout",
+  "onmouseover",
+  "onmouseup",
+  "onpaste",
+  "onpause",
+  "onplay",
+  "onplaying",
+  "onpointercancel",
+  "onpointerdown",
+  "onpointerenter",
+  "onpointerleave",
+  "onpointermove",
+  "onpointerout",
+  "onpointerover",
+  "onpointerup",
+  "onprogress",
+  "onratechange",
+  "onreset",
+  "onresize",
+  "onscroll",
+  "onscrollend",
+  "onsecuritypolicyviolation",
+  "onseeked",
+  "onseeking",
+  "onselect",
+  "onselectionchange",
+  "onselectstart",
+  "onslotchange",
+  "onstalled",
+  "onsubmit",
+  "onsuspend",
+  "ontimeupdate",
+  "ontoggle",
+  "ontouchcancel",
+  "ontouchend",
+  "ontouchmove",
+  "ontouchstart",
+  "ontransitioncancel",
+  "ontransitionend",
+  "ontransitionrun",
+  "ontransitionstart",
+  "onvolumechange",
+  "onwaiting",
+  "onwebkitanimationend",
+  "onwebkitanimationiteration",
+  "onwebkitanimationstart",
+  "onwebkittransitionend",
+  "onwheel"
+];
+const EVENT_LIST_SET = new Set(EVENT_LIST);
+function isEventHandler(key) {
+  return EVENT_LIST_SET.has(key);
+}
+function mergeProps(...args) {
+  const result = { ...args[0] };
+  for (let i = 1; i < args.length; i++) {
+    const props = args[i];
+    if (!props)
+      continue;
+    for (const key of Object.keys(props)) {
+      const a = result[key];
+      const b = props[key];
+      const aIsFunction = typeof a === "function";
+      const bIsFunction = typeof b === "function";
+      if (aIsFunction && typeof bIsFunction && isEventHandler(key)) {
+        const aHandler = a;
+        const bHandler = b;
+        result[key] = composeHandlers(aHandler, bHandler);
+      } else if (aIsFunction && bIsFunction) {
+        result[key] = executeCallbacks(a, b);
+      } else if (key === "class") {
+        const aIsClassValue = isClassValue(a);
+        const bIsClassValue = isClassValue(b);
+        if (aIsClassValue && bIsClassValue) {
+          result[key] = clsx(a, b);
+        } else if (aIsClassValue) {
+          result[key] = clsx(a);
+        } else if (bIsClassValue) {
+          result[key] = clsx(b);
+        }
+      } else if (key === "style") {
+        const aIsObject = typeof a === "object";
+        const bIsObject = typeof b === "object";
+        const aIsString = typeof a === "string";
+        const bIsString = typeof b === "string";
+        if (aIsObject && bIsObject) {
+          result[key] = { ...a, ...b };
+        } else if (aIsObject && bIsString) {
+          const parsedStyle = cssToStyleObj(b);
+          result[key] = { ...a, ...parsedStyle };
+        } else if (aIsString && bIsObject) {
+          const parsedStyle = cssToStyleObj(a);
+          result[key] = { ...parsedStyle, ...b };
+        } else if (aIsString && bIsString) {
+          const parsedStyleA = cssToStyleObj(a);
+          const parsedStyleB = cssToStyleObj(b);
+          result[key] = { ...parsedStyleA, ...parsedStyleB };
+        } else if (aIsObject) {
+          result[key] = a;
+        } else if (bIsObject) {
+          result[key] = b;
+        } else if (aIsString) {
+          result[key] = a;
+        } else if (bIsString) {
+          result[key] = b;
+        }
+      } else {
+        result[key] = b !== void 0 ? b : a;
+      }
+    }
+    for (const key of Object.getOwnPropertySymbols(props)) {
+      const a = result[key];
+      const b = props[key];
+      result[key] = b !== void 0 ? b : a;
+    }
+  }
+  if (typeof result.style === "object") {
+    result.style = styleToString(result.style).replaceAll("\n", " ");
+  }
+  if (result.hidden === false) {
+    result.hidden = void 0;
+    delete result.hidden;
+  }
+  if (result.disabled === false) {
+    result.disabled = void 0;
+    delete result.disabled;
+  }
+  return result;
+}
+const defaultWindow = void 0;
+function getActiveElement$1(document2) {
+  let activeElement = document2.activeElement;
+  while (activeElement?.shadowRoot) {
+    const node = activeElement.shadowRoot.activeElement;
+    if (node === activeElement)
+      break;
+    else
+      activeElement = node;
+  }
+  return activeElement;
+}
+const SvelteMap = globalThis.Map;
+function createSubscriber(_) {
+  return () => {
+  };
+}
+class ActiveElement {
+  #document;
+  #subscribe;
+  constructor(options = {}) {
+    const { window: window2 = defaultWindow, document: document2 = window2?.document } = options;
+    if (window2 === void 0) return;
+    this.#document = document2;
+    this.#subscribe = createSubscriber();
+  }
+  get current() {
+    this.#subscribe?.();
+    if (!this.#document) return null;
+    return getActiveElement$1(this.#document);
+  }
+}
+new ActiveElement();
+class Context {
+  #name;
+  #key;
+  /**
+   * @param name The name of the context.
+   * This is used for generating the context key and error messages.
+   */
+  constructor(name) {
+    this.#name = name;
+    this.#key = Symbol(name);
+  }
+  /**
+   * The key used to get and set the context.
+   *
+   * It is not recommended to use this value directly.
+   * Instead, use the methods provided by this class.
+   */
+  get key() {
+    return this.#key;
+  }
+  /**
+   * Checks whether this has been set in the context of a parent component.
+   *
+   * Must be called during component initialisation.
+   */
+  exists() {
+    return hasContext(this.#key);
+  }
+  /**
+   * Retrieves the context that belongs to the closest parent component.
+   *
+   * Must be called during component initialisation.
+   *
+   * @throws An error if the context does not exist.
+   */
+  get() {
+    const context = getContext(this.#key);
+    if (context === void 0) {
+      throw new Error(`Context "${this.#name}" not found`);
+    }
+    return context;
+  }
+  /**
+   * Retrieves the context that belongs to the closest parent component,
+   * or the given fallback value if the context does not exist.
+   *
+   * Must be called during component initialisation.
+   */
+  getOr(fallback) {
+    const context = getContext(this.#key);
+    if (context === void 0) {
+      return fallback;
+    }
+    return context;
+  }
+  /**
+   * Associates the given value with the current component and returns it.
+   *
+   * Must be called during component initialisation.
+   */
+  set(context) {
+    return setContext(this.#key, context);
+  }
+}
+function runWatcher(sources, flush, effect, options = {}) {
+  const { lazy = false } = options;
+}
+function watch(sources, effect, options) {
+  runWatcher(sources, "post", effect, options);
+}
+function watchPre(sources, effect, options) {
+  runWatcher(sources, "pre", effect, options);
+}
+watch.pre = watchPre;
+function afterSleep(ms, cb) {
+  return setTimeout(cb, ms);
+}
+function afterTick(fn) {
+  tick().then(fn);
+}
+const ELEMENT_NODE = 1;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_FRAGMENT_NODE = 11;
+function isHTMLElement$1(node) {
+  return isObject(node) && node.nodeType === ELEMENT_NODE && typeof node.nodeName === "string";
+}
+function isDocument(node) {
+  return isObject(node) && node.nodeType === DOCUMENT_NODE;
+}
+function isWindow(node) {
+  return isObject(node) && node.constructor?.name === "VisualViewport";
+}
+function isNode(node) {
+  return isObject(node) && node.nodeType !== void 0;
+}
+function isShadowRoot(node) {
+  return isNode(node) && node.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in node;
+}
+function contains(parent, child) {
+  if (!parent || !child)
+    return false;
+  if (!isHTMLElement$1(parent) || !isHTMLElement$1(child))
+    return false;
+  const rootNode = child.getRootNode?.();
+  if (parent === child)
+    return true;
+  if (parent.contains(child))
+    return true;
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    while (next) {
+      if (parent === next)
+        return true;
+      next = next.parentNode || next.host;
+    }
+  }
+  return false;
+}
+function getDocument(node) {
+  if (isDocument(node))
+    return node;
+  if (isWindow(node))
+    return node.document;
+  return node?.ownerDocument ?? document;
+}
+function getActiveElement(rootNode) {
+  let activeElement = rootNode.activeElement;
+  while (activeElement?.shadowRoot) {
+    const el = activeElement.shadowRoot.activeElement;
+    if (el === activeElement)
+      break;
+    else
+      activeElement = el;
+  }
+  return activeElement;
+}
+class DOMContext {
+  element;
+  #root = derived(() => {
+    if (!this.element.current) return document;
+    const rootNode = this.element.current.getRootNode() ?? document;
+    return rootNode;
+  });
+  get root() {
+    return this.#root();
+  }
+  set root($$value) {
+    return this.#root($$value);
+  }
+  constructor(element) {
+    if (typeof element === "function") {
+      this.element = boxWith(element);
+    } else {
+      this.element = element;
+    }
+  }
+  getDocument = () => {
+    return getDocument(this.root);
+  };
+  getWindow = () => {
+    return this.getDocument().defaultView ?? window;
+  };
+  getActiveElement = () => {
+    return getActiveElement(this.root);
+  };
+  isActiveElement = (node) => {
+    return node === this.getActiveElement();
+  };
+  getElementById(id) {
+    return this.root.getElementById(id);
+  }
+  querySelector = (selector) => {
+    if (!this.root) return null;
+    return this.root.querySelector(selector);
+  };
+  querySelectorAll = (selector) => {
+    if (!this.root) return [];
+    return this.root.querySelectorAll(selector);
+  };
+  setTimeout = (callback, delay) => {
+    return this.getWindow().setTimeout(callback, delay);
+  };
+  clearTimeout = (timeoutId) => {
+    return this.getWindow().clearTimeout(timeoutId);
+  };
+}
+function attachRef(ref, onChange) {
+  return {
+    [createAttachmentKey()]: (node) => {
+      if (isBox(ref)) {
+        ref.current = node;
+        run(() => onChange?.(node));
+        return () => {
+          if ("isConnected" in node && node.isConnected)
+            return;
+          ref.current = null;
+          onChange?.(null);
+        };
+      }
+      ref(node);
+      run(() => onChange?.(node));
+      return () => {
+        if ("isConnected" in node && node.isConnected)
+          return;
+        ref(null);
+        onChange?.(null);
+      };
+    }
+  };
+}
+function boolToStr(condition) {
+  return condition ? "true" : "false";
+}
+function boolToEmptyStrOrUndef(condition) {
+  return condition ? "" : void 0;
+}
+function getDataOpenClosed(condition) {
+  return condition ? "open" : "closed";
+}
+function getAriaChecked(checked, indeterminate) {
+  if (indeterminate) {
+    return "mixed";
+  }
+  return checked ? "true" : "false";
+}
+class BitsAttrs {
+  #variant;
+  #prefix;
+  attrs;
+  constructor(config) {
+    this.#variant = config.getVariant ? config.getVariant() : null;
+    this.#prefix = this.#variant ? `data-${this.#variant}-` : `data-${config.component}-`;
+    this.getAttr = this.getAttr.bind(this);
+    this.selector = this.selector.bind(this);
+    this.attrs = Object.fromEntries(config.parts.map((part) => [part, this.getAttr(part)]));
+  }
+  getAttr(part, variantOverride) {
+    if (variantOverride)
+      return `data-${variantOverride}-${part}`;
+    return `${this.#prefix}${part}`;
+  }
+  selector(part, variantOverride) {
+    return `[${this.getAttr(part, variantOverride)}]`;
+  }
+}
+function createBitsAttrs(config) {
+  const bitsAttrs = new BitsAttrs(config);
+  return {
+    ...bitsAttrs.attrs,
+    selector: bitsAttrs.selector,
+    getAttr: bitsAttrs.getAttr
+  };
+}
+const ENTER = "Enter";
+const ESCAPE = "Escape";
+const SPACE = " ";
+const isBrowser = typeof document !== "undefined";
+const isIOS = getIsIOS();
+function getIsIOS() {
+  return isBrowser && window?.navigator?.userAgent && (/iP(ad|hone|od)/.test(window.navigator.userAgent) || // The new iPad Pro Gen3 does not identify itself as iPad, but as Macintosh.
+  window?.navigator?.maxTouchPoints > 2 && /iPad|Macintosh/.test(window?.navigator.userAgent));
+}
+function isHTMLElement(element) {
+  return element instanceof HTMLElement;
+}
+function isElementOrSVGElement(element) {
+  return element instanceof Element || element instanceof SVGElement;
+}
+class AnimationsComplete {
+  #opts;
+  #currentFrame = null;
+  constructor(opts) {
+    this.#opts = opts;
+  }
+  #cleanup() {
+    if (!this.#currentFrame)
+      return;
+    window.cancelAnimationFrame(this.#currentFrame);
+    this.#currentFrame = null;
+  }
+  run(fn) {
+    this.#cleanup();
+    const node = this.#opts.ref.current;
+    if (!node)
+      return;
+    if (typeof node.getAnimations !== "function") {
+      this.#executeCallback(fn);
+      return;
+    }
+    this.#currentFrame = window.requestAnimationFrame(() => {
+      const animations = node.getAnimations();
+      if (animations.length === 0) {
+        this.#executeCallback(fn);
+        return;
+      }
+      Promise.allSettled(animations.map((animation) => animation.finished)).then(() => {
+        this.#executeCallback(fn);
+      });
+    });
+  }
+  #executeCallback(fn) {
+    const execute = () => {
+      fn();
+    };
+    if (this.#opts.afterTick) {
+      afterTick(execute);
+    } else {
+      execute();
+    }
+  }
+}
+class PresenceManager {
+  #opts;
+  #enabled;
+  #afterAnimations;
+  #shouldRender = false;
+  constructor(opts) {
+    this.#opts = opts;
+    this.#shouldRender = opts.open.current;
+    this.#enabled = opts.enabled ?? true;
+    this.#afterAnimations = new AnimationsComplete({ ref: this.#opts.ref, afterTick: this.#opts.open });
+    watch(() => this.#opts.open.current, (isOpen) => {
+      if (isOpen) this.#shouldRender = true;
+      if (!this.#enabled) return;
+      this.#afterAnimations.run(() => {
+        if (isOpen === this.#opts.open.current) {
+          if (!this.#opts.open.current) {
+            this.#shouldRender = false;
+          }
+          this.#opts.onComplete?.();
+        }
+      });
+    });
+  }
+  get shouldRender() {
+    return this.#shouldRender;
+  }
+}
+function noop() {
+}
+function createId(prefixOrUid, uid) {
+  return `bits-${prefixOrUid}`;
+}
+const dialogAttrs = createBitsAttrs({
+  component: "dialog",
+  parts: [
+    "content",
+    "trigger",
+    "overlay",
+    "title",
+    "description",
+    "close",
+    "cancel",
+    "action"
+  ]
+});
+const DialogRootContext = new Context("Dialog.Root | AlertDialog.Root");
+class DialogRootState {
+  static create(opts) {
+    const parent = DialogRootContext.getOr(null);
+    return DialogRootContext.set(new DialogRootState(opts, parent));
+  }
+  opts;
+  triggerNode = null;
+  contentNode = null;
+  overlayNode = null;
+  descriptionNode = null;
+  contentId = void 0;
+  titleId = void 0;
+  triggerId = void 0;
+  descriptionId = void 0;
+  cancelNode = null;
+  nestedOpenCount = 0;
+  depth;
+  parent;
+  contentPresence;
+  overlayPresence;
+  constructor(opts, parent) {
+    this.opts = opts;
+    this.parent = parent;
+    this.depth = parent ? parent.depth + 1 : 0;
+    this.handleOpen = this.handleOpen.bind(this);
+    this.handleClose = this.handleClose.bind(this);
+    this.contentPresence = new PresenceManager({
+      ref: boxWith(() => this.contentNode),
+      open: this.opts.open,
+      enabled: true,
+      onComplete: () => {
+        this.opts.onOpenChangeComplete.current(this.opts.open.current);
+      }
+    });
+    this.overlayPresence = new PresenceManager({
+      ref: boxWith(() => this.overlayNode),
+      open: this.opts.open,
+      enabled: true
+    });
+    watch(
+      () => this.opts.open.current,
+      (isOpen) => {
+        if (!this.parent) return;
+        if (isOpen) {
+          this.parent.incrementNested();
+        } else {
+          this.parent.decrementNested();
+        }
+      },
+      { lazy: true }
+    );
+  }
+  handleOpen() {
+    if (this.opts.open.current) return;
+    this.opts.open.current = true;
+  }
+  handleClose() {
+    if (!this.opts.open.current) return;
+    this.opts.open.current = false;
+  }
+  getBitsAttr = (part) => {
+    return dialogAttrs.getAttr(part, this.opts.variant.current);
+  };
+  incrementNested() {
+    this.nestedOpenCount++;
+    this.parent?.incrementNested();
+  }
+  decrementNested() {
+    if (this.nestedOpenCount === 0) return;
+    this.nestedOpenCount--;
+    this.parent?.decrementNested();
+  }
+  #sharedProps = derived(() => ({ "data-state": getDataOpenClosed(this.opts.open.current) }));
+  get sharedProps() {
+    return this.#sharedProps();
+  }
+  set sharedProps($$value) {
+    return this.#sharedProps($$value);
+  }
+}
+class DialogCloseState {
+  static create(opts) {
+    return new DialogCloseState(opts, DialogRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.attachment = attachRef(this.opts.ref);
+    this.onclick = this.onclick.bind(this);
+    this.onkeydown = this.onkeydown.bind(this);
+  }
+  onclick(e) {
+    if (this.opts.disabled.current) return;
+    if (e.button > 0) return;
+    this.root.handleClose();
+  }
+  onkeydown(e) {
+    if (this.opts.disabled.current) return;
+    if (e.key === SPACE || e.key === ENTER) {
+      e.preventDefault();
+      this.root.handleClose();
+    }
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    [this.root.getBitsAttr(this.opts.variant.current)]: "",
+    onclick: this.onclick,
+    onkeydown: this.onkeydown,
+    disabled: this.opts.disabled.current ? true : void 0,
+    tabindex: 0,
+    ...this.root.sharedProps,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class DialogActionState {
+  static create(opts) {
+    return new DialogActionState(opts, DialogRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.attachment = attachRef(this.opts.ref);
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    [this.root.getBitsAttr("action")]: "",
+    ...this.root.sharedProps,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class DialogTitleState {
+  static create(opts) {
+    return new DialogTitleState(opts, DialogRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.root.titleId = this.opts.id.current;
+    this.attachment = attachRef(this.opts.ref);
+    watch.pre(() => this.opts.id.current, (id) => {
+      this.root.titleId = id;
+    });
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    role: "heading",
+    "aria-level": this.opts.level.current,
+    [this.root.getBitsAttr("title")]: "",
+    ...this.root.sharedProps,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class DialogDescriptionState {
+  static create(opts) {
+    return new DialogDescriptionState(opts, DialogRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.root.descriptionId = this.opts.id.current;
+    this.attachment = attachRef(this.opts.ref, (v) => {
+      this.root.descriptionNode = v;
+    });
+    watch.pre(() => this.opts.id.current, (id) => {
+      this.root.descriptionId = id;
+    });
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    [this.root.getBitsAttr("description")]: "",
+    ...this.root.sharedProps,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class DialogContentState {
+  static create(opts) {
+    return new DialogContentState(opts, DialogRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.attachment = attachRef(this.opts.ref, (v) => {
+      this.root.contentNode = v;
+      this.root.contentId = v?.id;
+    });
+  }
+  #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,
+    role: this.root.opts.variant.current === "alert-dialog" ? "alertdialog" : "dialog",
+    "aria-modal": "true",
+    "aria-describedby": this.root.descriptionId,
+    "aria-labelledby": this.root.titleId,
+    [this.root.getBitsAttr("content")]: "",
+    style: {
+      pointerEvents: "auto",
+      outline: this.root.opts.variant.current === "alert-dialog" ? "none" : void 0,
+      "--bits-dialog-depth": this.root.depth,
+      "--bits-dialog-nested-count": this.root.nestedOpenCount
+    },
+    tabindex: this.root.opts.variant.current === "alert-dialog" ? -1 : void 0,
+    "data-nested-open": boolToEmptyStrOrUndef(this.root.nestedOpenCount > 0),
+    "data-nested": boolToEmptyStrOrUndef(this.root.parent !== null),
+    ...this.root.sharedProps,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+  get shouldRender() {
+    return this.root.contentPresence.shouldRender;
+  }
+}
+class DialogOverlayState {
+  static create(opts) {
+    return new DialogOverlayState(opts, DialogRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.attachment = attachRef(this.opts.ref, (v) => this.root.overlayNode = v);
+  }
+  #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,
+    [this.root.getBitsAttr("overlay")]: "",
+    style: {
+      pointerEvents: "auto",
+      "--bits-dialog-depth": this.root.depth,
+      "--bits-dialog-nested-count": this.root.nestedOpenCount
+    },
+    "data-nested-open": boolToEmptyStrOrUndef(this.root.nestedOpenCount > 0),
+    "data-nested": boolToEmptyStrOrUndef(this.root.parent !== null),
+    ...this.root.sharedProps,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+  get shouldRender() {
+    return this.root.overlayPresence.shouldRender;
+  }
+}
+class AlertDialogCancelState {
+  static create(opts) {
+    return new AlertDialogCancelState(opts, DialogRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.attachment = attachRef(this.opts.ref, (v) => this.root.cancelNode = v);
+    this.onclick = this.onclick.bind(this);
+    this.onkeydown = this.onkeydown.bind(this);
+  }
+  onclick(e) {
+    if (this.opts.disabled.current) return;
+    if (e.button > 0) return;
+    this.root.handleClose();
+  }
+  onkeydown(e) {
+    if (this.opts.disabled.current) return;
+    if (e.key === SPACE || e.key === ENTER) {
+      e.preventDefault();
+      this.root.handleClose();
+    }
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    [this.root.getBitsAttr("cancel")]: "",
+    onclick: this.onclick,
+    onkeydown: this.onkeydown,
+    tabindex: 0,
+    ...this.root.sharedProps,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+function Alert_dialog$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      open = false,
+      onOpenChange = noop,
+      onOpenChangeComplete = noop,
+      children
+    } = $$props;
+    DialogRootState.create({
+      variant: boxWith(() => "alert-dialog"),
+      open: boxWith(() => open, (v) => {
+        open = v;
+        onOpenChange(v);
+      }),
+      onOpenChangeComplete: boxWith(() => onOpenChangeComplete)
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+    bind_props($$props, { open });
+  });
+}
+function Dialog_title($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const uid = props_id($$renderer2);
+    let {
+      id = createId(uid),
+      ref = null,
+      child,
+      children,
+      level = 2,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const titleState = DialogTitleState.create({
+      id: boxWith(() => id),
+      level: boxWith(() => level),
+      ref: boxWith(() => ref, (v) => ref = v)
+    });
+    const mergedProps = mergeProps(restProps, titleState.props);
+    if (child) {
+      $$renderer2.push("<!--[-->");
+      child($$renderer2, { props: mergedProps });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[!-->");
+      $$renderer2.push(`<div${attributes({ ...mergedProps })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></div>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog_action$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const uid = props_id($$renderer2);
+    let {
+      children,
+      child,
+      id = createId(uid),
+      ref = null,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const actionState = DialogActionState.create({
+      id: boxWith(() => id),
+      ref: boxWith(() => ref, (v) => ref = v)
+    });
+    const mergedProps = mergeProps(restProps, actionState.props);
+    if (child) {
+      $$renderer2.push("<!--[-->");
+      child($$renderer2, { props: mergedProps });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[!-->");
+      $$renderer2.push(`<button${attributes({ ...mergedProps })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></button>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog_cancel$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 cancelState = AlertDialogCancelState.create({
+      id: boxWith(() => id),
+      ref: boxWith(() => ref, (v) => ref = v),
+      disabled: boxWith(() => Boolean(disabled))
+    });
+    const mergedProps = mergeProps(restProps, cancelState.props);
+    if (child) {
+      $$renderer2.push("<!--[-->");
+      child($$renderer2, { props: mergedProps });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[!-->");
+      $$renderer2.push(`<button${attributes({ ...mergedProps })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></button>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+const BitsConfigContext = new Context("BitsConfig");
+function getBitsConfig() {
+  const fallback = new BitsConfigState(null, {});
+  return BitsConfigContext.getOr(fallback).opts;
+}
+class BitsConfigState {
+  opts;
+  constructor(parent, opts) {
+    const resolveConfigOption = createConfigResolver(parent, opts);
+    this.opts = {
+      defaultPortalTo: resolveConfigOption((config) => config.defaultPortalTo),
+      defaultLocale: resolveConfigOption((config) => config.defaultLocale)
+    };
+  }
+}
+function createConfigResolver(parent, currentOpts) {
+  return (getter) => {
+    const configOption = boxWith(() => {
+      const value = getter(currentOpts)?.current;
+      if (value !== void 0)
+        return value;
+      if (parent === null)
+        return void 0;
+      return getter(parent.opts)?.current;
+    });
+    return configOption;
+  };
+}
+function createPropResolver(configOption, fallback) {
+  return (getProp) => {
+    const config = getBitsConfig();
+    return boxWith(() => {
+      const propValue = getProp();
+      if (propValue !== void 0)
+        return propValue;
+      const option = configOption(config).current;
+      if (option !== void 0)
+        return option;
+      return fallback;
+    });
+  };
+}
+const resolvePortalToProp = createPropResolver((config) => config.defaultPortalTo, "body");
+function Portal($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { to: toProp, children, disabled } = $$props;
+    const to = resolvePortalToProp(() => toProp);
+    getAllContexts();
+    let target = getTarget();
+    function getTarget() {
+      if (!isBrowser || disabled) return null;
+      let localTarget = null;
+      if (typeof to.current === "string") {
+        const target2 = document.querySelector(to.current);
+        localTarget = target2;
+      } else {
+        localTarget = to.current;
+      }
+      return localTarget;
+    }
+    let instance;
+    function unmountInstance() {
+      if (instance) {
+        unmount();
+        instance = null;
+      }
+    }
+    watch([() => target, () => disabled], ([target2, disabled2]) => {
+      if (!target2 || disabled2) {
+        unmountInstance();
+        return;
+      }
+      instance = mount();
+      return () => {
+        unmountInstance();
+      };
+    });
+    if (disabled) {
+      $$renderer2.push("<!--[-->");
+      children?.($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[!-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+function debounce(fn, wait = 500) {
+  let timeout = null;
+  const debounced = (...args) => {
+    if (timeout !== null) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      fn(...args);
+    }, wait);
+  };
+  debounced.destroy = () => {
+    if (timeout !== null) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+  };
+  return debounced;
+}
+function isOrContainsTarget(node, target) {
+  return node === target || node.contains(target);
+}
+function getOwnerDocument(el) {
+  return el?.ownerDocument ?? document;
+}
+function isClickTrulyOutside(event, contentNode) {
+  const { clientX, clientY } = event;
+  const rect = contentNode.getBoundingClientRect();
+  return clientX < rect.left || clientX > rect.right || clientY < rect.top || clientY > rect.bottom;
+}
+const CONTEXT_MENU_TRIGGER_ATTR = "data-context-menu-trigger";
+const CONTEXT_MENU_CONTENT_ATTR = "data-context-menu-content";
+createBitsAttrs({
+  component: "menu",
+  parts: [
+    "trigger",
+    "content",
+    "sub-trigger",
+    "item",
+    "group",
+    "group-heading",
+    "checkbox-group",
+    "checkbox-item",
+    "radio-group",
+    "radio-item",
+    "separator",
+    "sub-content",
+    "arrow"
+  ]
+});
+globalThis.bitsDismissableLayers ??= /* @__PURE__ */ new Map();
+class DismissibleLayerState {
+  static create(opts) {
+    return new DismissibleLayerState(opts);
+  }
+  opts;
+  #interactOutsideProp;
+  #behaviorType;
+  #interceptedEvents = { pointerdown: false };
+  #isResponsibleLayer = false;
+  #isFocusInsideDOMTree = false;
+  #documentObj = void 0;
+  #onFocusOutside;
+  #unsubClickListener = noop;
+  constructor(opts) {
+    this.opts = opts;
+    this.#behaviorType = opts.interactOutsideBehavior;
+    this.#interactOutsideProp = opts.onInteractOutside;
+    this.#onFocusOutside = opts.onFocusOutside;
+    let unsubEvents = noop;
+    const cleanup = () => {
+      this.#resetState();
+      globalThis.bitsDismissableLayers.delete(this);
+      this.#handleInteractOutside.destroy();
+      unsubEvents();
+    };
+    watch([() => this.opts.enabled.current, () => this.opts.ref.current], () => {
+      if (!this.opts.enabled.current || !this.opts.ref.current) return;
+      afterSleep(1, () => {
+        if (!this.opts.ref.current) return;
+        globalThis.bitsDismissableLayers.set(this, this.#behaviorType);
+        unsubEvents();
+        unsubEvents = this.#addEventListeners();
+      });
+      return cleanup;
+    });
+  }
+  #handleFocus = (event) => {
+    if (event.defaultPrevented) return;
+    if (!this.opts.ref.current) return;
+    afterTick(() => {
+      if (!this.opts.ref.current || this.#isTargetWithinLayer(event.target)) return;
+      if (event.target && !this.#isFocusInsideDOMTree) {
+        this.#onFocusOutside.current?.(event);
+      }
+    });
+  };
+  #addEventListeners() {
+    return executeCallbacks(
+      /**
+       * CAPTURE INTERACTION START
+       * mark interaction-start event as intercepted.
+       * mark responsible layer during interaction start
+       * to avoid checking if is responsible layer during interaction end
+       * when a new floating element may have been opened.
+       */
+      on(this.#documentObj, "pointerdown", executeCallbacks(this.#markInterceptedEvent, this.#markResponsibleLayer), { capture: true }),
+      /**
+       * BUBBLE INTERACTION START
+       * Mark interaction-start event as non-intercepted. Debounce `onInteractOutsideStart`
+       * to avoid prematurely checking if other events were intercepted.
+       */
+      on(this.#documentObj, "pointerdown", executeCallbacks(this.#markNonInterceptedEvent, this.#handleInteractOutside)),
+      /**
+       * HANDLE FOCUS OUTSIDE
+       */
+      on(this.#documentObj, "focusin", this.#handleFocus)
+    );
+  }
+  #handleDismiss = (e) => {
+    let event = e;
+    if (event.defaultPrevented) {
+      event = createWrappedEvent(e);
+    }
+    this.#interactOutsideProp.current(e);
+  };
+  #handleInteractOutside = debounce(
+    (e) => {
+      if (!this.opts.ref.current) {
+        this.#unsubClickListener();
+        return;
+      }
+      const isEventValid = this.opts.isValidEvent.current(e, this.opts.ref.current) || isValidEvent(e, this.opts.ref.current);
+      if (!this.#isResponsibleLayer || this.#isAnyEventIntercepted() || !isEventValid) {
+        this.#unsubClickListener();
+        return;
+      }
+      let event = e;
+      if (event.defaultPrevented) {
+        event = createWrappedEvent(event);
+      }
+      if (this.#behaviorType.current !== "close" && this.#behaviorType.current !== "defer-otherwise-close") {
+        this.#unsubClickListener();
+        return;
+      }
+      if (e.pointerType === "touch") {
+        this.#unsubClickListener();
+        this.#unsubClickListener = on(this.#documentObj, "click", this.#handleDismiss, { once: true });
+      } else {
+        this.#interactOutsideProp.current(event);
+      }
+    },
+    10
+  );
+  #markInterceptedEvent = (e) => {
+    this.#interceptedEvents[e.type] = true;
+  };
+  #markNonInterceptedEvent = (e) => {
+    this.#interceptedEvents[e.type] = false;
+  };
+  #markResponsibleLayer = () => {
+    if (!this.opts.ref.current) return;
+    this.#isResponsibleLayer = isResponsibleLayer(this.opts.ref.current);
+  };
+  #isTargetWithinLayer = (target) => {
+    if (!this.opts.ref.current) return false;
+    return isOrContainsTarget(this.opts.ref.current, target);
+  };
+  #resetState = debounce(
+    () => {
+      for (const eventType in this.#interceptedEvents) {
+        this.#interceptedEvents[eventType] = false;
+      }
+      this.#isResponsibleLayer = false;
+    },
+    20
+  );
+  #isAnyEventIntercepted() {
+    const i = Object.values(this.#interceptedEvents).some(Boolean);
+    return i;
+  }
+  #onfocuscapture = () => {
+    this.#isFocusInsideDOMTree = true;
+  };
+  #onblurcapture = () => {
+    this.#isFocusInsideDOMTree = false;
+  };
+  props = {
+    onfocuscapture: this.#onfocuscapture,
+    onblurcapture: this.#onblurcapture
+  };
+}
+function getTopMostDismissableLayer(layersArr = [...globalThis.bitsDismissableLayers]) {
+  return layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+}
+function isResponsibleLayer(node) {
+  const layersArr = [...globalThis.bitsDismissableLayers];
+  const topMostLayer = getTopMostDismissableLayer(layersArr);
+  if (topMostLayer) return topMostLayer[0].opts.ref.current === node;
+  const [firstLayerNode] = layersArr[0];
+  return firstLayerNode.opts.ref.current === node;
+}
+function isValidEvent(e, node) {
+  const target = e.target;
+  if (!isElementOrSVGElement(target)) return false;
+  const targetIsContextMenuTrigger = Boolean(target.closest(`[${CONTEXT_MENU_TRIGGER_ATTR}]`));
+  if ("button" in e && e.button > 0 && !targetIsContextMenuTrigger) return false;
+  if ("button" in e && e.button === 0 && targetIsContextMenuTrigger) return true;
+  const nodeIsContextMenu = Boolean(node.closest(`[${CONTEXT_MENU_CONTENT_ATTR}]`));
+  if (targetIsContextMenuTrigger && nodeIsContextMenu) return false;
+  const ownerDocument = getOwnerDocument(target);
+  const isValid = ownerDocument.documentElement.contains(target) && !isOrContainsTarget(node, target) && isClickTrulyOutside(e, node);
+  return isValid;
+}
+function createWrappedEvent(e) {
+  const capturedCurrentTarget = e.currentTarget;
+  const capturedTarget = e.target;
+  let newEvent;
+  if (e instanceof PointerEvent) {
+    newEvent = new PointerEvent(e.type, e);
+  } else {
+    newEvent = new PointerEvent("pointerdown", e);
+  }
+  let isPrevented = false;
+  const wrappedEvent = new Proxy(newEvent, {
+    get: (target, prop) => {
+      if (prop === "currentTarget") {
+        return capturedCurrentTarget;
+      }
+      if (prop === "target") {
+        return capturedTarget;
+      }
+      if (prop === "preventDefault") {
+        return () => {
+          isPrevented = true;
+          if (typeof target.preventDefault === "function") {
+            target.preventDefault();
+          }
+        };
+      }
+      if (prop === "defaultPrevented") {
+        return isPrevented;
+      }
+      if (prop in target) {
+        return target[prop];
+      }
+      return e[prop];
+    }
+  });
+  return wrappedEvent;
+}
+function Dismissible_layer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      interactOutsideBehavior = "close",
+      onInteractOutside = noop,
+      onFocusOutside = noop,
+      id,
+      children,
+      enabled,
+      isValidEvent: isValidEvent2 = () => false,
+      ref
+    } = $$props;
+    const dismissibleLayerState = DismissibleLayerState.create({
+      id: boxWith(() => id),
+      interactOutsideBehavior: boxWith(() => interactOutsideBehavior),
+      onInteractOutside: boxWith(() => onInteractOutside),
+      enabled: boxWith(() => enabled),
+      onFocusOutside: boxWith(() => onFocusOutside),
+      isValidEvent: boxWith(() => isValidEvent2),
+      ref
+    });
+    children?.($$renderer2, { props: dismissibleLayerState.props });
+    $$renderer2.push(`<!---->`);
+  });
+}
+globalThis.bitsEscapeLayers ??= /* @__PURE__ */ new Map();
+class EscapeLayerState {
+  static create(opts) {
+    return new EscapeLayerState(opts);
+  }
+  opts;
+  domContext;
+  constructor(opts) {
+    this.opts = opts;
+    this.domContext = new DOMContext(this.opts.ref);
+    let unsubEvents = noop;
+    watch(() => opts.enabled.current, (enabled) => {
+      if (enabled) {
+        globalThis.bitsEscapeLayers.set(this, opts.escapeKeydownBehavior);
+        unsubEvents = this.#addEventListener();
+      }
+      return () => {
+        unsubEvents();
+        globalThis.bitsEscapeLayers.delete(this);
+      };
+    });
+  }
+  #addEventListener = () => {
+    return on(this.domContext.getDocument(), "keydown", this.#onkeydown, { passive: false });
+  };
+  #onkeydown = (e) => {
+    if (e.key !== ESCAPE || !isResponsibleEscapeLayer(this)) return;
+    const clonedEvent = new KeyboardEvent(e.type, e);
+    e.preventDefault();
+    const behaviorType = this.opts.escapeKeydownBehavior.current;
+    if (behaviorType !== "close" && behaviorType !== "defer-otherwise-close") return;
+    this.opts.onEscapeKeydown.current(clonedEvent);
+  };
+}
+function isResponsibleEscapeLayer(instance) {
+  const layersArr = [...globalThis.bitsEscapeLayers];
+  const topMostLayer = layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+  if (topMostLayer) return topMostLayer[0] === instance;
+  const [firstLayerNode] = layersArr[0];
+  return firstLayerNode === instance;
+}
+function Escape_layer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      escapeKeydownBehavior = "close",
+      onEscapeKeydown = noop,
+      children,
+      enabled,
+      ref
+    } = $$props;
+    EscapeLayerState.create({
+      escapeKeydownBehavior: boxWith(() => escapeKeydownBehavior),
+      onEscapeKeydown: boxWith(() => onEscapeKeydown),
+      enabled: boxWith(() => enabled),
+      ref
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+class FocusScopeManager {
+  static instance;
+  #scopeStack = simpleBox([]);
+  #focusHistory = /* @__PURE__ */ new WeakMap();
+  #preFocusHistory = /* @__PURE__ */ new WeakMap();
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new FocusScopeManager();
+    }
+    return this.instance;
+  }
+  register(scope) {
+    const current = this.getActive();
+    if (current && current !== scope) {
+      current.pause();
+    }
+    const activeElement = document.activeElement;
+    if (activeElement && activeElement !== document.body) {
+      this.#preFocusHistory.set(scope, activeElement);
+    }
+    this.#scopeStack.current = this.#scopeStack.current.filter((s) => s !== scope);
+    this.#scopeStack.current.unshift(scope);
+  }
+  unregister(scope) {
+    this.#scopeStack.current = this.#scopeStack.current.filter((s) => s !== scope);
+    const next = this.getActive();
+    if (next) {
+      next.resume();
+    }
+  }
+  getActive() {
+    return this.#scopeStack.current[0];
+  }
+  setFocusMemory(scope, element) {
+    this.#focusHistory.set(scope, element);
+  }
+  getFocusMemory(scope) {
+    return this.#focusHistory.get(scope);
+  }
+  isActiveScope(scope) {
+    return this.getActive() === scope;
+  }
+  setPreFocusMemory(scope, element) {
+    this.#preFocusHistory.set(scope, element);
+  }
+  getPreFocusMemory(scope) {
+    return this.#preFocusHistory.get(scope);
+  }
+  clearPreFocusMemory(scope) {
+    this.#preFocusHistory.delete(scope);
+  }
+}
+class FocusScope {
+  #paused = false;
+  #container = null;
+  #manager = FocusScopeManager.getInstance();
+  #cleanupFns = [];
+  #opts;
+  constructor(opts) {
+    this.#opts = opts;
+  }
+  get paused() {
+    return this.#paused;
+  }
+  pause() {
+    this.#paused = true;
+  }
+  resume() {
+    this.#paused = false;
+  }
+  #cleanup() {
+    for (const fn of this.#cleanupFns) {
+      fn();
+    }
+    this.#cleanupFns = [];
+  }
+  mount(container) {
+    if (this.#container) {
+      this.unmount();
+    }
+    this.#container = container;
+    this.#manager.register(this);
+    this.#setupEventListeners();
+    this.#handleOpenAutoFocus();
+  }
+  unmount() {
+    if (!this.#container) return;
+    this.#cleanup();
+    this.#handleCloseAutoFocus();
+    this.#manager.unregister(this);
+    this.#manager.clearPreFocusMemory(this);
+    this.#container = null;
+  }
+  #handleOpenAutoFocus() {
+    if (!this.#container) return;
+    const event = new CustomEvent("focusScope.onOpenAutoFocus", { bubbles: false, cancelable: true });
+    this.#opts.onOpenAutoFocus.current(event);
+    if (!event.defaultPrevented) {
+      requestAnimationFrame(() => {
+        if (!this.#container) return;
+        const firstTabbable = this.#getFirstTabbable();
+        if (firstTabbable) {
+          firstTabbable.focus();
+          this.#manager.setFocusMemory(this, firstTabbable);
+        } else {
+          this.#container.focus();
+        }
+      });
+    }
+  }
+  #handleCloseAutoFocus() {
+    const event = new CustomEvent("focusScope.onCloseAutoFocus", { bubbles: false, cancelable: true });
+    this.#opts.onCloseAutoFocus.current?.(event);
+    if (!event.defaultPrevented) {
+      const preFocusedElement = this.#manager.getPreFocusMemory(this);
+      if (preFocusedElement && document.contains(preFocusedElement)) {
+        try {
+          preFocusedElement.focus();
+        } catch {
+          document.body.focus();
+        }
+      }
+    }
+  }
+  #setupEventListeners() {
+    if (!this.#container || !this.#opts.trap.current) return;
+    const container = this.#container;
+    const doc = container.ownerDocument;
+    const handleFocus = (e) => {
+      if (this.#paused || !this.#manager.isActiveScope(this)) return;
+      const target = e.target;
+      if (!target) return;
+      const isInside = container.contains(target);
+      if (isInside) {
+        this.#manager.setFocusMemory(this, target);
+      } else {
+        const lastFocused = this.#manager.getFocusMemory(this);
+        if (lastFocused && container.contains(lastFocused) && isFocusable(lastFocused)) {
+          e.preventDefault();
+          lastFocused.focus();
+        } else {
+          const firstTabbable = this.#getFirstTabbable();
+          const firstFocusable = this.#getAllFocusables()[0];
+          (firstTabbable || firstFocusable || container).focus();
+        }
+      }
+    };
+    const handleKeydown = (e) => {
+      if (!this.#opts.loop || this.#paused || e.key !== "Tab") return;
+      if (!this.#manager.isActiveScope(this)) return;
+      const tabbables = this.#getTabbables();
+      if (tabbables.length < 2) return;
+      const first = tabbables[0];
+      const last = tabbables[tabbables.length - 1];
+      if (!e.shiftKey && doc.activeElement === last) {
+        e.preventDefault();
+        first.focus();
+      } else if (e.shiftKey && doc.activeElement === first) {
+        e.preventDefault();
+        last.focus();
+      }
+    };
+    this.#cleanupFns.push(on(doc, "focusin", handleFocus, { capture: true }), on(container, "keydown", handleKeydown));
+    const observer = new MutationObserver(() => {
+      const lastFocused = this.#manager.getFocusMemory(this);
+      if (lastFocused && !container.contains(lastFocused)) {
+        const firstTabbable = this.#getFirstTabbable();
+        const firstFocusable = this.#getAllFocusables()[0];
+        const elementToFocus = firstTabbable || firstFocusable;
+        if (elementToFocus) {
+          elementToFocus.focus();
+          this.#manager.setFocusMemory(this, elementToFocus);
+        } else {
+          container.focus();
+        }
+      }
+    });
+    observer.observe(container, { childList: true, subtree: true });
+    this.#cleanupFns.push(() => observer.disconnect());
+  }
+  #getTabbables() {
+    if (!this.#container) return [];
+    return tabbable(this.#container, { includeContainer: false, getShadowRoot: true });
+  }
+  #getFirstTabbable() {
+    const tabbables = this.#getTabbables();
+    return tabbables[0] || null;
+  }
+  #getAllFocusables() {
+    if (!this.#container) return [];
+    return focusable(this.#container, { includeContainer: false, getShadowRoot: true });
+  }
+  static use(opts) {
+    let scope = null;
+    watch([() => opts.ref.current, () => opts.enabled.current], ([ref, enabled]) => {
+      if (ref && enabled) {
+        if (!scope) {
+          scope = new FocusScope(opts);
+        }
+        scope.mount(ref);
+      } else if (scope) {
+        scope.unmount();
+        scope = null;
+      }
+    });
+    return {
+      get props() {
+        return { tabindex: -1 };
+      }
+    };
+  }
+}
+function Focus_scope($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      enabled = false,
+      trapFocus = false,
+      loop = false,
+      onCloseAutoFocus = noop,
+      onOpenAutoFocus = noop,
+      focusScope,
+      ref
+    } = $$props;
+    const focusScopeState = FocusScope.use({
+      enabled: boxWith(() => enabled),
+      trap: boxWith(() => trapFocus),
+      loop,
+      onCloseAutoFocus: boxWith(() => onCloseAutoFocus),
+      onOpenAutoFocus: boxWith(() => onOpenAutoFocus),
+      ref
+    });
+    focusScope?.($$renderer2, { props: focusScopeState.props });
+    $$renderer2.push(`<!---->`);
+  });
+}
+globalThis.bitsTextSelectionLayers ??= /* @__PURE__ */ new Map();
+class TextSelectionLayerState {
+  static create(opts) {
+    return new TextSelectionLayerState(opts);
+  }
+  opts;
+  domContext;
+  #unsubSelectionLock = noop;
+  constructor(opts) {
+    this.opts = opts;
+    this.domContext = new DOMContext(opts.ref);
+    let unsubEvents = noop;
+    watch(() => this.opts.enabled.current, (isEnabled) => {
+      if (isEnabled) {
+        globalThis.bitsTextSelectionLayers.set(this, this.opts.enabled);
+        unsubEvents();
+        unsubEvents = this.#addEventListeners();
+      }
+      return () => {
+        unsubEvents();
+        this.#resetSelectionLock();
+        globalThis.bitsTextSelectionLayers.delete(this);
+      };
+    });
+  }
+  #addEventListeners() {
+    return executeCallbacks(on(this.domContext.getDocument(), "pointerdown", this.#pointerdown), on(this.domContext.getDocument(), "pointerup", composeHandlers(this.#resetSelectionLock, this.opts.onPointerUp.current)));
+  }
+  #pointerdown = (e) => {
+    const node = this.opts.ref.current;
+    const target = e.target;
+    if (!isHTMLElement(node) || !isHTMLElement(target) || !this.opts.enabled.current) return;
+    if (!isHighestLayer(this) || !contains(node, target)) return;
+    this.opts.onPointerDown.current(e);
+    if (e.defaultPrevented) return;
+    this.#unsubSelectionLock = preventTextSelectionOverflow(node, this.domContext.getDocument().body);
+  };
+  #resetSelectionLock = () => {
+    this.#unsubSelectionLock();
+    this.#unsubSelectionLock = noop;
+  };
+}
+const getUserSelect = (node) => node.style.userSelect || node.style.webkitUserSelect;
+function preventTextSelectionOverflow(node, body) {
+  const originalBodyUserSelect = getUserSelect(body);
+  const originalNodeUserSelect = getUserSelect(node);
+  setUserSelect(body, "none");
+  setUserSelect(node, "text");
+  return () => {
+    setUserSelect(body, originalBodyUserSelect);
+    setUserSelect(node, originalNodeUserSelect);
+  };
+}
+function setUserSelect(node, value) {
+  node.style.userSelect = value;
+  node.style.webkitUserSelect = value;
+}
+function isHighestLayer(instance) {
+  const layersArr = [...globalThis.bitsTextSelectionLayers];
+  if (!layersArr.length) return false;
+  const highestLayer = layersArr.at(-1);
+  if (!highestLayer) return false;
+  return highestLayer[0] === instance;
+}
+function Text_selection_layer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      preventOverflowTextSelection = true,
+      onPointerDown = noop,
+      onPointerUp = noop,
+      id,
+      children,
+      enabled,
+      ref
+    } = $$props;
+    TextSelectionLayerState.create({
+      id: boxWith(() => id),
+      onPointerDown: boxWith(() => onPointerDown),
+      onPointerUp: boxWith(() => onPointerUp),
+      enabled: boxWith(() => enabled && preventOverflowTextSelection),
+      ref
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+globalThis.bitsIdCounter ??= { current: 0 };
+function useId(prefix = "bits") {
+  globalThis.bitsIdCounter.current++;
+  return `${prefix}-${globalThis.bitsIdCounter.current}`;
+}
+class SharedState {
+  #factory;
+  #subscribers = 0;
+  #state;
+  #scope;
+  constructor(factory) {
+    this.#factory = factory;
+  }
+  #dispose() {
+    this.#subscribers -= 1;
+    if (this.#scope && this.#subscribers <= 0) {
+      this.#scope();
+      this.#state = void 0;
+      this.#scope = void 0;
+    }
+  }
+  get(...args) {
+    this.#subscribers += 1;
+    if (this.#state === void 0) {
+      this.#scope = () => {
+      };
+    }
+    return this.#state;
+  }
+}
+const lockMap = new SvelteMap();
+let initialBodyStyle = null;
+let cleanupTimeoutId = null;
+let isInCleanupTransition = false;
+const anyLocked = boxWith(() => {
+  for (const value of lockMap.values()) {
+    if (value) return true;
+  }
+  return false;
+});
+let cleanupScheduledAt = null;
+const bodyLockStackCount = new SharedState(() => {
+  function resetBodyStyle() {
+    return;
+  }
+  function cancelPendingCleanup() {
+    if (cleanupTimeoutId === null) return;
+    window.clearTimeout(cleanupTimeoutId);
+    cleanupTimeoutId = null;
+  }
+  function scheduleCleanupIfNoNewLocks(delay, callback) {
+    cancelPendingCleanup();
+    isInCleanupTransition = true;
+    cleanupScheduledAt = Date.now();
+    const currentCleanupId = cleanupScheduledAt;
+    const cleanupFn = () => {
+      cleanupTimeoutId = null;
+      if (cleanupScheduledAt !== currentCleanupId) return;
+      if (!isAnyLocked(lockMap)) {
+        isInCleanupTransition = false;
+        callback();
+      } else {
+        isInCleanupTransition = false;
+      }
+    };
+    const actualDelay = delay === null ? 24 : delay;
+    cleanupTimeoutId = window.setTimeout(cleanupFn, actualDelay);
+  }
+  function ensureInitialStyleCaptured() {
+    if (initialBodyStyle === null && lockMap.size === 0 && !isInCleanupTransition) {
+      initialBodyStyle = document.body.getAttribute("style");
+    }
+  }
+  watch(() => anyLocked.current, () => {
+    if (!anyLocked.current) return;
+    ensureInitialStyleCaptured();
+    isInCleanupTransition = false;
+    const htmlStyle = getComputedStyle(document.documentElement);
+    const bodyStyle = getComputedStyle(document.body);
+    const hasStableGutter = htmlStyle.scrollbarGutter?.includes("stable") || bodyStyle.scrollbarGutter?.includes("stable");
+    const verticalScrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+    const paddingRight = Number.parseInt(bodyStyle.paddingRight ?? "0", 10);
+    const config = {
+      padding: paddingRight + verticalScrollbarWidth,
+      margin: Number.parseInt(bodyStyle.marginRight ?? "0", 10)
+    };
+    if (verticalScrollbarWidth > 0 && !hasStableGutter) {
+      document.body.style.paddingRight = `${config.padding}px`;
+      document.body.style.marginRight = `${config.margin}px`;
+      document.body.style.setProperty("--scrollbar-width", `${verticalScrollbarWidth}px`);
+    }
+    document.body.style.overflow = "hidden";
+    if (isIOS) {
+      on(
+        document,
+        "touchmove",
+        (e) => {
+          if (e.target !== document.documentElement) return;
+          if (e.touches.length > 1) return;
+          e.preventDefault();
+        },
+        { passive: false }
+      );
+    }
+    afterTick(() => {
+      document.body.style.pointerEvents = "none";
+      document.body.style.overflow = "hidden";
+    });
+  });
+  return {
+    get lockMap() {
+      return lockMap;
+    },
+    resetBodyStyle,
+    scheduleCleanupIfNoNewLocks,
+    cancelPendingCleanup,
+    ensureInitialStyleCaptured
+  };
+});
+class BodyScrollLock {
+  #id = useId();
+  #initialState;
+  #restoreScrollDelay = () => null;
+  #countState;
+  locked;
+  constructor(initialState, restoreScrollDelay = () => null) {
+    this.#initialState = initialState;
+    this.#restoreScrollDelay = restoreScrollDelay;
+    this.#countState = bodyLockStackCount.get();
+    if (!this.#countState) return;
+    this.#countState.cancelPendingCleanup();
+    this.#countState.ensureInitialStyleCaptured();
+    this.#countState.lockMap.set(this.#id, this.#initialState ?? false);
+    this.locked = boxWith(() => this.#countState.lockMap.get(this.#id) ?? false, (v) => this.#countState.lockMap.set(this.#id, v));
+  }
+}
+function isAnyLocked(map) {
+  for (const [_, value] of map) {
+    if (value) return true;
+  }
+  return false;
+}
+function Scroll_lock($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { preventScroll = true, restoreScrollDelay = null } = $$props;
+    if (preventScroll) {
+      new BodyScrollLock(preventScroll, () => restoreScrollDelay);
+    }
+  });
+}
+function Alert_dialog_content$1($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const uid = props_id($$renderer2);
+    let {
+      id = createId(uid),
+      children,
+      child,
+      ref = null,
+      forceMount = false,
+      interactOutsideBehavior = "ignore",
+      onCloseAutoFocus = noop,
+      onEscapeKeydown = noop,
+      onOpenAutoFocus = noop,
+      onInteractOutside = noop,
+      preventScroll = true,
+      trapFocus = true,
+      restoreScrollDelay = null,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const contentState = DialogContentState.create({
+      id: boxWith(() => id),
+      ref: boxWith(() => ref, (v) => ref = v)
+    });
+    const mergedProps = mergeProps(restProps, contentState.props);
+    if (contentState.shouldRender || forceMount) {
+      $$renderer2.push("<!--[-->");
+      {
+        let focusScope = function($$renderer3, { props: focusScopeProps }) {
+          Escape_layer($$renderer3, spread_props([
+            mergedProps,
+            {
+              enabled: contentState.root.opts.open.current,
+              ref: contentState.opts.ref,
+              onEscapeKeydown: (e) => {
+                onEscapeKeydown(e);
+                if (e.defaultPrevented) return;
+                contentState.root.handleClose();
+              },
+              children: ($$renderer4) => {
+                Dismissible_layer($$renderer4, spread_props([
+                  mergedProps,
+                  {
+                    ref: contentState.opts.ref,
+                    enabled: contentState.root.opts.open.current,
+                    interactOutsideBehavior,
+                    onInteractOutside: (e) => {
+                      onInteractOutside(e);
+                      if (e.defaultPrevented) return;
+                      contentState.root.handleClose();
+                    },
+                    children: ($$renderer5) => {
+                      Text_selection_layer($$renderer5, spread_props([
+                        mergedProps,
+                        {
+                          ref: contentState.opts.ref,
+                          enabled: contentState.root.opts.open.current,
+                          children: ($$renderer6) => {
+                            if (child) {
+                              $$renderer6.push("<!--[-->");
+                              if (contentState.root.opts.open.current) {
+                                $$renderer6.push("<!--[-->");
+                                Scroll_lock($$renderer6, { preventScroll, restoreScrollDelay });
+                              } else {
+                                $$renderer6.push("<!--[!-->");
+                              }
+                              $$renderer6.push(`<!--]--> `);
+                              child($$renderer6, {
+                                props: mergeProps(mergedProps, focusScopeProps),
+                                ...contentState.snippetProps
+                              });
+                              $$renderer6.push(`<!---->`);
+                            } else {
+                              $$renderer6.push("<!--[!-->");
+                              Scroll_lock($$renderer6, { preventScroll });
+                              $$renderer6.push(`<!----> <div${attributes({ ...mergeProps(mergedProps, focusScopeProps) })}>`);
+                              children?.($$renderer6);
+                              $$renderer6.push(`<!----></div>`);
+                            }
+                            $$renderer6.push(`<!--]-->`);
+                          },
+                          $$slots: { default: true }
+                        }
+                      ]));
+                    },
+                    $$slots: { default: true }
+                  }
+                ]));
+              },
+              $$slots: { default: true }
+            }
+          ]));
+        };
+        Focus_scope($$renderer2, {
+          ref: contentState.opts.ref,
+          loop: true,
+          trapFocus,
+          enabled: contentState.root.opts.open.current,
+          onCloseAutoFocus,
+          onOpenAutoFocus: (e) => {
+            onOpenAutoFocus(e);
+            if (e.defaultPrevented) return;
+            e.preventDefault();
+            afterSleep(0, () => contentState.opts.ref.current?.focus());
+          },
+          focusScope
+        });
+      }
+    } else {
+      $$renderer2.push("<!--[!-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Dialog_overlay($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const uid = props_id($$renderer2);
+    let {
+      id = createId(uid),
+      forceMount = false,
+      child,
+      children,
+      ref = null,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const overlayState = DialogOverlayState.create({
+      id: boxWith(() => id),
+      ref: boxWith(() => ref, (v) => ref = v)
+    });
+    const mergedProps = mergeProps(restProps, overlayState.props);
+    if (overlayState.shouldRender || forceMount) {
+      $$renderer2.push("<!--[-->");
+      if (child) {
+        $$renderer2.push("<!--[-->");
+        child($$renderer2, { props: mergeProps(mergedProps), ...overlayState.snippetProps });
+        $$renderer2.push(`<!---->`);
+      } else {
+        $$renderer2.push("<!--[!-->");
+        $$renderer2.push(`<div${attributes({ ...mergeProps(mergedProps) })}>`);
+        children?.($$renderer2, overlayState.snippetProps);
+        $$renderer2.push(`<!----></div>`);
+      }
+      $$renderer2.push(`<!--]-->`);
+    } else {
+      $$renderer2.push("<!--[!-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Dialog_description($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const uid = props_id($$renderer2);
+    let {
+      id = createId(uid),
+      children,
+      child,
+      ref = null,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const descriptionState = DialogDescriptionState.create({
+      id: boxWith(() => id),
+      ref: boxWith(() => ref, (v) => ref = v)
+    });
+    const mergedProps = mergeProps(restProps, descriptionState.props);
+    if (child) {
+      $$renderer2.push("<!--[-->");
+      child($$renderer2, { props: mergedProps });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[!-->");
+      $$renderer2.push(`<div${attributes({ ...mergedProps })}>`);
+      children?.($$renderer2);
+      $$renderer2.push(`<!----></div>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { open = false, $$slots, $$events, ...restProps } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<!---->`);
+      Alert_dialog$1?.($$renderer3, spread_props([
+        restProps,
+        {
+          get open() {
+            return open;
+          },
+          set open($$value) {
+            open = $$value;
+            $$settled = false;
+          }
+        }
+      ]));
+      $$renderer3.push(`<!---->`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { open });
+  });
+}
+function Alert_dialog_portal($$renderer, $$props) {
+  let { $$slots, $$events, ...restProps } = $$props;
+  $$renderer.push(`<!---->`);
+  Portal?.($$renderer, spread_props([restProps]));
+  $$renderer.push(`<!---->`);
+}
+function Alert_dialog_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) {
+      $$renderer3.push(`<!---->`);
+      Dialog_title?.($$renderer3, spread_props([
+        {
+          "data-slot": "alert-dialog-title",
+          class: cn("text-lg font-semibold", className)
+        },
+        restProps,
+        {
+          get ref() {
+            return ref;
+          },
+          set ref($$value) {
+            ref = $$value;
+            $$settled = false;
+          }
+        }
+      ]));
+      $$renderer3.push(`<!---->`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog_action($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<!---->`);
+      Alert_dialog_action$1?.($$renderer3, spread_props([
+        {
+          "data-slot": "alert-dialog-action",
+          class: cn(buttonVariants(), className)
+        },
+        restProps,
+        {
+          get ref() {
+            return ref;
+          },
+          set ref($$value) {
+            ref = $$value;
+            $$settled = false;
+          }
+        }
+      ]));
+      $$renderer3.push(`<!---->`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog_cancel($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<!---->`);
+      Alert_dialog_cancel$1?.($$renderer3, spread_props([
+        {
+          "data-slot": "alert-dialog-cancel",
+          class: cn(buttonVariants({ variant: "outline" }), className)
+        },
+        restProps,
+        {
+          get ref() {
+            return ref;
+          },
+          set ref($$value) {
+            ref = $$value;
+            $$settled = false;
+          }
+        }
+      ]));
+      $$renderer3.push(`<!---->`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog_footer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<div${attributes({
+      "data-slot": "alert-dialog-footer",
+      class: clsx$1(cn("flex flex-col-reverse gap-2 sm:flex-row sm:justify-end", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog_header($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    $$renderer2.push(`<div${attributes({
+      "data-slot": "alert-dialog-header",
+      class: clsx$1(cn("flex flex-col gap-2 text-center sm:text-start", className)),
+      ...restProps
+    })}>`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog_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) {
+      $$renderer3.push(`<!---->`);
+      Dialog_overlay?.($$renderer3, spread_props([
+        {
+          "data-slot": "alert-dialog-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(`<!---->`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+function Alert_dialog_content($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      ref = null,
+      class: className,
+      portalProps,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      Alert_dialog_portal($$renderer3, spread_props([
+        portalProps,
+        {
+          children: ($$renderer4) => {
+            Alert_dialog_overlay($$renderer4, {});
+            $$renderer4.push(`<!----> <!---->`);
+            Alert_dialog_content$1?.($$renderer4, spread_props([
+              {
+                "data-slot": "alert-dialog-content",
+                class: cn("bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg", className)
+              },
+              restProps,
+              {
+                get ref() {
+                  return ref;
+                },
+                set ref($$value) {
+                  ref = $$value;
+                  $$settled = false;
+                }
+              }
+            ]));
+            $$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 Alert_dialog_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) {
+      $$renderer3.push(`<!---->`);
+      Dialog_description?.($$renderer3, spread_props([
+        {
+          "data-slot": "alert-dialog-description",
+          class: cn("text-muted-foreground text-sm", className)
+        },
+        restProps,
+        {
+          get ref() {
+            return ref;
+          },
+          set ref($$value) {
+            ref = $$value;
+            $$settled = false;
+          }
+        }
+      ]));
+      $$renderer3.push(`<!---->`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    bind_props($$props, { ref });
+  });
+}
+export {
+  Alert_dialog as A,
+  Alert_dialog_description as B,
+  Context as C,
+  DialogRootState as D,
+  ENTER as E,
+  Focus_scope as F,
+  Alert_dialog_footer as G,
+  Alert_dialog_cancel as H,
+  Alert_dialog_action as I,
+  Portal as P,
+  SPACE as S,
+  Text_selection_layer as T,
+  attachRef as a,
+  boolToEmptyStrOrUndef as b,
+  createBitsAttrs as c,
+  boolToStr as d,
+  createId as e,
+  boxWith as f,
+  getAriaChecked as g,
+  DialogCloseState as h,
+  isHTMLElement as i,
+  DialogContentState as j,
+  Escape_layer as k,
+  Dismissible_layer as l,
+  mergeProps as m,
+  noop as n,
+  Scroll_lock as o,
+  simpleBox as p,
+  executeCallbacks as q,
+  DOMContext as r,
+  styleToString as s,
+  Dialog_title as t,
+  useId as u,
+  Dialog_overlay as v,
+  watch as w,
+  Alert_dialog_content as x,
+  Alert_dialog_header as y,
+  Alert_dialog_title as z
+};