@recombine-ai/bosun 0.16.1 → 0.16.2-cloud-2

package/build/server/chunks/Modal-CAzVFw5x.js

@@ -1,2595 +0,0 @@
-import { aA as bind_props, aD as hasContext, ax as getContext, _ as setContext, m as derived, aE as getAllContexts, aF as spread_props, aG as clsx, ay as attributes, k as escape_html } from './index-rHCWxLFZ.js';
-import { m as mount, u as unmount, t as tick } from './index-server-BMxlf3ZC.js';
-import { o as on } from './root-UeqiktJA.js';
-
-// http://www.w3.org/TR/CSS21/grammar.html
-// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027
-var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
-
-var NEWLINE_REGEX = /\n/g;
-var WHITESPACE_REGEX = /^\s*/;
-
-// declaration
-var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
-var COLON_REGEX = /^:\s*/;
-var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
-var SEMICOLON_REGEX = /^[;\s]*/;
-
-// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill
-var TRIM_REGEX = /^\s+|\s+$/g;
-
-// strings
-var NEWLINE = '\n';
-var FORWARD_SLASH = '/';
-var ASTERISK = '*';
-var EMPTY_STRING = '';
-
-// types
-var TYPE_COMMENT = 'comment';
-var TYPE_DECLARATION = 'declaration';
-
-/**
- * @param {String} style
- * @param {Object} [options]
- * @return {Object[]}
- * @throws {TypeError}
- * @throws {Error}
- */
-function index (style, options) {
-  if (typeof style !== 'string') {
-    throw new TypeError('First argument must be a string');
-  }
-
-  if (!style) return [];
-
-  options = options || {};
-
-  /**
-   * Positional.
-   */
-  var lineno = 1;
-  var column = 1;
-
-  /**
-   * Update lineno and column based on `str`.
-   *
-   * @param {String} str
-   */
-  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;
-  }
-
-  /**
-   * Mark position and patch `node.position`.
-   *
-   * @return {Function}
-   */
-  function position() {
-    var start = { line: lineno, column: column };
-    return function (node) {
-      node.position = new Position(start);
-      whitespace();
-      return node;
-    };
-  }
-
-  /**
-   * Store position information for a node.
-   *
-   * @constructor
-   * @property {Object} start
-   * @property {Object} end
-   * @property {undefined|String} source
-   */
-  function Position(start) {
-    this.start = start;
-    this.end = { line: lineno, column: column };
-    this.source = options.source;
-  }
-
-  /**
-   * Non-enumerable source string.
-   */
-  Position.prototype.content = style;
-
-  /**
-   * Error `msg`.
-   *
-   * @param {String} msg
-   * @throws {Error}
-   */
-  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;
-    }
-  }
-
-  /**
-   * Match `re` and return captures.
-   *
-   * @param {RegExp} re
-   * @return {undefined|Array}
-   */
-  function match(re) {
-    var m = re.exec(style);
-    if (!m) return;
-    var str = m[0];
-    updatePosition(str);
-    style = style.slice(str.length);
-    return m;
-  }
-
-  /**
-   * Parse whitespace.
-   */
-  function whitespace() {
-    match(WHITESPACE_REGEX);
-  }
-
-  /**
-   * Parse comments.
-   *
-   * @param {Object[]} [rules]
-   * @return {Object[]}
-   */
-  function comments(rules) {
-    var c;
-    rules = rules || [];
-    while ((c = comment())) {
-      if (c !== false) {
-        rules.push(c);
-      }
-    }
-    return rules;
-  }
-
-  /**
-   * Parse comment.
-   *
-   * @return {Object}
-   * @throws {Error}
-   */
-  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
-    });
-  }
-
-  /**
-   * Parse declaration.
-   *
-   * @return {Object}
-   * @throws {Error}
-   */
-  function declaration() {
-    var pos = position();
-
-    // prop
-    var prop = match(PROPERTY_REGEX);
-    if (!prop) return;
-    comment();
-
-    // :
-    if (!match(COLON_REGEX)) return error("property missing ':'");
-
-    // val
-    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;
-  }
-
-  /**
-   * Parse declarations.
-   *
-   * @return {Object[]}
-   */
-  function declarations() {
-    var decls = [];
-
-    comments(decls);
-
-    // declarations
-    var decl;
-    while ((decl = declaration())) {
-      if (decl !== false) {
-        decls.push(decl);
-        comments(decls);
-      }
-    }
-
-    return decls;
-  }
-
-  whitespace();
-  return declarations();
-}
-
-/**
- * Trim `str`.
- *
- * @param {String} str
- * @return {String}
- */
-function trim(str) {
-  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
-}
-
-/**
- * Parses inline style to object.
- *
- * @param style - Inline style.
- * @param iterator - Iterator.
- * @returns - Style object or null.
- *
- * @example Parsing inline style to object:
- *
- * ```js
- * import parse from 'style-to-object';
- * parse('line-height: 42;'); // { 'line-height': '42' }
- * ```
- */
-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;
-}
-
-/*!
-* tabbable 6.3.0
-* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
-*/
-// NOTE: separate `:not()` selectors has broader browser support than the newer
-//  `:not([inert], [inert] *)` (Feb 2023)
-// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes
-//  the entire query to fail, resulting in no nodes found, which will break a lot
-//  of things... so we have to rely on JS to identify nodes inside an inert container
-var candidateSelectors = ['input:not([inert])', 'select:not([inert])', 'textarea:not([inert])', 'a[href]:not([inert])', 'button:not([inert])', '[tabindex]:not(slot):not([inert])', 'audio[controls]:not([inert])', 'video[controls]:not([inert])', '[contenteditable]:not([contenteditable="false"]):not([inert])', 'details>summary:first-of-type:not([inert])', 'details: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;
-};
-
-/**
- * Determines if a node is inert or in an inert ancestor.
- * @param {Element} [node]
- * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to
- *  see if any of them are inert. If false, only `node` itself is considered.
- * @returns {boolean} True if inert itself or by way of being in an inert ancestor.
- *  False if `node` is falsy.
- */
-var _isInert = function isInert(node, lookUp) {
-  var _node$getAttribute;
-  if (lookUp === void 0) {
-    lookUp = true;
-  }
-  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`
-  //  JS API property; we have to check the attribute, which can either be empty or 'true';
-  //  if it's `null` (not specified) or 'false', it's an active element
-  var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, 'inert');
-  var inert = inertAtt === '' || inertAtt === 'true';
-
-  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`
-  //  if it weren't for `matches()` not being a function on shadow roots; the following
-  //  code works for any kind of node
-  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`
-  //  so it likely would not support `:is([inert] *)` either...
-  var result = inert || lookUp && node && _isInert(node.parentNode); // recursive
-
-  return result;
-};
-
-/**
- * Determines if a node's content is editable.
- * @param {Element} [node]
- * @returns True if it's content-editable; false if it's not or `node` is falsy.
- */
-var isContentEditable = function isContentEditable(node) {
-  var _node$getAttribute2;
-  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have
-  //  to use the attribute directly to check for this, which can either be empty or 'true';
-  //  if it's `null` (not specified) or 'false', it's a non-editable element
-  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';
-};
-
-/**
- * @private
- * Determines if the node has an explicitly specified `tabindex` attribute.
- * @param {HTMLElement} node
- * @returns {boolean} True if so; false if not.
- */
-var hasTabIndex = function hasTabIndex(node) {
-  return !isNaN(parseInt(node.getAttribute('tabindex'), 10));
-};
-
-/**
- * Determine the tab index of a given node.
- * @param {HTMLElement} node
- * @returns {number} Tab order (negative, 0, or positive number).
- * @throws {Error} If `node` is falsy.
- */
-var getTabIndex = function getTabIndex(node) {
-  if (!node) {
-    throw new Error('No node provided');
-  }
-  if (node.tabIndex < 0) {
-    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default
-    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,
-    // yet they are still part of the regular tab order; in FF, they get a default
-    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab
-    // order, consider their tab index to be 0.
-    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;
-    // so if they don't have a tabindex attribute specifically set, assume it's 0.
-    if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) {
-      return 0;
-    }
-  }
-  return node.tabIndex;
-};
-var isInput = function isInput(node) {
-  return node.tagName === 'INPUT';
-};
-var isHiddenInput = function isHiddenInput(node) {
-  return isInput(node) && node.type === 'hidden';
-};
-var isDetailsWithSummary = function isDetailsWithSummary(node) {
-  var r = node.tagName === 'DETAILS' && Array.prototype.slice.apply(node.children).some(function (child) {
-    return child.tagName === 'SUMMARY';
-  });
-  return r;
-};
-var getCheckedRadio = function getCheckedRadio(nodes, form) {
-  for (var i = 0; i < nodes.length; i++) {
-    if (nodes[i].checked && nodes[i].form === form) {
-      return nodes[i];
-    }
-  }
-};
-var isTabbableRadio = function isTabbableRadio(node) {
-  if (!node.name) {
-    return true;
-  }
-  var radioScope = node.form || getRootNode(node);
-  var queryRadios = function queryRadios(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) {
-      // eslint-disable-next-line no-console
-      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 isRadio(node) {
-  return isInput(node) && node.type === 'radio';
-};
-var isNonTabbableRadio = function isNonTabbableRadio(node) {
-  return isRadio(node) && !isTabbableRadio(node);
-};
-
-// determines if a node is ultimately attached to the window's document
-var isNodeAttached = function isNodeAttached(node) {
-  var _nodeRoot;
-  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise
-  //  (but NOT _the_ document; see second 'If' comment below for more).
-  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow
-  //  is attached, and the one we need to check if it's in the document or not (because the
-  //  shadow, and all nodes it contains, is never considered in the document since shadows
-  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,
-  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's
-  //  visibility, including all the nodes it contains). The host could be any normal node,
-  //  or a custom element (i.e. web component). Either way, that's the one that is considered
-  //  part of the document, not the shadow root, nor any of its children (i.e. the node being
-  //  tested).
-  // To further complicate things, we have to look all the way up until we find a shadow HOST
-  //  that is attached (or find none) because the node might be in nested shadows...
-  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the
-  //  document (per the docs) and while it's a Document-type object, that document does not
-  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer
-  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,
-  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when
-  //  node is actually detached.
-  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible
-  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed
-  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then
-  //  `ownerDocument` will be `null`, hence the optional chaining on it.
-  var nodeRoot = node && getRootNode(node);
-  var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
-
-  // in some cases, a detached node will return itself as the root instead of a document or
-  //  shadow root object, in which case, we shouldn't try to look further up the host chain
-  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;
-      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,
-      //  which means we need to get the host's host and check if that parent host is contained
-      //  in (i.e. attached to) the document
-      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 isZeroArea(node) {
-  var _node$getBoundingClie = node.getBoundingClientRect(),
-    width = _node$getBoundingClie.width,
-    height = _node$getBoundingClie.height;
-  return width === 0 && height === 0;
-};
-var isHidden = function isHidden(node, _ref) {
-  var displayCheck = _ref.displayCheck,
-    getShadowRoot = _ref.getShadowRoot;
-  if (displayCheck === 'full-native') {
-    if ('checkVisibility' in node) {
-      // Chrome >= 105, Edge >= 105, Firefox >= 106, Safari >= 17.4
-      // @see https://developer.mozilla.org/en-US/docs/Web/API/Element/checkVisibility#browser_compatibility
-      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;
-    }
-    // Fall through to manual visibility checks
-  }
-
-  // NOTE: visibility will be `undefined` if node is detached from the document
-  //  (see notes about this further down), which means we will consider it visible
-  //  (this is legacy behavior from a very long way back)
-  // NOTE: we check this regardless of `displayCheck="none"` because this is a
-  //  _visibility_ check, not a _display_ check
-  if (getComputedStyle(node).visibility === 'hidden') {
-    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') {
-      // figure out if we should consider the node to be in an undisclosed shadow and use the
-      //  'non-zero-area' fallback
-      var originalNode = node;
-      while (node) {
-        var parentElement = node.parentElement;
-        var rootNode = getRootNode(node);
-        if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true // check if there's an undisclosed shadow
-        ) {
-          // node has an undisclosed shadow which means we can only treat it as a black box, so we
-          //  fall back to a non-zero-area test
-          return isZeroArea(node);
-        } else if (node.assignedSlot) {
-          // iterate up slot
-          node = node.assignedSlot;
-        } else if (!parentElement && rootNode !== node.ownerDocument) {
-          // cross shadow boundary
-          node = rootNode.host;
-        } else {
-          // iterate up normal dom
-          node = parentElement;
-        }
-      }
-      node = originalNode;
-    }
-    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support
-    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or
-    //  it might be a falsy value, which means shadow DOM support is disabled
-
-    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)
-    //  now we can just test to see if it would normally be visible or not, provided it's
-    //  attached to the main document.
-    // NOTE: We must consider case where node is inside a shadow DOM and given directly to
-    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.
-
-    if (isNodeAttached(node)) {
-      // this works wherever the node is: if there's at least one client rect, it's
-      //  somehow displayed; it also covers the CSS 'display: contents' case where the
-      //  node itself is hidden in place of its contents; and there's no need to search
-      //  up the hierarchy either
-      return !node.getClientRects().length;
-    }
-
-    // Else, the node isn't attached to the document, which means the `getClientRects()`
-    //  API will __always__ return zero rects (this can happen, for example, if React
-    //  is used to render nodes onto a detached tree, as confirmed in this thread:
-    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)
-    //
-    // It also means that even window.getComputedStyle(node).display will return `undefined`
-    //  because styles are only computed for nodes that are in the document.
-    //
-    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable
-    //  somehow. Though it was never stated officially, anyone who has ever used tabbable
-    //  APIs on nodes in detached containers has actually implicitly used tabbable in what
-    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck="none"` mode -- essentially
-    //  considering __everything__ to be visible because of the innability to determine styles.
-    //
-    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached
-    //  nodes as visible with the 'none' fallback.__
-    if (displayCheck !== 'legacy-full') {
-      return true; // hidden
-    }
-    // else, fallback to 'none' mode and consider the node visible
-  } else if (displayCheck === 'non-zero-area') {
-    // NOTE: Even though this tests that the node's client rect is non-zero to determine
-    //  whether it's displayed, and that a detached node will __always__ have a zero-area
-    //  client rect, we don't special-case for whether the node is attached or not. In
-    //  this mode, we do want to consider nodes that have a zero area to be hidden at all
-    //  times, and that includes attached or not.
-    return isZeroArea(node);
-  }
-
-  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume
-  //  it's visible
-  return false;
-};
-
-// form fields (nested) inside a disabled fieldset are not focusable/tabbable
-//  unless they are in the _first_ <legend> element of the top-most disabled
-//  fieldset
-var isDisabledFromFieldset = function isDisabledFromFieldset(node) {
-  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
-    var parentNode = node.parentElement;
-    // check if `node` is contained in a disabled <fieldset>
-    while (parentNode) {
-      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {
-        // look for the first <legend> among the children of the disabled <fieldset>
-        for (var i = 0; i < parentNode.children.length; i++) {
-          var child = parentNode.children.item(i);
-          // when the first <legend> (in document order) is found
-          if (child.tagName === 'LEGEND') {
-            // if its parent <fieldset> is not nested in another disabled <fieldset>,
-            // return whether `node` is a descendant of its first <legend>
-            return matches.call(parentNode, 'fieldset[disabled] *') ? true : !child.contains(node);
-          }
-        }
-        // the disabled <fieldset> containing `node` has no <legend>
-        return true;
-      }
-      parentNode = parentNode.parentElement;
-    }
-  }
-
-  // else, node's tabbable/focusable state should not be affected by a fieldset's
-  //  enabled/disabled state
-  return false;
-};
-var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {
-  if (node.disabled ||
-  // we must do an inert look up to filter out any elements inside an inert ancestor
-  //  because we're limited in the type of selectors we can use in JSDom (see related
-  //  note related to `candidateSelectors`)
-  _isInert(node) || 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 isNodeMatchingSelectorTabbable(options, node) {
-  if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {
-    return false;
-  }
-  return true;
-};
-var isTabbable = function isTabbable(node, options) {
-  options = options || {};
-  if (!node) {
-    throw new Error('No node provided');
-  }
-  if (matches.call(node, candidateSelector) === false) {
-    return false;
-  }
-  return isNodeMatchingSelectorTabbable(options, node);
-};
-
-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);
-      }
-    }
-  };
-}
-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(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;
-      }
-    }
-  }
-  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 = defaultWindow, document: document2 = window?.document } = options;
-    if (window === 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 }) {
-  watch([() => id.current, deps], ([_id]) => {
-    const rootNode = getRootNode?.() ?? 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 isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
-      if (node.disabled || node.hidden || isHiddenInput)
-        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];
-}
-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 = "",
-      children,
-      footer
-    } = $$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" });
-                    $$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-hidden rounded-lg border border-rc-gray-600 bg-rc-gray-800 shadow-xl " + className,
-                      children: ($$renderer6) => {
-                        $$renderer6.push(`<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>`);
-                      },
-                      $$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-CAzVFw5x.js.map