@recombine-ai/platform 0.2.6-test.8 → 0.3.0

package/build/bosun-app/frontend/server/chunks/chunks/Modal.js-BUDSUOER.js

@@ -0,0 +1,2290 @@
+import { ad as bind_props, ak as hasContext, a7 as getContext, y as setContext, R as derived, al as getAllContexts, am as spread_props, an as clsx$1, ab as attributes, a8 as escape_html } from './index.js-DczFGj-7.js';
+import { m as mount, u as unmount, t as tick } from './index-server.js-CALBgpac.js';
+import { o as on } from './root.js-CJvqqGUj.js';
+
+function isFunction(value) {
+  return typeof value === "function";
+}
+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 = Symbol("box");
+const isWritableSymbol = Symbol("is-writable");
+function isBox(value) {
+  return isObject(value) && BoxSymbol in value;
+}
+function isWritableBox(value) {
+  return box.isBox(value) && isWritableSymbol in value;
+}
+function box(initialValue) {
+  let current = initialValue;
+  return {
+    [BoxSymbol]: true,
+    [isWritableSymbol]: true,
+    get current() {
+      return current;
+    },
+    set current(v) {
+      current = v;
+    }
+  };
+}
+function boxWith(getter, setter) {
+  const derived$1 = derived(getter);
+  if (setter) {
+    return {
+      [BoxSymbol]: true,
+      [isWritableSymbol]: true,
+      get current() {
+        return derived$1();
+      },
+      set current(v) {
+        setter(v);
+      }
+    };
+  }
+  return {
+    [BoxSymbol]: true,
+    get current() {
+      return getter();
+    }
+  };
+}
+function boxFrom(value) {
+  if (box.isBox(value)) return value;
+  if (isFunction(value)) return box.with(value);
+  return box(value);
+}
+function boxFlatten(boxes) {
+  return Object.entries(boxes).reduce(
+    (acc, [key, b]) => {
+      if (!box.isBox(b)) {
+        return Object.assign(acc, { [key]: b });
+      }
+      if (box.isWritableBox(b)) {
+        Object.defineProperty(acc, key, {
+          get() {
+            return b.current;
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          set(v) {
+            b.current = v;
+          }
+        });
+      } else {
+        Object.defineProperty(acc, key, {
+          get() {
+            return b.current;
+          }
+        });
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function toReadonlyBox(b) {
+  if (!box.isWritableBox(b)) return b;
+  return {
+    [BoxSymbol]: true,
+    get current() {
+      return b.current;
+    }
+  };
+}
+box.from = boxFrom;
+box.with = boxWith;
+box.flatten = boxFlatten;
+box.readonly = toReadonlyBox;
+box.isBox = isBox;
+box.isWritableBox = isWritableBox;
+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);
+      }
+    }
+  };
+}
+var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+var NEWLINE_REGEX = /\n/g;
+var WHITESPACE_REGEX = /^\s*/;
+var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
+var COLON_REGEX = /^:\s*/;
+var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
+var SEMICOLON_REGEX = /^[;\s]*/;
+var TRIM_REGEX = /^\s+|\s+$/g;
+var NEWLINE = "\n";
+var FORWARD_SLASH = "/";
+var ASTERISK = "*";
+var EMPTY_STRING = "";
+var TYPE_COMMENT = "comment";
+var TYPE_DECLARATION = "declaration";
+function index(style, options) {
+  if (typeof style !== "string") {
+    throw new TypeError("First argument must be a string");
+  }
+  if (!style) return [];
+  options = options || {};
+  var lineno = 1;
+  var column = 1;
+  function updatePosition(str) {
+    var lines = str.match(NEWLINE_REGEX);
+    if (lines) lineno += lines.length;
+    var i = str.lastIndexOf(NEWLINE);
+    column = ~i ? str.length - i : column + str.length;
+  }
+  function position() {
+    var start = { line: lineno, column };
+    return function(node) {
+      node.position = new Position(start);
+      whitespace();
+      return node;
+    };
+  }
+  function Position(start) {
+    this.start = start;
+    this.end = { line: lineno, column };
+    this.source = options.source;
+  }
+  Position.prototype.content = style;
+  function error(msg) {
+    var err = new Error(
+      options.source + ":" + lineno + ":" + column + ": " + msg
+    );
+    err.reason = msg;
+    err.filename = options.source;
+    err.line = lineno;
+    err.column = column;
+    err.source = style;
+    if (options.silent) ;
+    else {
+      throw err;
+    }
+  }
+  function match(re) {
+    var m = re.exec(style);
+    if (!m) return;
+    var str = m[0];
+    updatePosition(str);
+    style = style.slice(str.length);
+    return m;
+  }
+  function whitespace() {
+    match(WHITESPACE_REGEX);
+  }
+  function comments(rules) {
+    var c;
+    rules = rules || [];
+    while (c = comment()) {
+      if (c !== false) {
+        rules.push(c);
+      }
+    }
+    return rules;
+  }
+  function comment() {
+    var pos = position();
+    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;
+    var i = 2;
+    while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {
+      ++i;
+    }
+    i += 2;
+    if (EMPTY_STRING === style.charAt(i - 1)) {
+      return error("End of comment missing");
+    }
+    var str = style.slice(2, i - 2);
+    column += 2;
+    updatePosition(str);
+    style = style.slice(i);
+    column += 2;
+    return pos({
+      type: TYPE_COMMENT,
+      comment: str
+    });
+  }
+  function declaration() {
+    var pos = position();
+    var prop = match(PROPERTY_REGEX);
+    if (!prop) return;
+    comment();
+    if (!match(COLON_REGEX)) return error("property missing ':'");
+    var val = match(VALUE_REGEX);
+    var ret = pos({
+      type: TYPE_DECLARATION,
+      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+      value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
+    });
+    match(SEMICOLON_REGEX);
+    return ret;
+  }
+  function declarations() {
+    var decls = [];
+    comments(decls);
+    var decl;
+    while (decl = declaration()) {
+      if (decl !== false) {
+        decls.push(decl);
+        comments(decls);
+      }
+    }
+    return decls;
+  }
+  whitespace();
+  return declarations();
+}
+function trim(str) {
+  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
+}
+function StyleToObject(style, iterator) {
+  let styleObject = null;
+  if (!style || typeof style !== "string") {
+    return styleObject;
+  }
+  const declarations = index(style);
+  const hasIterator = typeof iterator === "function";
+  declarations.forEach((declaration) => {
+    if (declaration.type !== "declaration") {
+      return;
+    }
+    const { property, value } = declaration;
+    if (hasIterator) {
+      iterator(property, value, declaration);
+    } else if (value) {
+      styleObject = styleObject || {};
+      styleObject[property] = value;
+    }
+  });
+  return styleObject;
+}
+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;
+  }
+  StyleToObject(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 srOnlyStyles = {
+  position: "absolute",
+  width: "1px",
+  height: "1px",
+  padding: "0",
+  margin: "-1px",
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  borderWidth: "0",
+  transform: "translateX(-100%)"
+};
+styleToString(srOnlyStyles);
+function isEventHandler(key) {
+  return key.length > 2 && key.startsWith("on") && key[2] === key[2]?.toLowerCase();
+}
+function mergeProps(...args) {
+  const result = { ...args[0] };
+  for (let i = 1; i < args.length; i++) {
+    const props = args[i];
+    for (const key in 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$1(a, b);
+        } else if (aIsClassValue) {
+          result[key] = clsx$1(a);
+        } else if (bIsClassValue) {
+          result[key] = clsx$1(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;
+      }
+    }
+  }
+  if (typeof result.style === "object") {
+    result.style = styleToString(result.style).replaceAll("\n", " ");
+  }
+  if (result.hidden !== true) {
+    result.hidden = void 0;
+    delete result.hidden;
+  }
+  if (result.disabled !== true) {
+    result.disabled = void 0;
+    delete result.disabled;
+  }
+  return result;
+}
+const defaultWindow = void 0;
+function getActiveElement(document2) {
+  let activeElement = document2.activeElement;
+  while (activeElement?.shadowRoot) {
+    const node = activeElement.shadowRoot.activeElement;
+    if (node === activeElement)
+      break;
+    else
+      activeElement = node;
+  }
+  return activeElement;
+}
+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(this.#document);
+  }
+}
+new ActiveElement();
+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;
+class Previous {
+  #previous = void 0;
+  #curr;
+  constructor(getter) {
+  }
+  get current() {
+    return this.#previous;
+  }
+}
+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 useRefById({ id, ref, deps = () => true, onRefChange, getRootNode: getRootNode2 }) {
+  watch([() => id.current, deps], ([_id]) => {
+    const rootNode = getRootNode2?.() ?? document;
+    const node = rootNode?.getElementById(_id);
+    if (node) ref.current = node;
+    else ref.current = null;
+    onRefChange?.(ref.current);
+  });
+}
+function afterSleep(ms, cb) {
+  return setTimeout(cb, ms);
+}
+function afterTick(fn) {
+  tick().then(fn);
+}
+function getDataOpenClosed(condition) {
+  return condition ? "open" : "closed";
+}
+const ENTER = "Enter";
+const ESCAPE = "Escape";
+const SPACE = " ";
+const TAB = "Tab";
+const isBrowser = typeof document !== "undefined";
+function isHTMLElement(element) {
+  return element instanceof HTMLElement;
+}
+function isElement(element) {
+  return element instanceof Element;
+}
+function isSelectableInput(element) {
+  return element instanceof HTMLInputElement && "select" in element;
+}
+function isElementHidden(node, stopAt) {
+  if (getComputedStyle(node).visibility === "hidden")
+    return true;
+  while (node) {
+    if (stopAt !== void 0 && node === stopAt)
+      return false;
+    if (getComputedStyle(node).display === "none")
+      return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+globalThis.bitsIdCounter ??= { current: 0 };
+function useId(prefix = "bits") {
+  globalThis.bitsIdCounter.current++;
+  return `${prefix}-${globalThis.bitsIdCounter.current}`;
+}
+function noop() {
+}
+function useStateMachine(initialState, machine) {
+  const state = box(initialState);
+  function reducer(event) {
+    const nextState = machine[state.current][event];
+    return nextState ?? state.current;
+  }
+  const dispatch = (event) => {
+    state.current = reducer(event);
+  };
+  return { state, dispatch };
+}
+function usePresence(present, id) {
+  let styles = {};
+  let prevAnimationNameState = "none";
+  const initialState = present.current ? "mounted" : "unmounted";
+  let node = null;
+  const prevPresent = new Previous(() => present.current);
+  watch([() => id.current, () => present.current], ([id2, present2]) => {
+    if (!id2 || !present2) return;
+    afterTick(() => {
+      node = document.getElementById(id2);
+    });
+  });
+  const { state, dispatch } = useStateMachine(initialState, {
+    mounted: { UNMOUNT: "unmounted", ANIMATION_OUT: "unmountSuspended" },
+    unmountSuspended: { MOUNT: "mounted", ANIMATION_END: "unmounted" },
+    unmounted: { MOUNT: "mounted" }
+  });
+  watch(() => present.current, (currPresent) => {
+    if (!node) {
+      node = document.getElementById(id.current);
+    }
+    if (!node) return;
+    const hasPresentChanged = currPresent !== prevPresent.current;
+    if (!hasPresentChanged) return;
+    const prevAnimationName = prevAnimationNameState;
+    const currAnimationName = getAnimationName(node);
+    if (currPresent) {
+      dispatch("MOUNT");
+    } else if (currAnimationName === "none" || styles.display === "none") {
+      dispatch("UNMOUNT");
+    } else {
+      const isAnimating = prevAnimationName !== currAnimationName;
+      if (prevPresent && isAnimating) {
+        dispatch("ANIMATION_OUT");
+      } else {
+        dispatch("UNMOUNT");
+      }
+    }
+  });
+  function handleAnimationEnd(event) {
+    if (!node) node = document.getElementById(id.current);
+    if (!node) return;
+    const currAnimationName = getAnimationName(node);
+    const isCurrentAnimation = currAnimationName.includes(event.animationName) || currAnimationName === "none";
+    if (event.target === node && isCurrentAnimation) {
+      dispatch("ANIMATION_END");
+    }
+  }
+  function handleAnimationStart(event) {
+    if (!node) node = document.getElementById(id.current);
+    if (!node) return;
+    if (event.target === node) {
+      prevAnimationNameState = getAnimationName(node);
+    }
+  }
+  watch(() => state.current, () => {
+    if (!node) node = document.getElementById(id.current);
+    if (!node) return;
+    const currAnimationName = getAnimationName(node);
+    prevAnimationNameState = state.current === "mounted" ? currAnimationName : "none";
+  });
+  watch(() => node, (node2) => {
+    if (!node2) return;
+    styles = getComputedStyle(node2);
+    return executeCallbacks(on(node2, "animationstart", handleAnimationStart), on(node2, "animationcancel", handleAnimationEnd), on(node2, "animationend", handleAnimationEnd));
+  });
+  const isPresentDerived = derived(() => ["mounted", "unmountSuspended"].includes(state.current));
+  return {
+    get current() {
+      return isPresentDerived();
+    }
+  };
+}
+function getAnimationName(node) {
+  return node ? getComputedStyle(node).animationName || "none" : "none";
+}
+function Presence_layer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { present, forceMount, presence, id } = $$props;
+    const isPresent = usePresence(box.with(() => present), box.with(() => id));
+    if (forceMount || present || isPresent.current) {
+      $$renderer2.push("<!--[0-->");
+      presence?.($$renderer2, { present: isPresent });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+function createAttrs(variant) {
+  return {
+    content: `data-${variant}-content`,
+    trigger: `data-${variant}-trigger`,
+    overlay: `data-${variant}-overlay`,
+    title: `data-${variant}-title`,
+    description: `data-${variant}-description`,
+    close: `data-${variant}-close`,
+    cancel: `data-${variant}-cancel`,
+    action: `data-${variant}-action`
+  };
+}
+class DialogRootState {
+  opts;
+  triggerNode = null;
+  contentNode = null;
+  descriptionNode = null;
+  contentId = void 0;
+  titleId = void 0;
+  triggerId = void 0;
+  descriptionId = void 0;
+  cancelNode = null;
+  #attrs = derived(() => createAttrs(this.opts.variant.current));
+  get attrs() {
+    return this.#attrs();
+  }
+  set attrs($$value) {
+    return this.#attrs($$value);
+  }
+  constructor(opts) {
+    this.opts = opts;
+    this.handleOpen = this.handleOpen.bind(this);
+    this.handleClose = this.handleClose.bind(this);
+  }
+  handleOpen() {
+    if (this.opts.open.current) return;
+    this.opts.open.current = true;
+  }
+  handleClose() {
+    if (!this.opts.open.current) return;
+    this.opts.open.current = false;
+  }
+  #sharedProps = derived(() => ({ "data-state": getDataOpenClosed(this.opts.open.current) }));
+  get sharedProps() {
+    return this.#sharedProps();
+  }
+  set sharedProps($$value) {
+    return this.#sharedProps($$value);
+  }
+}
+class DialogCloseState {
+  opts;
+  root;
+  #attr = derived(() => this.root.attrs[this.opts.variant.current]);
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.onclick = this.onclick.bind(this);
+    this.onkeydown = this.onkeydown.bind(this);
+    useRefById({ ...opts, deps: () => this.root.opts.open.current });
+  }
+  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.#attr()]: "",
+    onclick: this.onclick,
+    onkeydown: this.onkeydown,
+    disabled: this.opts.disabled.current ? true : void 0,
+    tabindex: 0,
+    ...this.root.sharedProps
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class DialogTitleState {
+  opts;
+  root;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    useRefById({
+      ...opts,
+      onRefChange: (node) => {
+        this.root.titleId = node?.id;
+      },
+      deps: () => this.root.opts.open.current
+    });
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    role: "heading",
+    "aria-level": this.opts.level.current,
+    [this.root.attrs.title]: "",
+    ...this.root.sharedProps
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class DialogContentState {
+  opts;
+  root;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    useRefById({
+      ...opts,
+      deps: () => this.root.opts.open.current,
+      onRefChange: (node) => {
+        this.root.contentNode = node;
+        this.root.contentId = node?.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.attrs.content]: "",
+    style: {
+      pointerEvents: "auto",
+      outline: this.root.opts.variant.current === "alert-dialog" ? "none" : void 0
+    },
+    tabindex: this.root.opts.variant.current === "alert-dialog" ? -1 : void 0,
+    ...this.root.sharedProps
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class DialogOverlayState {
+  opts;
+  root;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    useRefById({ ...opts, deps: () => this.root.opts.open.current });
+  }
+  #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.attrs.overlay]: "",
+    style: { pointerEvents: "auto" },
+    ...this.root.sharedProps
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+const DialogRootContext = new Context("Dialog.Root");
+function useDialogRoot(props) {
+  return DialogRootContext.set(new DialogRootState(props));
+}
+function useDialogTitle(props) {
+  return new DialogTitleState(props, DialogRootContext.get());
+}
+function useDialogContent(props) {
+  return new DialogContentState(props, DialogRootContext.get());
+}
+function useDialogOverlay(props) {
+  return new DialogOverlayState(props, DialogRootContext.get());
+}
+function useDialogClose(props) {
+  return new DialogCloseState(props, DialogRootContext.get());
+}
+function Dialog_title($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id = useId(),
+      ref = null,
+      child,
+      children,
+      level = 2,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const titleState = useDialogTitle({
+      id: box.with(() => id),
+      level: box.with(() => level),
+      ref: box.with(() => ref, (v) => ref = v)
+    });
+    const mergedProps = derived(() => mergeProps(restProps, titleState.props));
+    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 Portal($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { to = "body", children, disabled } = $$props;
+    getAllContexts();
+    let target = derived(getTarget);
+    function getTarget() {
+      if (!isBrowser || disabled) return null;
+      let localTarget = null;
+      if (typeof to === "string") {
+        localTarget = document.querySelector(to);
+      } else if (to instanceof HTMLElement || to instanceof DocumentFragment) {
+        localTarget = to;
+      } else ;
+      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("<!--[0-->");
+      children?.($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+function addEventListener(target, event, handler, options) {
+  const events = Array.isArray(event) ? event : [event];
+  events.forEach((_event) => target.addEventListener(_event, handler, options));
+  return () => {
+    events.forEach((_event) => target.removeEventListener(_event, handler, options));
+  };
+}
+class CustomEventDispatcher {
+  eventName;
+  options;
+  constructor(eventName, options = { bubbles: true, cancelable: true }) {
+    this.eventName = eventName;
+    this.options = options;
+  }
+  createEvent(detail) {
+    return new CustomEvent(this.eventName, {
+      ...this.options,
+      detail
+    });
+  }
+  dispatch(element, detail) {
+    const event = this.createEvent(detail);
+    element.dispatchEvent(event);
+    return event;
+  }
+  listen(element, callback, options) {
+    const handler = (event) => {
+      callback(event);
+    };
+    return on(element, this.eventName, handler, options);
+  }
+}
+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;
+}
+globalThis.bitsDismissableLayers ??= /* @__PURE__ */ new Map();
+class DismissibleLayerState {
+  opts;
+  #interactOutsideProp;
+  #behaviorType;
+  #interceptedEvents = { pointerdown: false };
+  #isResponsibleLayer = false;
+  #isFocusInsideDOMTree = false;
+  node = box(null);
+  #documentObj = void 0;
+  #onFocusOutside;
+  currNode = null;
+  #unsubClickListener = noop;
+  constructor(opts) {
+    this.opts = opts;
+    useRefById({
+      id: opts.id,
+      ref: this.node,
+      deps: () => opts.enabled.current,
+      onRefChange: (node) => {
+        this.currNode = node;
+      }
+    });
+    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.currNode], ([enabled, currNode]) => {
+      if (!enabled || !currNode) return;
+      afterSleep(1, () => {
+        if (!this.currNode) return;
+        globalThis.bitsDismissableLayers.set(this, this.#behaviorType);
+        unsubEvents();
+        unsubEvents = this.#addEventListeners();
+      });
+      return cleanup;
+    });
+  }
+  #handleFocus = (event) => {
+    if (event.defaultPrevented) return;
+    if (!this.currNode) return;
+    afterTick(() => {
+      if (!this.currNode || 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.currNode) {
+        this.#unsubClickListener();
+        return;
+      }
+      const isEventValid = this.opts.isValidEvent.current(e, this.currNode) || isValidEvent(e, this.currNode);
+      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 = addEventListener(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.node.current) return;
+    this.#isResponsibleLayer = isResponsibleLayer(this.node.current);
+  };
+  #isTargetWithinLayer = (target) => {
+    if (!this.node.current) return false;
+    return isOrContainsTarget(this.node.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 useDismissibleLayer(props) {
+  return new DismissibleLayerState(props);
+}
+function getTopMostLayer(layersArr) {
+  return layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+}
+function isResponsibleLayer(node) {
+  const layersArr = [...globalThis.bitsDismissableLayers];
+  const topMostLayer = getTopMostLayer(layersArr);
+  if (topMostLayer) return topMostLayer[0].node.current === node;
+  const [firstLayerNode] = layersArr[0];
+  return firstLayerNode.node.current === node;
+}
+function isValidEvent(e, node) {
+  if ("button" in e && e.button > 0) return false;
+  const target = e.target;
+  if (!isElement(target)) 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
+    } = $$props;
+    const dismissibleLayerState = useDismissibleLayer({
+      id: box.with(() => id),
+      interactOutsideBehavior: box.with(() => interactOutsideBehavior),
+      onInteractOutside: box.with(() => onInteractOutside),
+      enabled: box.with(() => enabled),
+      onFocusOutside: box.with(() => onFocusOutside),
+      isValidEvent: box.with(() => isValidEvent2)
+    });
+    children?.($$renderer2, { props: dismissibleLayerState.props });
+    $$renderer2.push(`<!---->`);
+  });
+}
+globalThis.bitsEscapeLayers ??= /* @__PURE__ */ new Map();
+class EscapeLayerState {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    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(document, "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 useEscapeLayer(props) {
+  return new EscapeLayerState(props);
+}
+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
+    } = $$props;
+    useEscapeLayer({
+      escapeKeydownBehavior: box.with(() => escapeKeydownBehavior),
+      onEscapeKeydown: box.with(() => onEscapeKeydown),
+      enabled: box.with(() => enabled)
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+const focusStack = box([]);
+function createFocusScopeStack() {
+  return {
+    add(focusScope) {
+      const activeFocusScope = focusStack.current[0];
+      if (activeFocusScope && focusScope.id !== activeFocusScope.id) {
+        activeFocusScope.pause();
+      }
+      focusStack.current = removeFromFocusScopeArray(focusStack.current, focusScope);
+      focusStack.current.unshift(focusScope);
+    },
+    remove(focusScope) {
+      focusStack.current = removeFromFocusScopeArray(focusStack.current, focusScope);
+      focusStack.current[0]?.resume();
+    },
+    get current() {
+      return focusStack.current;
+    }
+  };
+}
+function createFocusScopeAPI() {
+  let paused = false;
+  let isHandlingFocus = false;
+  return {
+    id: useId(),
+    get paused() {
+      return paused;
+    },
+    get isHandlingFocus() {
+      return isHandlingFocus;
+    },
+    set isHandlingFocus(value) {
+      isHandlingFocus = value;
+    },
+    pause() {
+      paused = true;
+    },
+    resume() {
+      paused = false;
+    }
+  };
+}
+function removeFromFocusScopeArray(arr, item) {
+  return [...arr].filter((i) => i.id !== item.id);
+}
+function removeLinks(items) {
+  return items.filter((item) => item.tagName !== "A");
+}
+function focus(element, { select = false } = {}) {
+  if (!(element && element.focus))
+    return;
+  if (document.activeElement === element)
+    return;
+  const previouslyFocusedElement = document.activeElement;
+  element.focus({ preventScroll: true });
+  if (element !== previouslyFocusedElement && isSelectableInput(element) && select) {
+    element.select();
+  }
+}
+function focusFirst(candidates, { select = false } = {}) {
+  const previouslyFocusedElement = document.activeElement;
+  for (const candidate of candidates) {
+    focus(candidate, { select });
+    if (document.activeElement !== previouslyFocusedElement)
+      return true;
+  }
+}
+function findVisible(elements, container) {
+  for (const element of elements) {
+    if (!isElementHidden(element, container))
+      return element;
+  }
+}
+function getTabbableCandidates(container) {
+  const nodes = [];
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    acceptNode: (node) => {
+      const isHiddenInput3 = node.tagName === "INPUT" && node.type === "hidden";
+      if (node.disabled || node.hidden || isHiddenInput3)
+        return NodeFilter.FILTER_SKIP;
+      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  while (walker.nextNode())
+    nodes.push(walker.currentNode);
+  return nodes;
+}
+function getTabbableEdges(container) {
+  const candidates = getTabbableCandidates(container);
+  const first = findVisible(candidates, container);
+  const last = findVisible(candidates.reverse(), container);
+  return [first, last];
+}
+/*!
+* tabbable 6.5.0
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
+var candidateSelectors = ["input:not([inert]):not([inert] *)", "select:not([inert]):not([inert] *)", "textarea:not([inert]):not([inert] *)", "a[href]:not([inert]):not([inert] *)", "area[href]:not([inert]):not([inert] *)", "button:not([inert]):not([inert] *)", "[tabindex]:not(slot):not([inert]):not([inert] *)", "audio[controls]:not([inert]):not([inert] *)", "video[controls]:not([inert]):not([inert] *)", '[contenteditable]:not([contenteditable="false"]):not([inert]):not([inert] *)', "details>summary:first-of-type:not([inert]):not([inert] *)", "details:not([inert]):not([inert] *)"];
+var candidateSelector = /* @__PURE__ */ candidateSelectors.join(",");
+var NoElement = typeof Element === "undefined";
+var matches = NoElement ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
+  var _element$getRootNode;
+  return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
+} : function(element) {
+  return element === null || element === void 0 ? void 0 : element.ownerDocument;
+};
+var isContentEditable = function isContentEditable2(node) {
+  var _node$getAttribute2;
+  var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
+  return attValue === "" || attValue === "true";
+};
+var hasTabIndex = function hasTabIndex2(node) {
+  return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
+};
+var getTabIndex = function getTabIndex2(node) {
+  if (!node) {
+    throw new Error("No node provided");
+  }
+  if (node.tabIndex < 0) {
+    if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) {
+      return 0;
+    }
+  }
+  return node.tabIndex;
+};
+var isInput = function isInput2(node) {
+  return node.tagName === "INPUT";
+};
+var isHiddenInput = function isHiddenInput2(node) {
+  return isInput(node) && node.type === "hidden";
+};
+var isDetailsWithSummary = function isDetailsWithSummary2(node) {
+  var r = node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+    return child.tagName === "SUMMARY";
+  });
+  return r;
+};
+var getCheckedRadio = function getCheckedRadio2(nodes, form) {
+  for (var i = 0; i < nodes.length; i++) {
+    if (nodes[i].checked && nodes[i].form === form) {
+      return nodes[i];
+    }
+  }
+};
+var isTabbableRadio = function isTabbableRadio2(node) {
+  if (!node.name) {
+    return true;
+  }
+  var radioScope = node.form || getRootNode(node);
+  var queryRadios = function queryRadios2(name) {
+    return radioScope.querySelectorAll('input[type="radio"][name="' + name + '"]');
+  };
+  var radioSet;
+  if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") {
+    radioSet = queryRadios(window.CSS.escape(node.name));
+  } else {
+    try {
+      radioSet = queryRadios(node.name);
+    } catch (err) {
+      console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+      return false;
+    }
+  }
+  var checked = getCheckedRadio(radioSet, node.form);
+  return !checked || checked === node;
+};
+var isRadio = function isRadio2(node) {
+  return isInput(node) && node.type === "radio";
+};
+var isNonTabbableRadio = function isNonTabbableRadio2(node) {
+  return isRadio(node) && !isTabbableRadio(node);
+};
+var isNodeAttached = function isNodeAttached2(node) {
+  var _nodeRoot;
+  var nodeRoot = node && getRootNode(node);
+  var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
+  var attached = false;
+  if (nodeRoot && nodeRoot !== node) {
+    var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
+    attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
+    while (!attached && nodeRootHost) {
+      var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
+      nodeRoot = getRootNode(nodeRootHost);
+      nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
+      attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
+    }
+  }
+  return attached;
+};
+var isZeroArea = function isZeroArea2(node) {
+  var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+  return width === 0 && height === 0;
+};
+var isHidden = function isHidden2(node, _ref) {
+  var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
+  if (displayCheck === "full-native") {
+    if ("checkVisibility" in node) {
+      var visible = node.checkVisibility({
+        // Checking opacity might be desirable for some use cases, but natively,
+        // opacity zero elements _are_ focusable and tabbable.
+        checkOpacity: false,
+        opacityProperty: false,
+        contentVisibilityAuto: true,
+        visibilityProperty: true,
+        // This is an alias for `visibilityProperty`. Contemporary browsers
+        // support both. However, this alias has wider browser support (Chrome
+        // >= 105 and Firefox >= 106, vs. Chrome >= 121 and Firefox >= 122), so
+        // we include it anyway.
+        checkVisibilityCSS: true
+      });
+      return !visible;
+    }
+  }
+  var _getComputedStyle = getComputedStyle(node), visibility = _getComputedStyle.visibility;
+  if (visibility === "hidden" || visibility === "collapse") {
+    return true;
+  }
+  var isDirectSummary = matches.call(node, "details>summary:first-of-type");
+  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
+  if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
+    return true;
+  }
+  if (!displayCheck || displayCheck === "full" || // full-native can run this branch when it falls through in case
+  // Element#checkVisibility is unsupported
+  displayCheck === "full-native" || displayCheck === "legacy-full") {
+    if (typeof getShadowRoot === "function") {
+      var originalNode = node;
+      while (node) {
+        var parentElement = node.parentElement;
+        var rootNode = getRootNode(node);
+        if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) {
+          return isZeroArea(node);
+        } else if (node.assignedSlot) {
+          node = node.assignedSlot;
+        } else if (!parentElement && rootNode !== node.ownerDocument) {
+          node = rootNode.host;
+        } else {
+          node = parentElement;
+        }
+      }
+      node = originalNode;
+    }
+    if (isNodeAttached(node)) {
+      return !node.getClientRects().length;
+    }
+    if (displayCheck !== "legacy-full") {
+      return true;
+    }
+  } else if (displayCheck === "non-zero-area") {
+    return isZeroArea(node);
+  }
+  return false;
+};
+var isDisabledFromFieldset = function isDisabledFromFieldset2(node) {
+  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
+    var parentNode = node.parentElement;
+    while (parentNode) {
+      if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+        for (var i = 0; i < parentNode.children.length; i++) {
+          var child = parentNode.children.item(i);
+          if (child.tagName === "LEGEND") {
+            return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
+          }
+        }
+        return true;
+      }
+      parentNode = parentNode.parentElement;
+    }
+  }
+  return false;
+};
+var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable2(options, node) {
+  if (node.disabled || isHiddenInput(node) || isHidden(node, options) || // For a details element with a summary, the summary element gets the focus
+  isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
+    return false;
+  }
+  return true;
+};
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable2(options, node) {
+  if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {
+    return false;
+  }
+  return true;
+};
+var isTabbable = function isTabbable2(node, options) {
+  options = options || {};
+  if (!node) {
+    throw new Error("No node provided");
+  }
+  if (matches.call(node, candidateSelector) === false) {
+    return false;
+  }
+  return isNodeMatchingSelectorTabbable(options, node);
+};
+const AutoFocusOnMountEvent = new CustomEventDispatcher("focusScope.autoFocusOnMount", { bubbles: false, cancelable: true });
+const AutoFocusOnDestroyEvent = new CustomEventDispatcher("focusScope.autoFocusOnDestroy", { bubbles: false, cancelable: true });
+const FocusScopeContext = new Context("FocusScope");
+function useFocusScope({
+  id,
+  loop,
+  enabled,
+  onOpenAutoFocus,
+  onCloseAutoFocus,
+  forceMount
+}) {
+  const focusScopeStack = createFocusScopeStack();
+  const focusScope = createFocusScopeAPI();
+  const ref = box(null);
+  const ctx = FocusScopeContext.getOr({ ignoreCloseAutoFocus: false });
+  let lastFocusedElement = null;
+  useRefById({ id, ref, deps: () => enabled.current });
+  function manageFocus(event) {
+    if (focusScope.paused || !ref.current || focusScope.isHandlingFocus) return;
+    focusScope.isHandlingFocus = true;
+    try {
+      const target = event.target;
+      if (!isHTMLElement(target)) return;
+      const isWithinActiveScope = ref.current.contains(target);
+      if (event.type === "focusin") {
+        if (isWithinActiveScope) {
+          lastFocusedElement = target;
+        } else {
+          if (ctx.ignoreCloseAutoFocus) return;
+          focus(lastFocusedElement, { select: true });
+        }
+      } else if (event.type === "focusout") {
+        if (!isWithinActiveScope && !ctx.ignoreCloseAutoFocus) {
+          focus(lastFocusedElement, { select: true });
+        }
+      }
+    } finally {
+      focusScope.isHandlingFocus = false;
+    }
+  }
+  function handleMutations(mutations) {
+    if (!lastFocusedElement || !ref.current) return;
+    let elementWasRemoved = false;
+    for (const mutation of mutations) {
+      if (mutation.type === "childList" && mutation.removedNodes.length > 0) {
+        for (const removedNode of mutation.removedNodes) {
+          if (removedNode === lastFocusedElement) {
+            elementWasRemoved = true;
+            break;
+          }
+          if (removedNode.nodeType === Node.ELEMENT_NODE && removedNode.contains(lastFocusedElement)) {
+            elementWasRemoved = true;
+            break;
+          }
+        }
+      }
+      if (elementWasRemoved) break;
+    }
+    if (elementWasRemoved && ref.current && !ref.current.contains(document.activeElement)) {
+      focus(ref.current);
+    }
+  }
+  watch([() => ref.current, () => enabled.current], ([container, enabled2]) => {
+    if (!container || !enabled2) return;
+    const removeEvents = executeCallbacks(on(document, "focusin", manageFocus), on(document, "focusout", manageFocus));
+    const mutationObserver = new MutationObserver(handleMutations);
+    mutationObserver.observe(container, { childList: true, subtree: true, attributes: false });
+    return () => {
+      removeEvents();
+      mutationObserver.disconnect();
+    };
+  });
+  watch([() => forceMount.current, () => ref.current], ([forceMount2, container]) => {
+    if (forceMount2) return;
+    const prevFocusedElement = document.activeElement;
+    handleOpen(container, prevFocusedElement);
+    return () => {
+      if (!container) return;
+      handleClose(prevFocusedElement);
+    };
+  });
+  watch(
+    [
+      () => forceMount.current,
+      () => ref.current,
+      () => enabled.current
+    ],
+    ([forceMount2, container]) => {
+      if (!forceMount2) return;
+      const prevFocusedElement = document.activeElement;
+      handleOpen(container, prevFocusedElement);
+      return () => {
+        if (!container) return;
+        handleClose(prevFocusedElement);
+      };
+    }
+  );
+  function handleOpen(container, prevFocusedElement) {
+    if (!container) container = document.getElementById(id.current);
+    if (!container || !enabled.current) return;
+    focusScopeStack.add(focusScope);
+    const hasFocusedCandidate = container.contains(prevFocusedElement);
+    if (!hasFocusedCandidate) {
+      const mountEvent = AutoFocusOnMountEvent.createEvent();
+      onOpenAutoFocus.current(mountEvent);
+      if (!mountEvent.defaultPrevented) {
+        afterTick(() => {
+          if (!container) return;
+          const result = focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
+          if (!result) focus(container);
+        });
+      }
+    }
+  }
+  function handleClose(prevFocusedElement) {
+    const destroyEvent = AutoFocusOnDestroyEvent.createEvent();
+    onCloseAutoFocus.current?.(destroyEvent);
+    const shouldIgnore = ctx.ignoreCloseAutoFocus;
+    afterSleep(0, () => {
+      if (!destroyEvent.defaultPrevented && prevFocusedElement && !shouldIgnore) {
+        focus(isTabbable(prevFocusedElement) ? prevFocusedElement : document.body, { select: true });
+      }
+      focusScopeStack.remove(focusScope);
+    });
+  }
+  function handleKeydown(e) {
+    if (!enabled.current) return;
+    if (!loop.current && !enabled.current) return;
+    if (focusScope.paused) return;
+    const isTabKey = e.key === TAB && !e.ctrlKey && !e.altKey && !e.metaKey;
+    const focusedElement = document.activeElement;
+    if (!(isTabKey && focusedElement)) return;
+    const container = ref.current;
+    if (!container) return;
+    const [first, last] = getTabbableEdges(container);
+    const hasTabbableElementsInside = first && last;
+    if (!hasTabbableElementsInside) {
+      if (focusedElement === container) {
+        e.preventDefault();
+      }
+    } else {
+      if (!e.shiftKey && focusedElement === last) {
+        e.preventDefault();
+        if (loop.current) focus(first, { select: true });
+      } else if (e.shiftKey && focusedElement === first) {
+        e.preventDefault();
+        if (loop.current) focus(last, { select: true });
+      }
+    }
+  }
+  const props = derived(() => ({ id: id.current, tabindex: -1, onkeydown: handleKeydown }));
+  return {
+    get props() {
+      return props();
+    }
+  };
+}
+function Focus_scope($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      trapFocus = false,
+      loop = false,
+      onCloseAutoFocus = noop,
+      onOpenAutoFocus = noop,
+      focusScope,
+      forceMount = false
+    } = $$props;
+    const focusScopeState = useFocusScope({
+      enabled: box.with(() => trapFocus),
+      loop: box.with(() => loop),
+      onCloseAutoFocus: box.with(() => onCloseAutoFocus),
+      onOpenAutoFocus: box.with(() => onOpenAutoFocus),
+      id: box.with(() => id),
+      forceMount: box.with(() => forceMount)
+    });
+    focusScope?.($$renderer2, { props: focusScopeState.props });
+    $$renderer2.push(`<!---->`);
+  });
+}
+globalThis.bitsTextSelectionLayers ??= /* @__PURE__ */ new Map();
+class TextSelectionLayerState {
+  opts;
+  #unsubSelectionLock = noop;
+  #ref = box(null);
+  constructor(opts) {
+    this.opts = opts;
+    useRefById({
+      id: opts.id,
+      ref: this.#ref,
+      deps: () => this.opts.enabled.current
+    });
+    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(document, "pointerdown", this.#pointerdown), on(document, "pointerup", composeHandlers(this.#resetSelectionLock, this.opts.onPointerUp.current)));
+  }
+  #pointerdown = (e) => {
+    const node = this.#ref.current;
+    const target = e.target;
+    if (!isHTMLElement(node) || !isHTMLElement(target) || !this.opts.enabled.current) return;
+    if (!isHighestLayer(this) || !isOrContainsTarget(node, target)) return;
+    this.opts.onPointerDown.current(e);
+    if (e.defaultPrevented) return;
+    this.#unsubSelectionLock = preventTextSelectionOverflow(node);
+  };
+  #resetSelectionLock = () => {
+    this.#unsubSelectionLock();
+    this.#unsubSelectionLock = noop;
+  };
+}
+function useTextSelectionLayer(props) {
+  return new TextSelectionLayerState(props);
+}
+const getUserSelect = (node) => node.style.userSelect || node.style.webkitUserSelect;
+function preventTextSelectionOverflow(node) {
+  const body = document.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
+    } = $$props;
+    useTextSelectionLayer({
+      id: box.with(() => id),
+      onPointerDown: box.with(() => onPointerDown),
+      onPointerUp: box.with(() => onPointerUp),
+      enabled: box.with(() => enabled && preventOverflowTextSelection)
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+function createSharedHook(factory) {
+  let state = void 0;
+  return (...args) => {
+    return state;
+  };
+}
+const useBodyLockStackCount = createSharedHook();
+function useBodyScrollLock(initialState, restoreScrollDelay = () => null) {
+  useId();
+  useBodyLockStackCount();
+  return;
+}
+function Scroll_lock($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { preventScroll = true, restoreScrollDelay = null } = $$props;
+    useBodyScrollLock(preventScroll, () => restoreScrollDelay);
+  });
+}
+function shouldTrapFocus({ forceMount, present, trapFocus, open }) {
+  if (forceMount) {
+    return open && trapFocus;
+  }
+  return present && trapFocus && open;
+}
+function Dialog_overlay($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id = useId(),
+      forceMount = false,
+      child,
+      children,
+      ref = null,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const overlayState = useDialogOverlay({
+      id: box.with(() => id),
+      ref: box.with(() => ref, (v) => ref = v)
+    });
+    const mergedProps = derived(() => mergeProps(restProps, overlayState.props));
+    {
+      let presence = function($$renderer3) {
+        if (child) {
+          $$renderer3.push("<!--[0-->");
+          child($$renderer3, {
+            props: mergeProps(mergedProps()),
+            ...overlayState.snippetProps
+          });
+          $$renderer3.push(`<!---->`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          $$renderer3.push(`<div${attributes({ ...mergeProps(mergedProps()) })}>`);
+          children?.($$renderer3, overlayState.snippetProps);
+          $$renderer3.push(`<!----></div>`);
+        }
+        $$renderer3.push(`<!--]-->`);
+      };
+      Presence_layer($$renderer2, {
+        id,
+        present: overlayState.root.opts.open.current || forceMount,
+        presence
+      });
+    }
+    bind_props($$props, { ref });
+  });
+}
+function Dialog($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { open = false, onOpenChange = noop, children } = $$props;
+    useDialogRoot({
+      variant: box.with(() => "dialog"),
+      open: box.with(() => open, (v) => {
+        open = v;
+        onOpenChange(v);
+      })
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+    bind_props($$props, { open });
+  });
+}
+function Dialog_close($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      children,
+      child,
+      id = useId(),
+      ref = null,
+      disabled = false,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const closeState = useDialogClose({
+      variant: box.with(() => "close"),
+      id: box.with(() => id),
+      ref: box.with(() => ref, (v) => ref = v),
+      disabled: box.with(() => Boolean(disabled))
+    });
+    const mergedProps = derived(() => mergeProps(restProps, closeState.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 Dialog_content($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id = useId(),
+      children,
+      child,
+      ref = null,
+      forceMount = false,
+      onCloseAutoFocus = noop,
+      onOpenAutoFocus = noop,
+      onEscapeKeydown = noop,
+      onInteractOutside = noop,
+      trapFocus = true,
+      preventScroll = true,
+      restoreScrollDelay = null,
+      $$slots,
+      $$events,
+      ...restProps
+    } = $$props;
+    const contentState = useDialogContent({
+      id: box.with(() => id),
+      ref: box.with(() => ref, (v) => ref = v)
+    });
+    const mergedProps = derived(() => mergeProps(restProps, contentState.props));
+    {
+      let presence = function($$renderer3) {
+        {
+          let focusScope = function($$renderer4, { props: focusScopeProps }) {
+            Escape_layer($$renderer4, spread_props([
+              mergedProps(),
+              {
+                enabled: contentState.root.opts.open.current,
+                onEscapeKeydown: (e) => {
+                  onEscapeKeydown(e);
+                  if (e.defaultPrevented) return;
+                  contentState.root.handleClose();
+                },
+                children: ($$renderer5) => {
+                  Dismissible_layer($$renderer5, spread_props([
+                    mergedProps(),
+                    {
+                      enabled: contentState.root.opts.open.current,
+                      onInteractOutside: (e) => {
+                        onInteractOutside(e);
+                        if (e.defaultPrevented) return;
+                        contentState.root.handleClose();
+                      },
+                      children: ($$renderer6) => {
+                        Text_selection_layer($$renderer6, spread_props([
+                          mergedProps(),
+                          {
+                            enabled: contentState.root.opts.open.current,
+                            children: ($$renderer7) => {
+                              if (child) {
+                                $$renderer7.push("<!--[0-->");
+                                if (contentState.root.opts.open.current) {
+                                  $$renderer7.push("<!--[0-->");
+                                  Scroll_lock($$renderer7, { preventScroll, restoreScrollDelay });
+                                } else {
+                                  $$renderer7.push("<!--[-1-->");
+                                }
+                                $$renderer7.push(`<!--]--> `);
+                                child($$renderer7, {
+                                  props: mergeProps(mergedProps(), focusScopeProps),
+                                  ...contentState.snippetProps
+                                });
+                                $$renderer7.push(`<!---->`);
+                              } else {
+                                $$renderer7.push("<!--[-1-->");
+                                Scroll_lock($$renderer7, { preventScroll });
+                                $$renderer7.push(`<!----> <div${attributes({ ...mergeProps(mergedProps(), focusScopeProps) })}>`);
+                                children?.($$renderer7);
+                                $$renderer7.push(`<!----></div>`);
+                              }
+                              $$renderer7.push(`<!--]-->`);
+                            },
+                            $$slots: { default: true }
+                          }
+                        ]));
+                      },
+                      $$slots: { default: true }
+                    }
+                  ]));
+                },
+                $$slots: { default: true }
+              }
+            ]));
+          };
+          Focus_scope($$renderer3, {
+            loop: true,
+            trapFocus: shouldTrapFocus({
+              forceMount,
+              present: contentState.root.opts.open.current,
+              trapFocus,
+              open: contentState.root.opts.open.current
+            }),
+            onOpenAutoFocus,
+            id,
+            onCloseAutoFocus: (e) => {
+              onCloseAutoFocus(e);
+              if (e.defaultPrevented) return;
+              contentState.root.triggerNode?.focus();
+            },
+            focusScope
+          });
+        }
+      };
+      Presence_layer($$renderer2, spread_props([
+        mergedProps(),
+        {
+          forceMount,
+          present: contentState.root.opts.open.current || forceMount,
+          presence,
+          $$slots: { presence: true }
+        }
+      ]));
+    }
+    bind_props($$props, { ref });
+  });
+}
+function Modal($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      open = false,
+      title = "",
+      class: className = "",
+      overlayClass = "",
+      children,
+      footer,
+      underlay,
+      underlayOpen = false
+    } = $$props;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      if (Dialog) {
+        $$renderer3.push("<!--[-->");
+        Dialog($$renderer3, {
+          get open() {
+            return open;
+          },
+          set open($$value) {
+            open = $$value;
+            $$settled = false;
+          },
+          children: ($$renderer4) => {
+            if (Portal) {
+              $$renderer4.push("<!--[-->");
+              Portal($$renderer4, {
+                children: ($$renderer5) => {
+                  if (Dialog_overlay) {
+                    $$renderer5.push("<!--[-->");
+                    Dialog_overlay($$renderer5, { class: "fixed inset-0 z-50 bg-black/60 " + overlayClass });
+                    $$renderer5.push("<!--]-->");
+                  } else {
+                    $$renderer5.push("<!--[!-->");
+                    $$renderer5.push("<!--]-->");
+                  }
+                  $$renderer5.push(` `);
+                  if (Dialog_content) {
+                    $$renderer5.push("<!--[-->");
+                    Dialog_content($$renderer5, {
+                      class: "fixed left-1/2 top-1/2 z-50 max-h-[90vh] w-[95vw] max-w-6xl -translate-x-1/2 -translate-y-1/2 overflow-visible " + className,
+                      children: ($$renderer6) => {
+                        $$renderer6.push(`<div class="overflow-hidden rounded-lg border border-rc-gray-600 bg-rc-gray-800 shadow-xl"><div class="flex items-center justify-between border-b border-rc-gray-600 px-4 py-3">`);
+                        if (Dialog_title) {
+                          $$renderer6.push("<!--[-->");
+                          Dialog_title($$renderer6, {
+                            class: "text-lg font-semibold text-gray-100",
+                            children: ($$renderer7) => {
+                              $$renderer7.push(`<!---->${escape_html(title)}`);
+                            },
+                            $$slots: { default: true }
+                          });
+                          $$renderer6.push("<!--]-->");
+                        } else {
+                          $$renderer6.push("<!--[!-->");
+                          $$renderer6.push("<!--]-->");
+                        }
+                        $$renderer6.push(` `);
+                        if (Dialog_close) {
+                          $$renderer6.push("<!--[-->");
+                          Dialog_close($$renderer6, {
+                            class: "text-gray-400 hover:text-gray-200",
+                            "aria-label": "Close",
+                            children: ($$renderer7) => {
+                              $$renderer7.push(`<!---->✕`);
+                            },
+                            $$slots: { default: true }
+                          });
+                          $$renderer6.push("<!--]-->");
+                        } else {
+                          $$renderer6.push("<!--[!-->");
+                          $$renderer6.push("<!--]-->");
+                        }
+                        $$renderer6.push(`</div> <div class="rc-scroll max-h-[calc(90vh-7rem)] overflow-auto p-4">`);
+                        children?.($$renderer6);
+                        $$renderer6.push(`<!----></div> <div class="flex items-center justify-end gap-3 border-t border-rc-gray-600 px-4 py-3">`);
+                        footer?.($$renderer6);
+                        $$renderer6.push(`<!----></div></div> `);
+                        if (underlayOpen && underlay) {
+                          $$renderer6.push("<!--[0-->");
+                          $$renderer6.push(`<div class="modal-underlay absolute left-0 right-0 top-full -z-10 -mt-2 overflow-hidden rounded-b-lg border border-t-0 border-rc-gray-600 bg-rc-gray-800 px-4 pb-xs pt-2.5 shadow-xl svelte-ta60gp">`);
+                          underlay($$renderer6);
+                          $$renderer6.push(`<!----></div>`);
+                        } else {
+                          $$renderer6.push("<!--[-1-->");
+                        }
+                        $$renderer6.push(`<!--]-->`);
+                      },
+                      $$slots: { default: true }
+                    });
+                    $$renderer5.push("<!--]-->");
+                  } else {
+                    $$renderer5.push("<!--[!-->");
+                    $$renderer5.push("<!--]-->");
+                  }
+                }
+              });
+              $$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);
+    bind_props($$props, { open });
+  });
+}
+
+export { Modal as M };
+//# sourceMappingURL=Modal.js-BUDSUOER.js.map