@selvajs/selva 4.6.0-beta.0 → 4.6.0-beta.2

package/build/server/chunks/chunks/scroll-lock.js-BzUpWsKI.js

@@ -0,0 +1,2854 @@
+import { al as getAllContexts, R as derived } from './renderer.js-CtAppMtw.js';
+import { t as tick, m as mount, u as unmount } from './index-server2.js-BXzJu7TP.js';
+import { w as watch, n as noop, C as Context, i as isBrowser, E as ESCAPE, a as isHTMLElement$1, b as isIOS, c as isElementOrSVGElement, S as SPACE, d as ENTER, A as ARROW_DOWN, R as RovingFocusGroup, e as isElement, T as TAB, P as PAGE_UP, H as HOME, f as ARROW_UP, g as PAGE_DOWN, h as END, j as isSelectableInput, k as ARROW_LEFT, l as ARROW_RIGHT } from './noop.js-CKHdXpdB.js';
+import 'clsx';
+import { a as boxWith, s as simpleBox, f as createBitsAttrs, g as executeCallbacks, h as composeHandlers, j as isObject, k as attachRef, l as getDataOpenClosed, m as boolToEmptyStrOrUndef, n as boolToStr, o as getDataTransitionAttrs, p as mergeProps } from './create-id.js-9t6eRojp.js';
+import { o as on } from './events.js-CzuTO9ni.js';
+import { S as SvelteMap } from './index-server.js-DMc-UvjC.js';
+
+function afterSleep(ms, cb) {
+  return setTimeout(cb, ms);
+}
+function afterTick(fn) {
+  tick().then(fn);
+}
+const ELEMENT_NODE = 1;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_FRAGMENT_NODE = 11;
+function isHTMLElement(node) {
+  return isObject(node) && node.nodeType === ELEMENT_NODE && typeof node.nodeName === "string";
+}
+function isDocument(node) {
+  return isObject(node) && node.nodeType === DOCUMENT_NODE;
+}
+function isWindow(node) {
+  return isObject(node) && node.constructor?.name === "VisualViewport";
+}
+function isNode(node) {
+  return isObject(node) && node.nodeType !== void 0;
+}
+function isShadowRoot(node) {
+  return isNode(node) && node.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in node;
+}
+function contains(parent, child) {
+  if (!parent || !child)
+    return false;
+  if (!isHTMLElement(parent) || !isHTMLElement(child))
+    return false;
+  const rootNode = child.getRootNode?.();
+  if (parent === child)
+    return true;
+  if (parent.contains(child))
+    return true;
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next2 = child;
+    while (next2) {
+      if (parent === next2)
+        return true;
+      next2 = next2.parentNode || next2.host;
+    }
+  }
+  return false;
+}
+function getDocument(node) {
+  if (isDocument(node))
+    return node;
+  if (isWindow(node))
+    return node.document;
+  return node?.ownerDocument ?? document;
+}
+function getWindow(node) {
+  if (isShadowRoot(node))
+    return getWindow(node.host);
+  if (isDocument(node))
+    return node.defaultView ?? window;
+  if (isHTMLElement(node))
+    return node.ownerDocument?.defaultView ?? window;
+  return window;
+}
+function getActiveElement(rootNode) {
+  let activeElement = rootNode.activeElement;
+  while (activeElement?.shadowRoot) {
+    const el = activeElement.shadowRoot.activeElement;
+    if (el === activeElement)
+      break;
+    else
+      activeElement = el;
+  }
+  return activeElement;
+}
+class DOMContext {
+  element;
+  #root = derived(() => {
+    if (!this.element.current) return document;
+    const rootNode = this.element.current.getRootNode() ?? document;
+    return rootNode;
+  });
+  get root() {
+    return this.#root();
+  }
+  set root($$value) {
+    return this.#root($$value);
+  }
+  constructor(element) {
+    if (typeof element === "function") {
+      this.element = boxWith(element);
+    } else {
+      this.element = element;
+    }
+  }
+  getDocument = () => {
+    return getDocument(this.root);
+  };
+  getWindow = () => {
+    return this.getDocument().defaultView ?? window;
+  };
+  getActiveElement = () => {
+    return getActiveElement(this.root);
+  };
+  isActiveElement = (node) => {
+    return node === this.getActiveElement();
+  };
+  getElementById(id) {
+    return this.root.getElementById(id);
+  }
+  querySelector = (selector) => {
+    if (!this.root) return null;
+    return this.root.querySelector(selector);
+  };
+  querySelectorAll = (selector) => {
+    if (!this.root) return [];
+    return this.root.querySelectorAll(selector);
+  };
+  setTimeout = (callback, delay) => {
+    return this.getWindow().setTimeout(callback, delay);
+  };
+  clearTimeout = (timeoutId) => {
+    return this.getWindow().clearTimeout(timeoutId);
+  };
+}
+class AnimationsComplete {
+  #opts;
+  #currentFrame = null;
+  #observer = null;
+  #runId = 0;
+  constructor(opts) {
+    this.#opts = opts;
+  }
+  #cleanup() {
+    if (this.#currentFrame !== null) {
+      window.cancelAnimationFrame(this.#currentFrame);
+      this.#currentFrame = null;
+    }
+    this.#observer?.disconnect();
+    this.#observer = null;
+    this.#runId++;
+  }
+  run(fn) {
+    this.#cleanup();
+    const node = this.#opts.ref.current;
+    if (!node)
+      return;
+    if (typeof node.getAnimations !== "function") {
+      this.#executeCallback(fn);
+      return;
+    }
+    const runId = this.#runId;
+    const executeIfCurrent = () => {
+      if (runId !== this.#runId)
+        return;
+      this.#executeCallback(fn);
+    };
+    const waitForAnimations = () => {
+      if (runId !== this.#runId)
+        return;
+      const animations = node.getAnimations();
+      if (animations.length === 0) {
+        executeIfCurrent();
+        return;
+      }
+      Promise.all(animations.map((animation) => animation.finished)).then(() => {
+        executeIfCurrent();
+      }).catch(() => {
+        if (runId !== this.#runId)
+          return;
+        const currentAnimations = node.getAnimations();
+        const hasRunningAnimations = currentAnimations.some((animation) => animation.pending || animation.playState !== "finished");
+        if (hasRunningAnimations) {
+          waitForAnimations();
+          return;
+        }
+        executeIfCurrent();
+      });
+    };
+    const requestWaitForAnimations = () => {
+      this.#currentFrame = window.requestAnimationFrame(() => {
+        this.#currentFrame = null;
+        waitForAnimations();
+      });
+    };
+    if (!this.#opts.afterTick.current) {
+      requestWaitForAnimations();
+      return;
+    }
+    this.#currentFrame = window.requestAnimationFrame(() => {
+      this.#currentFrame = null;
+      const startingStyleAttr = "data-starting-style";
+      if (!node.hasAttribute(startingStyleAttr)) {
+        requestWaitForAnimations();
+        return;
+      }
+      this.#observer = new MutationObserver(() => {
+        if (runId !== this.#runId)
+          return;
+        if (node.hasAttribute(startingStyleAttr))
+          return;
+        this.#observer?.disconnect();
+        this.#observer = null;
+        requestWaitForAnimations();
+      });
+      this.#observer.observe(node, {
+        attributes: true,
+        attributeFilter: [startingStyleAttr]
+      });
+    });
+  }
+  #executeCallback(fn) {
+    const execute = () => {
+      fn();
+    };
+    if (this.#opts.afterTick) {
+      afterTick(execute);
+    } else {
+      execute();
+    }
+  }
+}
+class PresenceManager {
+  #opts;
+  #enabled;
+  #afterAnimations;
+  #shouldRender = false;
+  #transitionStatus = void 0;
+  #hasMounted = false;
+  #transitionFrame = null;
+  constructor(opts) {
+    this.#opts = opts;
+    this.#shouldRender = opts.open.current;
+    this.#enabled = opts.enabled ?? true;
+    this.#afterAnimations = new AnimationsComplete({ ref: this.#opts.ref, afterTick: this.#opts.open });
+    watch(() => this.#opts.open.current, (isOpen) => {
+      if (!this.#hasMounted) {
+        this.#hasMounted = true;
+        return;
+      }
+      this.#clearTransitionFrame();
+      if (!isOpen && this.#opts.shouldSkipExitAnimation?.()) {
+        this.#shouldRender = false;
+        this.#transitionStatus = void 0;
+        this.#opts.onComplete?.();
+        return;
+      }
+      if (isOpen) this.#shouldRender = true;
+      this.#transitionStatus = isOpen ? "starting" : "ending";
+      if (isOpen) {
+        this.#transitionFrame = window.requestAnimationFrame(() => {
+          this.#transitionFrame = null;
+          if (this.#opts.open.current) {
+            this.#transitionStatus = void 0;
+          }
+        });
+      }
+      if (!this.#enabled) {
+        if (!isOpen) {
+          this.#shouldRender = false;
+        }
+        this.#transitionStatus = void 0;
+        this.#opts.onComplete?.();
+        return;
+      }
+      this.#afterAnimations.run(() => {
+        if (isOpen === this.#opts.open.current) {
+          if (!this.#opts.open.current) {
+            this.#shouldRender = false;
+          }
+          this.#transitionStatus = void 0;
+          this.#opts.onComplete?.();
+        }
+      });
+    });
+  }
+  get shouldRender() {
+    return this.#shouldRender;
+  }
+  get transitionStatus() {
+    return this.#transitionStatus;
+  }
+  #clearTransitionFrame() {
+    if (this.#transitionFrame === null) return;
+    window.cancelAnimationFrame(this.#transitionFrame);
+    this.#transitionFrame = null;
+  }
+}
+const BitsConfigContext = new Context("BitsConfig");
+function getBitsConfig() {
+  const fallback = new BitsConfigState(null, {});
+  return BitsConfigContext.getOr(fallback).opts;
+}
+class BitsConfigState {
+  opts;
+  constructor(parent, opts) {
+    const resolveConfigOption = createConfigResolver(parent, opts);
+    this.opts = {
+      defaultPortalTo: resolveConfigOption((config) => config.defaultPortalTo),
+      defaultLocale: resolveConfigOption((config) => config.defaultLocale)
+    };
+  }
+}
+function createConfigResolver(parent, currentOpts) {
+  return (getter) => {
+    const configOption = boxWith(() => {
+      const value = getter(currentOpts)?.current;
+      if (value !== void 0)
+        return value;
+      if (parent === null)
+        return void 0;
+      return getter(parent.opts)?.current;
+    });
+    return configOption;
+  };
+}
+function createPropResolver(configOption, fallback) {
+  return (getProp) => {
+    const config = getBitsConfig();
+    return boxWith(() => {
+      const propValue = getProp();
+      if (propValue !== void 0)
+        return propValue;
+      const option = configOption(config).current;
+      if (option !== void 0)
+        return option;
+      return fallback;
+    });
+  };
+}
+const resolvePortalToProp = createPropResolver((config) => config.defaultPortalTo, "body");
+function Portal($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { to: toProp, children, disabled } = $$props;
+    const to = resolvePortalToProp(() => toProp);
+    getAllContexts();
+    let target = derived(getTarget);
+    function getTarget() {
+      if (!isBrowser || disabled) return null;
+      let localTarget = null;
+      if (typeof to.current === "string") {
+        const target2 = document.querySelector(to.current);
+        localTarget = target2;
+      } else {
+        localTarget = to.current;
+      }
+      return localTarget;
+    }
+    let instance;
+    function unmountInstance() {
+      if (instance) {
+        unmount();
+        instance = null;
+      }
+    }
+    watch([() => target(), () => disabled], ([target2, disabled2]) => {
+      if (!target2 || disabled2) {
+        unmountInstance();
+        return;
+      }
+      instance = mount();
+      return () => {
+        unmountInstance();
+      };
+    });
+    if (disabled) {
+      $$renderer2.push("<!--[0-->");
+      children?.($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+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;
+}
+const SELECTION_KEYS = [ENTER, SPACE];
+const FIRST_KEYS = [ARROW_DOWN, PAGE_UP, HOME];
+const LAST_KEYS = [ARROW_UP, PAGE_DOWN, END];
+const FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
+const SUB_OPEN_KEYS = {
+  ltr: [...SELECTION_KEYS, ARROW_RIGHT],
+  rtl: [...SELECTION_KEYS, ARROW_LEFT]
+};
+const SUB_CLOSE_KEYS = {
+  ltr: [ARROW_LEFT],
+  rtl: [ARROW_RIGHT]
+};
+function isMouseEvent(event) {
+  return event.pointerType === "mouse";
+}
+function focus(element, { select = false } = {}) {
+  if (!element || !element.focus)
+    return;
+  const doc = getDocument(element);
+  if (doc.activeElement === element)
+    return;
+  const previouslyFocusedElement = doc.activeElement;
+  element.focus({ preventScroll: true });
+  if (element !== previouslyFocusedElement && isSelectableInput(element) && select) {
+    element.select();
+  }
+}
+function focusFirst(candidates, { select = false } = {}, getActiveElement2) {
+  const previouslyFocusedElement = getActiveElement2();
+  for (const candidate of candidates) {
+    focus(candidate, { select });
+    if (getActiveElement2() !== previouslyFocusedElement)
+      return true;
+  }
+}
+let isUsingKeyboard = false;
+class IsUsingKeyboard {
+  static _refs = 0;
+  // Reference counting to avoid multiple listeners.
+  static _cleanup;
+  constructor() {
+  }
+  get current() {
+    return isUsingKeyboard;
+  }
+  set current(value) {
+    isUsingKeyboard = value;
+  }
+}
+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 _isInert = function isInert(node, lookUp) {
+  var _node$getAttribute;
+  if (lookUp === void 0) {
+    lookUp = true;
+  }
+  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";
+  var result = inert || lookUp && node && // closest does not exist on shadow roots, so we fall back to a manual
+  // lookup upward, in case it is not defined.
+  (typeof node.closest === "function" ? node.closest("[inert]") : _isInert(node.parentNode));
+  return result;
+};
+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 getCandidates = function getCandidates2(el, includeContainer, filter) {
+  if (_isInert(el)) {
+    return [];
+  }
+  var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+  if (includeContainer && matches.call(el, candidateSelector)) {
+    candidates.unshift(el);
+  }
+  candidates = candidates.filter(filter);
+  return candidates;
+};
+var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+  var candidates = [];
+  var elementsToCheck = Array.from(elements);
+  while (elementsToCheck.length) {
+    var element = elementsToCheck.shift();
+    if (_isInert(element, false)) {
+      continue;
+    }
+    if (element.tagName === "SLOT") {
+      var assigned = element.assignedElements();
+      var content = assigned.length ? assigned : element.children;
+      var nestedCandidates = _getCandidatesIteratively(content, true, options);
+      if (options.flatten) {
+        candidates.push.apply(candidates, nestedCandidates);
+      } else {
+        candidates.push({
+          scopeParent: element,
+          candidates: nestedCandidates
+        });
+      }
+    } else {
+      var validCandidate = matches.call(element, candidateSelector);
+      if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {
+        candidates.push(element);
+      }
+      var shadowRoot = element.shadowRoot || // check for an undisclosed shadow
+      typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
+      var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
+      if (shadowRoot && validShadowRoot) {
+        var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+        if (options.flatten) {
+          candidates.push.apply(candidates, _nestedCandidates);
+        } else {
+          candidates.push({
+            scopeParent: element,
+            candidates: _nestedCandidates
+          });
+        }
+      } else {
+        elementsToCheck.unshift.apply(elementsToCheck, element.children);
+      }
+    }
+  }
+  return candidates;
+};
+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 getSortOrderTabIndex = function getSortOrderTabIndex2(node, isScope) {
+  var tabIndex = getTabIndex(node);
+  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {
+    return 0;
+  }
+  return tabIndex;
+};
+var sortOrderedTabbables = function sortOrderedTabbables2(a, b) {
+  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.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 isShadowRootTabbable = function isShadowRootTabbable2(shadowHostNode) {
+  var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
+  if (isNaN(tabIndex) || tabIndex >= 0) {
+    return true;
+  }
+  return false;
+};
+var _sortByOrder = function sortByOrder(candidates) {
+  var regularTabbables = [];
+  var orderedTabbables = [];
+  candidates.forEach(function(item, i) {
+    var isScope = !!item.scopeParent;
+    var element = isScope ? item.scopeParent : item;
+    var candidateTabindex = getSortOrderTabIndex(element, isScope);
+    var elements = isScope ? _sortByOrder(item.candidates) : element;
+    if (candidateTabindex === 0) {
+      isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
+    } else {
+      orderedTabbables.push({
+        documentOrder: i,
+        tabIndex: candidateTabindex,
+        item,
+        isScope,
+        content: elements
+      });
+    }
+  });
+  return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
+    sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
+    return acc;
+  }, []).concat(regularTabbables);
+};
+var tabbable = function tabbable2(container, options) {
+  options = options || {};
+  var candidates;
+  if (options.getShadowRoot) {
+    candidates = _getCandidatesIteratively([container], options.includeContainer, {
+      filter: isNodeMatchingSelectorTabbable.bind(null, options),
+      flatten: false,
+      getShadowRoot: options.getShadowRoot,
+      shadowRootFilter: isShadowRootTabbable
+    });
+  } else {
+    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+  }
+  return _sortByOrder(candidates);
+};
+var focusable = function focusable2(container, options) {
+  options = options || {};
+  var candidates;
+  if (options.getShadowRoot) {
+    candidates = _getCandidatesIteratively([container], options.includeContainer, {
+      filter: isNodeMatchingSelectorFocusable.bind(null, options),
+      flatten: true,
+      getShadowRoot: options.getShadowRoot
+    });
+  } else {
+    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+  }
+  return candidates;
+};
+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);
+};
+var focusableCandidateSelector = /* @__PURE__ */ candidateSelectors.concat("iframe:not([inert]):not([inert] *)").join(",");
+var isFocusable = function isFocusable2(node, options) {
+  options = options || {};
+  if (!node) {
+    throw new Error("No node provided");
+  }
+  if (matches.call(node, focusableCandidateSelector) === false) {
+    return false;
+  }
+  return isNodeMatchingSelectorFocusable(options, node);
+};
+function getTabbableOptions() {
+  return {
+    getShadowRoot: true,
+    displayCheck: (
+      // JSDOM does not support the `tabbable` library. To solve this we can
+      // check if `ResizeObserver` is a real function (not polyfilled), which
+      // determines if the current environment is JSDOM-like.
+      typeof ResizeObserver === "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+    )
+  };
+}
+function getTabbableFrom(currentNode, direction) {
+  if (!isTabbable(currentNode, getTabbableOptions())) {
+    return getTabbableFromFocusable(currentNode, direction);
+  }
+  const doc = getDocument(currentNode);
+  const allTabbable = tabbable(doc.body, getTabbableOptions());
+  if (direction === "prev")
+    allTabbable.reverse();
+  const activeIndex = allTabbable.indexOf(currentNode);
+  if (activeIndex === -1)
+    return doc.body;
+  const nextTabbableElements = allTabbable.slice(activeIndex + 1);
+  return nextTabbableElements[0];
+}
+function getTabbableFromFocusable(currentNode, direction) {
+  const doc = getDocument(currentNode);
+  if (!isFocusable(currentNode, getTabbableOptions()))
+    return doc.body;
+  const allFocusable = focusable(doc.body, getTabbableOptions());
+  if (direction === "prev")
+    allFocusable.reverse();
+  const activeIndex = allFocusable.indexOf(currentNode);
+  if (activeIndex === -1)
+    return doc.body;
+  const nextFocusableElements = allFocusable.slice(activeIndex + 1);
+  return nextFocusableElements.find((node) => isTabbable(node, getTabbableOptions())) ?? doc.body;
+}
+function isValidIndex(index, arr) {
+  return index >= 0 && index < arr.length;
+}
+function next(array, index, loop = true) {
+  if (array.length === 0 || index < 0 || index >= array.length)
+    return;
+  if (array.length === 1 && index === 0)
+    return array[0];
+  if (index === array.length - 1)
+    return loop ? array[0] : void 0;
+  return array[index + 1];
+}
+function prev(array, index, loop = true) {
+  if (array.length === 0 || index < 0 || index >= array.length)
+    return;
+  if (array.length === 1 && index === 0)
+    return array[0];
+  if (index === 0)
+    return loop ? array[array.length - 1] : void 0;
+  return array[index - 1];
+}
+function forward(array, index, increment, loop = true) {
+  if (array.length === 0 || index < 0 || index >= array.length)
+    return;
+  let targetIndex = index + increment;
+  if (loop) {
+    targetIndex = (targetIndex % array.length + array.length) % array.length;
+  } else {
+    targetIndex = Math.max(0, Math.min(targetIndex, array.length - 1));
+  }
+  return array[targetIndex];
+}
+function backward(array, index, decrement, loop = true) {
+  if (array.length === 0 || index < 0 || index >= array.length)
+    return;
+  let targetIndex = index - decrement;
+  if (loop) {
+    targetIndex = (targetIndex % array.length + array.length) % array.length;
+  } else {
+    targetIndex = Math.max(0, Math.min(targetIndex, array.length - 1));
+  }
+  return array[targetIndex];
+}
+function getNextMatch(values, search, currentMatch) {
+  const lowerSearch = search.toLowerCase();
+  if (lowerSearch.endsWith(" ")) {
+    const searchWithoutSpace = lowerSearch.slice(0, -1);
+    const matchesWithoutSpace = values.filter((value) => value.toLowerCase().startsWith(searchWithoutSpace));
+    if (matchesWithoutSpace.length <= 1) {
+      return getNextMatch(values, searchWithoutSpace, currentMatch);
+    }
+    const currentMatchLowercase = currentMatch?.toLowerCase();
+    if (currentMatchLowercase && currentMatchLowercase.startsWith(searchWithoutSpace) && currentMatchLowercase.charAt(searchWithoutSpace.length) === " " && search.trim() === searchWithoutSpace) {
+      return currentMatch;
+    }
+    const spacedMatches = values.filter((value) => value.toLowerCase().startsWith(lowerSearch));
+    if (spacedMatches.length > 0) {
+      const currentMatchIndex2 = currentMatch ? values.indexOf(currentMatch) : -1;
+      let wrappedMatches = wrapArray(spacedMatches, Math.max(currentMatchIndex2, 0));
+      const nextMatch2 = wrappedMatches.find((match) => match !== currentMatch);
+      return nextMatch2 || currentMatch;
+    }
+  }
+  const isRepeated = search.length > 1 && Array.from(search).every((char) => char === search[0]);
+  const normalizedSearch = isRepeated ? search[0] : search;
+  const normalizedLowerSearch = normalizedSearch.toLowerCase();
+  const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
+  let wrappedValues = wrapArray(values, Math.max(currentMatchIndex, 0));
+  const excludeCurrentMatch = normalizedSearch.length === 1;
+  if (excludeCurrentMatch)
+    wrappedValues = wrappedValues.filter((v) => v !== currentMatch);
+  const nextMatch = wrappedValues.find((value) => value?.toLowerCase().startsWith(normalizedLowerSearch));
+  return nextMatch !== currentMatch ? nextMatch : void 0;
+}
+function wrapArray(array, startIndex) {
+  return array.map((_, index) => array[(startIndex + index) % array.length]);
+}
+const defaultOptions = { afterMs: 1e4, onChange: noop };
+function boxAutoReset(defaultValue, options) {
+  const { afterMs, onChange, getWindow: getWindow2 } = { ...defaultOptions, ...options };
+  let timeout = null;
+  let value = defaultValue;
+  function resetAfter() {
+    return getWindow2().setTimeout(
+      () => {
+        value = defaultValue;
+        onChange?.(defaultValue);
+      },
+      afterMs
+    );
+  }
+  return boxWith(() => value, (v) => {
+    value = v;
+    onChange?.(v);
+    if (timeout) getWindow2().clearTimeout(timeout);
+    timeout = resetAfter();
+  });
+}
+class DOMTypeahead {
+  #opts;
+  #search;
+  #onMatch = derived(() => {
+    if (this.#opts.onMatch) return this.#opts.onMatch;
+    return (node) => node.focus();
+  });
+  #getCurrentItem = derived(() => {
+    if (this.#opts.getCurrentItem) return this.#opts.getCurrentItem;
+    return this.#opts.getActiveElement;
+  });
+  constructor(opts) {
+    this.#opts = opts;
+    this.#search = boxAutoReset("", { afterMs: 1e3, getWindow: opts.getWindow });
+    this.handleTypeaheadSearch = this.handleTypeaheadSearch.bind(this);
+    this.resetTypeahead = this.resetTypeahead.bind(this);
+  }
+  handleTypeaheadSearch(key, candidates) {
+    if (!candidates.length) return;
+    this.#search.current = this.#search.current + key;
+    const currentItem = this.#getCurrentItem()();
+    const currentMatch = candidates.find((item) => item === currentItem)?.textContent?.trim() ?? "";
+    const values = candidates.map((item) => item.textContent?.trim() ?? "");
+    const nextMatch = getNextMatch(values, this.#search.current, currentMatch);
+    const newItem = candidates.find((item) => item.textContent?.trim() === nextMatch);
+    if (newItem) this.#onMatch()(newItem);
+    return newItem;
+  }
+  resetTypeahead() {
+    this.#search.current = "";
+  }
+  get search() {
+    return this.#search.current;
+  }
+}
+const CONTEXT_MENU_TRIGGER_ATTR = "data-context-menu-trigger";
+const CONTEXT_MENU_CONTENT_ATTR = "data-context-menu-content";
+const MenuRootContext = new Context("Menu.Root");
+const MenuMenuContext = new Context("Menu.Root | Menu.Sub");
+const MenuContentContext = new Context("Menu.Content");
+const MenuOpenEvent = new CustomEventDispatcher("bitsmenuopen", { bubbles: false, cancelable: true });
+const menuAttrs = createBitsAttrs({
+  component: "menu",
+  parts: [
+    "trigger",
+    "content",
+    "sub-trigger",
+    "item",
+    "group",
+    "group-heading",
+    "checkbox-group",
+    "checkbox-item",
+    "radio-group",
+    "radio-item",
+    "separator",
+    "sub-content",
+    "arrow"
+  ]
+});
+class MenuSubmenuIntent {
+  #opts;
+  // readonly #debugOverlay: MenuIntentDebugOverlay;
+  #cleanupDocMove = null;
+  #fallbackTimer = null;
+  #active = false;
+  #target = null;
+  #apex = null;
+  #pointerPoint = null;
+  // #corridor: Polygon | null = null;
+  // #intentPolygon: Polygon | null = null;
+  #launchPoint = null;
+  constructor(opts) {
+    this.#opts = opts;
+    watch([opts.triggerNode, opts.contentNode, opts.enabled], ([triggerNode, contentNode, enabled]) => {
+      this.#reset();
+      if (!triggerNode || !contentNode || !enabled) return;
+      const onTriggerMove = (e) => {
+        if (!isMouseEvent(e)) return;
+        this.#launchPoint = { x: e.clientX, y: e.clientY };
+        if (!this.#active) this.#preview(e, "content");
+      };
+      const onTriggerLeave = (e) => {
+        if (!isMouseEvent(e)) return;
+        this.#engage(e, "content");
+      };
+      const onContentMove = (e) => {
+        if (!isMouseEvent(e)) return;
+        if (!this.#active) this.#preview(e, "trigger");
+      };
+      const onContentLeave = (e) => {
+        if (!isMouseEvent(e)) return;
+        if (isElement(e.relatedTarget)) {
+          const selector = this.#opts.subContentSelector();
+          const matchedSubContent = e.relatedTarget.closest(selector);
+          if (matchedSubContent && matchedSubContent !== contentNode && matchedSubContent.id) {
+            const isChild = !!contentNode.querySelector(`[aria-controls="${matchedSubContent.id}"]`);
+            if (isChild) {
+              return;
+            }
+          }
+        }
+        this.#engage(e, "trigger");
+      };
+      const onTriggerEnter = (e) => {
+        if (!isMouseEvent(e)) return;
+        this.#disengage();
+      };
+      const onContentEnter = (e) => {
+        if (!isMouseEvent(e)) return;
+        this.#disengage();
+      };
+      triggerNode.addEventListener("pointermove", onTriggerMove);
+      triggerNode.addEventListener("pointerleave", onTriggerLeave);
+      triggerNode.addEventListener("pointerenter", onTriggerEnter);
+      contentNode.addEventListener("pointermove", onContentMove);
+      contentNode.addEventListener("pointerleave", onContentLeave);
+      contentNode.addEventListener("pointerenter", onContentEnter);
+      return () => {
+        triggerNode.removeEventListener("pointermove", onTriggerMove);
+        triggerNode.removeEventListener("pointerleave", onTriggerLeave);
+        triggerNode.removeEventListener("pointerenter", onTriggerEnter);
+        contentNode.removeEventListener("pointermove", onContentMove);
+        contentNode.removeEventListener("pointerleave", onContentLeave);
+        contentNode.removeEventListener("pointerenter", onContentEnter);
+        this.#reset();
+      };
+    });
+  }
+  #parentTargetRect() {
+    const parent = this.#opts.parentContentNode();
+    if (parent) return parent.getBoundingClientRect();
+    return this.#opts.triggerNode()?.getBoundingClientRect() ?? null;
+  }
+  #computePolygons(pointerPt, target) {
+    const triggerNode = this.#opts.triggerNode();
+    const contentNode = this.#opts.contentNode();
+    if (!triggerNode || !contentNode) return null;
+    const triggerRect = triggerNode.getBoundingClientRect();
+    const contentRect = contentNode.getBoundingClientRect();
+    const side = getSide(triggerRect, contentRect);
+    let apex;
+    let targetRect;
+    let sourceRect;
+    if (target === "content") {
+      apex = this.#active ? this.#apex ?? pointerPt : pointerPt;
+      targetRect = contentRect;
+    } else {
+      apex = this.#launchPoint ?? pointerPt;
+      targetRect = this.#parentTargetRect() ?? triggerRect;
+      sourceRect = contentRect;
+    }
+    this.#apex = apex;
+    return {
+      corridor: getCorridorPolygon(triggerRect, contentRect, side),
+      intent: getIntentPolygon(apex, targetRect, side, target, sourceRect),
+      targetRect,
+      side
+    };
+  }
+  #isInSafeZone(pt, corridor, intent) {
+    return isPointInPolygon(pt, corridor) || isPointInPolygon(pt, intent);
+  }
+  #preview(e, target) {
+    const pt = { x: e.clientX, y: e.clientY };
+    const geo = this.#computePolygons(pt, target);
+    if (!geo) return;
+    this.#target = target;
+    this.#pointerPoint = pt;
+  }
+  #engage(e, target) {
+    if (!this.#opts.enabled()) return;
+    const triggerNode = this.#opts.triggerNode();
+    const contentNode = this.#opts.contentNode();
+    if (!triggerNode || !contentNode) return;
+    const related = e.relatedTarget;
+    if (isElement(related)) {
+      if (target === "content" && contentNode.contains(related)) return;
+      if (target === "trigger" && triggerNode.contains(related)) return;
+    }
+    const pt = { x: e.clientX, y: e.clientY };
+    const geo = this.#computePolygons(pt, target);
+    if (!geo) return;
+    if (!isInsideRect(pt, geo.targetRect) && !this.#isInSafeZone(pt, geo.corridor, geo.intent)) {
+      this.#clearVisuals();
+      return;
+    }
+    this.#active = true;
+    this.#target = target;
+    this.#pointerPoint = pt;
+    this.#opts.setIsPointerInTransit(true);
+    this.#attachDocMove();
+    this.#startFallback();
+  }
+  #disengageTimer = null;
+  #disengage() {
+    if (!this.#active) return;
+    const wasReturning = this.#target === "trigger";
+    this.#detachDocMove();
+    this.#clearFallback();
+    this.#active = false;
+    this.#clearVisuals();
+    if (wasReturning) {
+      this.#clearDisengageTimer();
+      this.#disengageTimer = setTimeout(
+        () => {
+          this.#disengageTimer = null;
+          this.#opts.setIsPointerInTransit(false);
+        },
+        100
+      );
+    } else {
+      this.#opts.setIsPointerInTransit(false);
+    }
+  }
+  #clearDisengageTimer() {
+    if (this.#disengageTimer === null) return;
+    clearTimeout(this.#disengageTimer);
+    this.#disengageTimer = null;
+  }
+  #intentExit() {
+    const pointerPoint = this.#pointerPoint;
+    this.#detachDocMove();
+    this.#clearFallback();
+    this.#clearDisengageTimer();
+    this.#active = false;
+    this.#opts.setIsPointerInTransit(false);
+    this.#clearVisuals();
+    this.#opts.onIntentExit(pointerPoint);
+  }
+  #reset() {
+    this.#detachDocMove();
+    this.#clearFallback();
+    this.#clearDisengageTimer();
+    if (this.#active) this.#opts.setIsPointerInTransit(false);
+    this.#active = false;
+    this.#target = null;
+    this.#apex = null;
+    this.#pointerPoint = null;
+    this.#launchPoint = null;
+  }
+  #isPointerInDescendantSubContent(pt) {
+    const contentNode = this.#opts.contentNode();
+    if (!contentNode) return false;
+    const doc = contentNode.ownerDocument;
+    const el = doc.elementFromPoint(pt.x, pt.y);
+    if (!el) return false;
+    const selector = this.#opts.subContentSelector();
+    const subContent = el.closest(selector);
+    if (!subContent || subContent === contentNode) return false;
+    if (subContent.id) return !!contentNode.querySelector(`[aria-controls="${subContent.id}"]`);
+    return false;
+  }
+  #onDocMove = (e) => {
+    if (!this.#active || !this.#target) return;
+    if (!isMouseEvent(e)) return;
+    const triggerNode = this.#opts.triggerNode();
+    const contentNode = this.#opts.contentNode();
+    if (!triggerNode || !contentNode) {
+      this.#intentExit();
+      return;
+    }
+    this.#clearFallback();
+    const pt = { x: e.clientX, y: e.clientY };
+    this.#pointerPoint = pt;
+    const triggerRect = triggerNode.getBoundingClientRect();
+    const contentRect = contentNode.getBoundingClientRect();
+    if (this.#target === "content" && isInsideRect(pt, contentRect)) {
+      this.#disengage();
+      return;
+    }
+    if (this.#target === "trigger" && isInsideInsetRect(pt, triggerRect, 4)) {
+      this.#disengage();
+      return;
+    }
+    if (this.#isPointerInDescendantSubContent(pt)) {
+      this.#startFallback();
+      return;
+    }
+    const geo = this.#computePolygons(pt, this.#target);
+    if (!geo) {
+      this.#intentExit();
+      return;
+    }
+    if (this.#isInSafeZone(pt, geo.corridor, geo.intent)) {
+      this.#startFallback();
+      return;
+    }
+    this.#intentExit();
+  };
+  #attachDocMove() {
+    if (this.#cleanupDocMove) return;
+    const doc = getDocument(this.#opts.triggerNode() ?? this.#opts.contentNode());
+    if (!doc) return;
+    doc.addEventListener("pointermove", this.#onDocMove, true);
+    this.#cleanupDocMove = () => {
+      doc.removeEventListener("pointermove", this.#onDocMove, true);
+      this.#cleanupDocMove = null;
+    };
+  }
+  #detachDocMove() {
+    this.#cleanupDocMove?.();
+  }
+  #startFallback() {
+    this.#clearFallback();
+    this.#fallbackTimer = setTimeout(
+      () => {
+        this.#fallbackTimer = null;
+        if (this.#active) this.#intentExit();
+      },
+      500
+    );
+  }
+  #clearFallback() {
+    if (this.#fallbackTimer === null) return;
+    clearTimeout(this.#fallbackTimer);
+    this.#fallbackTimer = null;
+  }
+  #clearVisuals() {
+    this.#target = null;
+    this.#apex = null;
+    this.#pointerPoint = null;
+  }
+}
+function isPointInPolygon(point, polygon) {
+  const { x, y } = point;
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i].x;
+    const yi = polygon[i].y;
+    const xj = polygon[j].x;
+    const yj = polygon[j].y;
+    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+function isInsideRect(point, rect) {
+  return point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.bottom;
+}
+function isInsideInsetRect(point, rect, inset) {
+  return point.x >= rect.left + inset && point.x <= rect.right - inset && point.y >= rect.top + inset && point.y <= rect.bottom - inset;
+}
+function getSide(triggerRect, contentRect) {
+  const triggerCenterX = triggerRect.left + triggerRect.width / 2;
+  const triggerCenterY = triggerRect.top + triggerRect.height / 2;
+  const contentCenterX = contentRect.left + contentRect.width / 2;
+  const contentCenterY = contentRect.top + contentRect.height / 2;
+  const deltaX = contentCenterX - triggerCenterX;
+  const deltaY = contentCenterY - triggerCenterY;
+  if (Math.abs(deltaX) > Math.abs(deltaY)) {
+    return deltaX > 0 ? "right" : "left";
+  }
+  return deltaY > 0 ? "bottom" : "top";
+}
+function getCorridorPolygon(triggerRect, contentRect, side) {
+  const buffer = 2;
+  switch (side) {
+    case "top":
+      return [
+        {
+          x: Math.min(triggerRect.left, contentRect.left) - buffer,
+          y: triggerRect.top
+        },
+        {
+          x: Math.min(triggerRect.left, contentRect.left) - buffer,
+          y: contentRect.bottom
+        },
+        {
+          x: Math.max(triggerRect.right, contentRect.right) + buffer,
+          y: contentRect.bottom
+        },
+        {
+          x: Math.max(triggerRect.right, contentRect.right) + buffer,
+          y: triggerRect.top
+        }
+      ];
+    case "bottom":
+      return [
+        {
+          x: Math.min(triggerRect.left, contentRect.left) - buffer,
+          y: triggerRect.bottom
+        },
+        {
+          x: Math.min(triggerRect.left, contentRect.left) - buffer,
+          y: contentRect.top
+        },
+        {
+          x: Math.max(triggerRect.right, contentRect.right) + buffer,
+          y: contentRect.top
+        },
+        {
+          x: Math.max(triggerRect.right, contentRect.right) + buffer,
+          y: triggerRect.bottom
+        }
+      ];
+    case "left":
+      return [
+        {
+          x: triggerRect.left,
+          y: Math.min(triggerRect.top, contentRect.top) - buffer
+        },
+        {
+          x: contentRect.right,
+          y: Math.min(triggerRect.top, contentRect.top) - buffer
+        },
+        {
+          x: contentRect.right,
+          y: Math.max(triggerRect.bottom, contentRect.bottom) + buffer
+        },
+        {
+          x: triggerRect.left,
+          y: Math.max(triggerRect.bottom, contentRect.bottom) + buffer
+        }
+      ];
+    case "right":
+      return [
+        {
+          x: triggerRect.right,
+          y: Math.min(triggerRect.top, contentRect.top) - buffer
+        },
+        {
+          x: contentRect.left,
+          y: Math.min(triggerRect.top, contentRect.top) - buffer
+        },
+        {
+          x: contentRect.left,
+          y: Math.max(triggerRect.bottom, contentRect.bottom) + buffer
+        },
+        {
+          x: triggerRect.right,
+          y: Math.max(triggerRect.bottom, contentRect.bottom) + buffer
+        }
+      ];
+  }
+}
+function getIntentPolygon(exitPoint, targetRect, side, target, sourceRect) {
+  const edgeBuffer = 8;
+  const effectiveSide = target === "trigger" ? flipSide(side) : side;
+  const top = sourceRect ? Math.min(targetRect.top, sourceRect.top) - edgeBuffer : targetRect.top - edgeBuffer;
+  const bottom = sourceRect ? Math.max(targetRect.bottom, sourceRect.bottom) + edgeBuffer : targetRect.bottom + edgeBuffer;
+  const left = sourceRect ? Math.min(targetRect.left, sourceRect.left) - edgeBuffer : targetRect.left - edgeBuffer;
+  const right = sourceRect ? Math.max(targetRect.right, sourceRect.right) + edgeBuffer : targetRect.right + edgeBuffer;
+  switch (effectiveSide) {
+    case "right":
+      return [
+        exitPoint,
+        { x: targetRect.left, y: top },
+        { x: targetRect.left, y: bottom }
+      ];
+    case "left":
+      return [
+        exitPoint,
+        { x: targetRect.right, y: top },
+        { x: targetRect.right, y: bottom }
+      ];
+    case "bottom":
+      return [
+        exitPoint,
+        { x: left, y: targetRect.top },
+        { x: right, y: targetRect.top }
+      ];
+    case "top":
+      return [
+        exitPoint,
+        { x: left, y: targetRect.bottom },
+        { x: right, y: targetRect.bottom }
+      ];
+  }
+}
+function flipSide(side) {
+  switch (side) {
+    case "top":
+      return "bottom";
+    case "bottom":
+      return "top";
+    case "left":
+      return "right";
+    case "right":
+      return "left";
+  }
+}
+class MenuRootState {
+  static create(opts) {
+    const root = new MenuRootState(opts);
+    return MenuRootContext.set(root);
+  }
+  opts;
+  isUsingKeyboard = new IsUsingKeyboard();
+  ignoreCloseAutoFocus = false;
+  isPointerInTransit = false;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  getBitsAttr = (part) => {
+    return menuAttrs.getAttr(part, this.opts.variant.current);
+  };
+}
+class MenuMenuState {
+  static create(opts, root) {
+    return MenuMenuContext.set(new MenuMenuState(opts, root, null));
+  }
+  opts;
+  root;
+  parentMenu;
+  contentId = boxWith(() => "");
+  contentNode = null;
+  contentPresence;
+  triggerNode = null;
+  constructor(opts, root, parentMenu) {
+    this.opts = opts;
+    this.root = root;
+    this.parentMenu = parentMenu;
+    this.contentPresence = new PresenceManager({
+      ref: boxWith(() => this.contentNode),
+      open: this.opts.open,
+      onComplete: () => {
+        this.opts.onOpenChangeComplete.current(this.opts.open.current);
+      },
+      shouldSkipExitAnimation: () => {
+        if (this.root.opts.variant.current !== "menubar" || this.parentMenu !== null) {
+          return false;
+        }
+        return this.root.opts.shouldSkipExitAnimation?.() ?? false;
+      }
+    });
+    if (parentMenu) {
+      watch(() => parentMenu.opts.open.current, () => {
+        if (parentMenu.opts.open.current) return;
+        this.opts.open.current = false;
+      });
+    }
+  }
+  toggleOpen() {
+    this.opts.open.current = !this.opts.open.current;
+  }
+  onOpen() {
+    this.opts.open.current = true;
+  }
+  onClose() {
+    this.opts.open.current = false;
+  }
+}
+class MenuContentState {
+  static create(opts) {
+    return MenuContentContext.set(new MenuContentState(opts, MenuMenuContext.get()));
+  }
+  opts;
+  parentMenu;
+  rovingFocusGroup;
+  domContext;
+  attachment;
+  search = "";
+  #timer = 0;
+  #handleTypeaheadSearch;
+  mounted = false;
+  #isSub;
+  constructor(opts, parentMenu) {
+    this.opts = opts;
+    this.parentMenu = parentMenu;
+    this.domContext = new DOMContext(opts.ref);
+    this.attachment = attachRef(this.opts.ref, (v) => {
+      if (this.parentMenu.contentNode !== v) {
+        this.parentMenu.contentNode = v;
+      }
+    });
+    parentMenu.contentId = opts.id;
+    this.#isSub = opts.isSub ?? false;
+    this.onkeydown = this.onkeydown.bind(this);
+    this.onblur = this.onblur.bind(this);
+    this.onfocus = this.onfocus.bind(this);
+    this.handleInteractOutside = this.handleInteractOutside.bind(this);
+    new MenuSubmenuIntent({
+      contentNode: () => this.parentMenu.contentNode,
+      triggerNode: () => this.parentMenu.triggerNode,
+      parentContentNode: () => this.parentMenu.parentMenu?.contentNode ?? null,
+      subContentSelector: () => `[${this.parentMenu.root.getBitsAttr("sub-content")}]`,
+      // debugMode: () => this.parentMenu.root.opts.debugMode.current,
+      enabled: () => this.parentMenu.opts.open.current && Boolean(this.parentMenu.triggerNode?.hasAttribute(this.parentMenu.root.getBitsAttr("sub-trigger"))),
+      onIntentExit: (pointerPoint) => {
+        this.parentMenu.opts.open.current = false;
+        this.#dispatchPointerMoveToHoveredSubTrigger(pointerPoint);
+      },
+      setIsPointerInTransit: (value) => {
+        this.parentMenu.root.isPointerInTransit = value;
+      }
+    });
+    this.#handleTypeaheadSearch = new DOMTypeahead({
+      getActiveElement: () => this.domContext.getActiveElement(),
+      getWindow: () => this.domContext.getWindow()
+    }).handleTypeaheadSearch;
+    this.rovingFocusGroup = new RovingFocusGroup({
+      rootNode: boxWith(() => this.parentMenu.contentNode),
+      candidateAttr: this.parentMenu.root.getBitsAttr("item"),
+      loop: this.opts.loop,
+      orientation: boxWith(() => "vertical")
+    });
+    watch(() => this.parentMenu.contentNode, (contentNode) => {
+      if (!contentNode) return;
+      const handler = () => {
+        afterTick(() => {
+          if (!this.parentMenu.root.isUsingKeyboard.current) return;
+          this.rovingFocusGroup.focusFirstCandidate();
+        });
+      };
+      return MenuOpenEvent.listen(contentNode, handler);
+    });
+  }
+  #getCandidateNodes() {
+    const node = this.parentMenu.contentNode;
+    if (!node) return [];
+    const candidates = Array.from(node.querySelectorAll(`[${this.parentMenu.root.getBitsAttr("item")}]:not([data-disabled])`));
+    return candidates;
+  }
+  #isPointerMovingToSubmenu() {
+    return this.parentMenu.root.isPointerInTransit;
+  }
+  #dispatchPointerMoveToHoveredSubTrigger(pointerPoint) {
+    if (!pointerPoint) return;
+    const parentContentNode = this.parentMenu.parentMenu?.contentNode;
+    if (!parentContentNode) return;
+    const hoveredNode = this.domContext.getDocument().elementFromPoint(pointerPoint.x, pointerPoint.y);
+    if (!isElement(hoveredNode)) return;
+    const hoveredSubTrigger = hoveredNode.closest(`[${this.parentMenu.root.getBitsAttr("sub-trigger")}]`);
+    if (!hoveredSubTrigger || !parentContentNode.contains(hoveredSubTrigger)) return;
+    if (hoveredSubTrigger === this.parentMenu.triggerNode) return;
+    hoveredSubTrigger.dispatchEvent(new PointerEvent("pointermove", {
+      bubbles: true,
+      cancelable: true,
+      pointerType: "mouse",
+      clientX: pointerPoint.x,
+      clientY: pointerPoint.y
+    }));
+  }
+  onCloseAutoFocus = (e) => {
+    this.opts.onCloseAutoFocus.current?.(e);
+    if (e.defaultPrevented || this.#isSub) return;
+    if (this.parentMenu.root.ignoreCloseAutoFocus) {
+      e.preventDefault();
+      return;
+    }
+    if (this.parentMenu.triggerNode && isTabbable(this.parentMenu.triggerNode)) {
+      e.preventDefault();
+      this.parentMenu.triggerNode.focus();
+    }
+  };
+  handleTabKeyDown(e) {
+    let rootMenu = this.parentMenu;
+    while (rootMenu.parentMenu !== null) {
+      rootMenu = rootMenu.parentMenu;
+    }
+    if (!rootMenu.triggerNode) return;
+    e.preventDefault();
+    const nodeToFocus = getTabbableFrom(rootMenu.triggerNode, e.shiftKey ? "prev" : "next");
+    if (nodeToFocus) {
+      this.parentMenu.root.ignoreCloseAutoFocus = true;
+      rootMenu.onClose();
+      afterTick(() => {
+        nodeToFocus.focus();
+        afterTick(() => {
+          this.parentMenu.root.ignoreCloseAutoFocus = false;
+        });
+      });
+    } else {
+      this.domContext.getDocument().body.focus();
+    }
+  }
+  onkeydown(e) {
+    if (e.defaultPrevented) return;
+    if (e.key === TAB) {
+      this.handleTabKeyDown(e);
+      return;
+    }
+    const target = e.target;
+    const currentTarget = e.currentTarget;
+    if (!isHTMLElement$1(target) || !isHTMLElement$1(currentTarget)) return;
+    const isKeydownInside = target.closest(`[${this.parentMenu.root.getBitsAttr("content")}]`)?.id === this.parentMenu.contentId.current;
+    const isModifierKey = e.ctrlKey || e.altKey || e.metaKey;
+    const isCharacterKey = e.key.length === 1;
+    const kbdFocusedEl = this.rovingFocusGroup.handleKeydown(target, e);
+    if (kbdFocusedEl) return;
+    if (e.code === "Space") return;
+    const candidateNodes = this.#getCandidateNodes();
+    if (isKeydownInside) {
+      if (!isModifierKey && isCharacterKey) {
+        this.#handleTypeaheadSearch(e.key, candidateNodes);
+      }
+    }
+    if (e.target?.id !== this.parentMenu.contentId.current) return;
+    if (!FIRST_LAST_KEYS.includes(e.key)) return;
+    e.preventDefault();
+    if (LAST_KEYS.includes(e.key)) {
+      candidateNodes.reverse();
+    }
+    focusFirst(candidateNodes, { select: false }, () => this.domContext.getActiveElement());
+  }
+  onblur(e) {
+    if (!isElement(e.currentTarget)) return;
+    if (!isElement(e.target)) return;
+    if (!e.currentTarget.contains?.(e.target)) {
+      this.domContext.getWindow().clearTimeout(this.#timer);
+      this.search = "";
+    }
+  }
+  onfocus(_) {
+    if (!this.parentMenu.root.isUsingKeyboard.current) return;
+    afterTick(() => this.rovingFocusGroup.focusFirstCandidate());
+  }
+  onItemEnter() {
+    return this.#isPointerMovingToSubmenu();
+  }
+  onItemLeave(e) {
+    if (e.currentTarget.hasAttribute(this.parentMenu.root.getBitsAttr("sub-trigger"))) return;
+    if (this.#isPointerMovingToSubmenu() || this.parentMenu.root.isUsingKeyboard.current) return;
+    const contentNode = this.parentMenu.contentNode;
+    contentNode?.focus({ preventScroll: true });
+    this.rovingFocusGroup.setCurrentTabStopId("");
+  }
+  onTriggerLeave() {
+    if (this.#isPointerMovingToSubmenu()) return true;
+    return false;
+  }
+  handleInteractOutside(e) {
+    if (!isElementOrSVGElement(e.target)) return;
+    const triggerId = this.parentMenu.triggerNode?.id;
+    if (e.target.id === triggerId) {
+      e.preventDefault();
+      return;
+    }
+    if (e.target.closest(`#${triggerId}`)) {
+      e.preventDefault();
+      return;
+    }
+    this.parentMenu.root.ignoreCloseAutoFocus = true;
+    afterTick(() => {
+      this.parentMenu.root.ignoreCloseAutoFocus = false;
+    });
+  }
+  get shouldRender() {
+    return this.parentMenu.contentPresence.shouldRender;
+  }
+  #snippetProps = derived(() => ({ open: this.parentMenu.opts.open.current }));
+  get snippetProps() {
+    return this.#snippetProps();
+  }
+  set snippetProps($$value) {
+    return this.#snippetProps($$value);
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    role: "menu",
+    "aria-orientation": "vertical",
+    [this.parentMenu.root.getBitsAttr("content")]: "",
+    "data-state": getDataOpenClosed(this.parentMenu.opts.open.current),
+    ...getDataTransitionAttrs(this.parentMenu.contentPresence.transitionStatus),
+    onkeydown: this.onkeydown,
+    onblur: this.onblur,
+    onfocus: this.onfocus,
+    dir: this.parentMenu.root.opts.dir.current,
+    style: { pointerEvents: "auto", contain: "layout style" },
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+  popperProps = { onCloseAutoFocus: (e) => this.onCloseAutoFocus(e) };
+}
+class MenuItemSharedState {
+  opts;
+  content;
+  attachment;
+  #isFocused = false;
+  constructor(opts, content) {
+    this.opts = opts;
+    this.content = content;
+    this.attachment = attachRef(this.opts.ref);
+    this.onpointermove = this.onpointermove.bind(this);
+    this.onpointerleave = this.onpointerleave.bind(this);
+    this.onfocus = this.onfocus.bind(this);
+    this.onblur = this.onblur.bind(this);
+  }
+  onpointermove(e) {
+    if (e.defaultPrevented) return;
+    if (!isMouseEvent(e)) return;
+    if (this.opts.disabled.current) {
+      this.content.onItemLeave(e);
+    } else {
+      const defaultPrevented = this.content.onItemEnter();
+      if (defaultPrevented) return;
+      const item = e.currentTarget;
+      if (!isHTMLElement$1(item)) return;
+      item.focus({ preventScroll: true });
+    }
+  }
+  onpointerleave(e) {
+    if (e.defaultPrevented) return;
+    if (!isMouseEvent(e)) return;
+    this.content.onItemLeave(e);
+  }
+  onfocus(e) {
+    afterTick(() => {
+      if (e.defaultPrevented || this.opts.disabled.current) return;
+      this.#isFocused = true;
+    });
+  }
+  onblur(e) {
+    afterTick(() => {
+      if (e.defaultPrevented) return;
+      this.#isFocused = false;
+    });
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    tabindex: -1,
+    role: "menuitem",
+    "aria-disabled": boolToStr(this.opts.disabled.current),
+    "data-disabled": boolToEmptyStrOrUndef(this.opts.disabled.current),
+    "data-highlighted": this.#isFocused ? "" : void 0,
+    [this.content.parentMenu.root.getBitsAttr("item")]: "",
+    //
+    onpointermove: this.onpointermove,
+    onpointerleave: this.onpointerleave,
+    onfocus: this.onfocus,
+    onblur: this.onblur,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class MenuItemState {
+  static create(opts) {
+    const item = new MenuItemSharedState(opts, MenuContentContext.get());
+    return new MenuItemState(opts, item);
+  }
+  opts;
+  item;
+  root;
+  #isPointerDown = false;
+  constructor(opts, item) {
+    this.opts = opts;
+    this.item = item;
+    this.root = item.content.parentMenu.root;
+    this.onkeydown = this.onkeydown.bind(this);
+    this.onclick = this.onclick.bind(this);
+    this.onpointerdown = this.onpointerdown.bind(this);
+    this.onpointerup = this.onpointerup.bind(this);
+  }
+  #handleSelect() {
+    if (this.item.opts.disabled.current) return;
+    const selectEvent = new CustomEvent("menuitemselect", { bubbles: true, cancelable: true });
+    this.opts.onSelect.current(selectEvent);
+    if (selectEvent.defaultPrevented) {
+      this.item.content.parentMenu.root.isUsingKeyboard.current = false;
+      return;
+    }
+    if (this.opts.closeOnSelect.current) {
+      this.item.content.parentMenu.root.opts.onClose();
+    }
+  }
+  onkeydown(e) {
+    const isTypingAhead = this.item.content.search !== "";
+    if (this.item.opts.disabled.current || isTypingAhead && e.key === SPACE) return;
+    if (SELECTION_KEYS.includes(e.key)) {
+      if (!isHTMLElement$1(e.currentTarget)) return;
+      e.currentTarget.click();
+      e.preventDefault();
+    }
+  }
+  onclick(_) {
+    if (this.item.opts.disabled.current) return;
+    this.#handleSelect();
+  }
+  onpointerup(e) {
+    if (e.defaultPrevented) return;
+    if (!this.#isPointerDown) {
+      if (!isHTMLElement$1(e.currentTarget)) return;
+      e.currentTarget?.click();
+    }
+  }
+  onpointerdown(_) {
+    this.#isPointerDown = true;
+  }
+  #props = derived(() => mergeProps(this.item.props, {
+    onclick: this.onclick,
+    onpointerdown: this.onpointerdown,
+    onpointerup: this.onpointerup,
+    onkeydown: this.onkeydown
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class MenuSubTriggerState {
+  static create(opts) {
+    const content = MenuContentContext.get();
+    const item = new MenuItemSharedState(opts, content);
+    const submenu = MenuMenuContext.get();
+    return new MenuSubTriggerState(opts, item, content, submenu);
+  }
+  opts;
+  item;
+  content;
+  submenu;
+  attachment;
+  #openTimer = null;
+  constructor(opts, item, content, submenu) {
+    this.opts = opts;
+    this.item = item;
+    this.content = content;
+    this.submenu = submenu;
+    this.attachment = attachRef(this.opts.ref, (v) => this.submenu.triggerNode = v);
+    this.onpointerleave = this.onpointerleave.bind(this);
+    this.onpointermove = this.onpointermove.bind(this);
+    this.onkeydown = this.onkeydown.bind(this);
+    this.onclick = this.onclick.bind(this);
+  }
+  #clearOpenTimer() {
+    if (this.#openTimer === null) return;
+    this.content.domContext.getWindow().clearTimeout(this.#openTimer);
+    this.#openTimer = null;
+  }
+  onpointermove(e) {
+    if (!isMouseEvent(e)) return;
+    if (this.submenu.root.isPointerInTransit) {
+      if (this.#openTimer !== null) this.#clearOpenTimer();
+      return;
+    }
+    if (!this.item.opts.disabled.current && !this.submenu.opts.open.current && !this.#openTimer) {
+      const openDelay = this.opts.openDelay.current;
+      if (openDelay <= 0) {
+        this.submenu.onOpen();
+        return;
+      }
+      this.#openTimer = this.content.domContext.setTimeout(
+        () => {
+          if (this.submenu.root.isPointerInTransit) {
+            this.#clearOpenTimer();
+            return;
+          }
+          this.submenu.onOpen();
+          this.#clearOpenTimer();
+        },
+        openDelay
+      );
+    }
+  }
+  onpointerleave(e) {
+    if (!isMouseEvent(e)) return;
+    this.#clearOpenTimer();
+  }
+  onkeydown(e) {
+    const isTypingAhead = this.content.search !== "";
+    if (this.item.opts.disabled.current || isTypingAhead && e.key === SPACE) return;
+    if (SUB_OPEN_KEYS[this.submenu.root.opts.dir.current].includes(e.key)) {
+      e.currentTarget.click();
+      e.preventDefault();
+    }
+  }
+  onclick(e) {
+    if (this.item.opts.disabled.current) return;
+    if (!isHTMLElement$1(e.currentTarget)) return;
+    e.currentTarget.focus();
+    const selectEvent = new CustomEvent("menusubtriggerselect", { bubbles: true, cancelable: true });
+    this.opts.onSelect.current(selectEvent);
+    if (!this.submenu.opts.open.current) {
+      this.submenu.onOpen();
+      afterTick(() => {
+        const contentNode = this.submenu.contentNode;
+        if (!contentNode) return;
+        MenuOpenEvent.dispatch(contentNode);
+      });
+    }
+  }
+  #props = derived(() => mergeProps(
+    {
+      "aria-haspopup": "menu",
+      "aria-expanded": boolToStr(this.submenu.opts.open.current),
+      "data-state": getDataOpenClosed(this.submenu.opts.open.current),
+      "aria-controls": this.submenu.opts.open.current ? this.submenu.contentId.current : void 0,
+      [this.submenu.root.getBitsAttr("sub-trigger")]: "",
+      onclick: this.onclick,
+      onpointermove: this.onpointermove,
+      onpointerleave: this.onpointerleave,
+      onkeydown: this.onkeydown,
+      ...this.attachment
+    },
+    this.item.props
+  ));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class MenuSeparatorState {
+  static create(opts) {
+    return new MenuSeparatorState(opts, MenuRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.attachment = attachRef(this.opts.ref);
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    role: "group",
+    [this.root.getBitsAttr("separator")]: "",
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class DropdownMenuTriggerState {
+  static create(opts) {
+    return new DropdownMenuTriggerState(opts, MenuMenuContext.get());
+  }
+  opts;
+  parentMenu;
+  attachment;
+  constructor(opts, parentMenu) {
+    this.opts = opts;
+    this.parentMenu = parentMenu;
+    this.attachment = attachRef(this.opts.ref, (v) => this.parentMenu.triggerNode = v);
+  }
+  onclick = (e) => {
+    if (this.opts.disabled.current || e.detail !== 0) return;
+    this.parentMenu.toggleOpen();
+    e.preventDefault();
+  };
+  onpointerdown = (e) => {
+    if (this.opts.disabled.current) return;
+    if (e.pointerType === "touch") return e.preventDefault();
+    if (e.button === 0 && e.ctrlKey === false) {
+      this.parentMenu.toggleOpen();
+      if (!this.parentMenu.opts.open.current) e.preventDefault();
+    }
+  };
+  onpointerup = (e) => {
+    if (this.opts.disabled.current) return;
+    if (e.pointerType === "touch") {
+      e.preventDefault();
+      this.parentMenu.toggleOpen();
+    }
+  };
+  onkeydown = (e) => {
+    if (this.opts.disabled.current) return;
+    if (e.key === SPACE || e.key === ENTER) {
+      this.parentMenu.toggleOpen();
+      e.preventDefault();
+      return;
+    }
+    if (e.key === ARROW_DOWN) {
+      this.parentMenu.onOpen();
+      e.preventDefault();
+    }
+  };
+  #ariaControls = derived(() => {
+    if (this.parentMenu.opts.open.current && this.parentMenu.contentId.current) return this.parentMenu.contentId.current;
+    return void 0;
+  });
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    disabled: this.opts.disabled.current,
+    "aria-haspopup": "menu",
+    "aria-expanded": boolToStr(this.parentMenu.opts.open.current),
+    "aria-controls": this.#ariaControls(),
+    "data-disabled": boolToEmptyStrOrUndef(this.opts.disabled.current),
+    "data-state": getDataOpenClosed(this.parentMenu.opts.open.current),
+    [this.parentMenu.root.getBitsAttr("trigger")]: "",
+    //
+    onclick: this.onclick,
+    onpointerdown: this.onpointerdown,
+    onpointerup: this.onpointerup,
+    onkeydown: this.onkeydown,
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class MenuSubmenuState {
+  static create(opts) {
+    const menu = MenuMenuContext.get();
+    return MenuMenuContext.set(new MenuMenuState(opts, menu.root, menu));
+  }
+}
+globalThis.bitsDismissableLayers ??= /* @__PURE__ */ new Map();
+class DismissibleLayerState {
+  static create(opts) {
+    return new DismissibleLayerState(opts);
+  }
+  opts;
+  #interactOutsideProp;
+  #behaviorType;
+  #interceptedEvents = { pointerdown: false };
+  #isResponsibleLayer = false;
+  #isFocusInsideDOMTree = false;
+  #documentObj = void 0;
+  #onFocusOutside;
+  #unsubClickListener = noop;
+  constructor(opts) {
+    this.opts = opts;
+    this.#behaviorType = opts.interactOutsideBehavior;
+    this.#interactOutsideProp = opts.onInteractOutside;
+    this.#onFocusOutside = opts.onFocusOutside;
+    let unsubEvents = noop;
+    const cleanup = () => {
+      this.#resetState();
+      globalThis.bitsDismissableLayers.delete(this);
+      this.#handleInteractOutside.destroy();
+      unsubEvents();
+    };
+    watch([() => this.opts.enabled.current, () => this.opts.ref.current], () => {
+      if (!this.opts.enabled.current || !this.opts.ref.current) return;
+      afterSleep(1, () => {
+        if (!this.opts.ref.current) return;
+        globalThis.bitsDismissableLayers.set(this, this.#behaviorType);
+        unsubEvents();
+        unsubEvents = this.#addEventListeners();
+      });
+      return cleanup;
+    });
+  }
+  #handleFocus = (event) => {
+    if (event.defaultPrevented) return;
+    if (!this.opts.ref.current) return;
+    afterTick(() => {
+      if (!this.opts.ref.current || this.#isTargetWithinLayer(event.target)) return;
+      if (event.target && !this.#isFocusInsideDOMTree) {
+        this.#onFocusOutside.current?.(event);
+      }
+    });
+  };
+  #addEventListeners() {
+    return executeCallbacks(
+      /**
+       * CAPTURE INTERACTION START
+       * mark interaction-start event as intercepted.
+       * mark responsible layer during interaction start
+       * to avoid checking if is responsible layer during interaction end
+       * when a new floating element may have been opened.
+       */
+      on(this.#documentObj, "pointerdown", executeCallbacks(this.#markInterceptedEvent, this.#markResponsibleLayer), { capture: true }),
+      /**
+       * BUBBLE INTERACTION START
+       * Mark interaction-start event as non-intercepted. Debounce `onInteractOutsideStart`
+       * to avoid prematurely checking if other events were intercepted.
+       */
+      on(this.#documentObj, "pointerdown", executeCallbacks(this.#markNonInterceptedEvent, this.#handleInteractOutside)),
+      /**
+       * HANDLE FOCUS OUTSIDE
+       */
+      on(this.#documentObj, "focusin", this.#handleFocus)
+    );
+  }
+  #handleDismiss = (e) => {
+    let event = e;
+    if (event.defaultPrevented) {
+      event = createWrappedEvent(e);
+    }
+    this.#interactOutsideProp.current(e);
+  };
+  #handleInteractOutside = debounce(
+    (e) => {
+      if (!this.opts.ref.current) {
+        this.#unsubClickListener();
+        return;
+      }
+      const isEventValid = this.opts.isValidEvent.current(e, this.opts.ref.current) || isValidEvent(e, this.opts.ref.current);
+      if (!this.#isResponsibleLayer || this.#isAnyEventIntercepted() || !isEventValid) {
+        this.#unsubClickListener();
+        return;
+      }
+      let event = e;
+      if (event.defaultPrevented) {
+        event = createWrappedEvent(event);
+      }
+      if (this.#behaviorType.current !== "close" && this.#behaviorType.current !== "defer-otherwise-close") {
+        this.#unsubClickListener();
+        return;
+      }
+      if (e.pointerType === "touch") {
+        this.#unsubClickListener();
+        this.#unsubClickListener = on(this.#documentObj, "click", this.#handleDismiss, { once: true });
+      } else {
+        this.#interactOutsideProp.current(event);
+      }
+    },
+    10
+  );
+  #markInterceptedEvent = (e) => {
+    this.#interceptedEvents[e.type] = true;
+  };
+  #markNonInterceptedEvent = (e) => {
+    this.#interceptedEvents[e.type] = false;
+  };
+  #markResponsibleLayer = () => {
+    if (!this.opts.ref.current) return;
+    this.#isResponsibleLayer = isResponsibleLayer(this.opts.ref.current);
+  };
+  #isTargetWithinLayer = (target) => {
+    if (!this.opts.ref.current) return false;
+    return isOrContainsTarget(this.opts.ref.current, target);
+  };
+  #resetState = debounce(
+    () => {
+      for (const eventType in this.#interceptedEvents) {
+        this.#interceptedEvents[eventType] = false;
+      }
+      this.#isResponsibleLayer = false;
+    },
+    20
+  );
+  #isAnyEventIntercepted() {
+    const i = Object.values(this.#interceptedEvents).some(Boolean);
+    return i;
+  }
+  #onfocuscapture = () => {
+    this.#isFocusInsideDOMTree = true;
+  };
+  #onblurcapture = () => {
+    this.#isFocusInsideDOMTree = false;
+  };
+  props = {
+    onfocuscapture: this.#onfocuscapture,
+    onblurcapture: this.#onblurcapture
+  };
+}
+function getTopMostDismissableLayer(layersArr = [...globalThis.bitsDismissableLayers]) {
+  return layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+}
+function isResponsibleLayer(node) {
+  const layersArr = [...globalThis.bitsDismissableLayers];
+  const topMostLayer = getTopMostDismissableLayer(layersArr);
+  if (topMostLayer) return topMostLayer[0].opts.ref.current === node;
+  const [firstLayerNode] = layersArr[0];
+  return firstLayerNode.opts.ref.current === node;
+}
+function isValidEvent(e, node) {
+  const target = e.target;
+  if (!isElementOrSVGElement(target)) return false;
+  const targetIsContextMenuTrigger = Boolean(target.closest(`[${CONTEXT_MENU_TRIGGER_ATTR}]`));
+  const nodeIsContextMenu = Boolean(node.closest(`[${CONTEXT_MENU_CONTENT_ATTR}]`));
+  if ("button" in e && e.button > 0 && !targetIsContextMenuTrigger) return false;
+  if ("button" in e && e.button === 0 && targetIsContextMenuTrigger && nodeIsContextMenu) {
+    return true;
+  }
+  if (targetIsContextMenuTrigger && nodeIsContextMenu) return false;
+  const ownerDocument = getOwnerDocument(target);
+  const isValid = ownerDocument.documentElement.contains(target) && !isOrContainsTarget(node, target) && isClickTrulyOutside(e, node);
+  return isValid;
+}
+function createWrappedEvent(e) {
+  const capturedCurrentTarget = e.currentTarget;
+  const capturedTarget = e.target;
+  let newEvent;
+  if (e instanceof PointerEvent) {
+    newEvent = new PointerEvent(e.type, e);
+  } else {
+    newEvent = new PointerEvent("pointerdown", e);
+  }
+  let isPrevented = false;
+  const wrappedEvent = new Proxy(newEvent, {
+    get: (target, prop) => {
+      if (prop === "currentTarget") {
+        return capturedCurrentTarget;
+      }
+      if (prop === "target") {
+        return capturedTarget;
+      }
+      if (prop === "preventDefault") {
+        return () => {
+          isPrevented = true;
+          if (typeof target.preventDefault === "function") {
+            target.preventDefault();
+          }
+        };
+      }
+      if (prop === "defaultPrevented") {
+        return isPrevented;
+      }
+      if (prop in target) {
+        return target[prop];
+      }
+      return e[prop];
+    }
+  });
+  return wrappedEvent;
+}
+function Dismissible_layer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      interactOutsideBehavior = "close",
+      onInteractOutside = noop,
+      onFocusOutside = noop,
+      id,
+      children,
+      enabled,
+      isValidEvent: isValidEvent2 = () => false,
+      ref
+    } = $$props;
+    const dismissibleLayerState = DismissibleLayerState.create({
+      id: boxWith(() => id),
+      interactOutsideBehavior: boxWith(() => interactOutsideBehavior),
+      onInteractOutside: boxWith(() => onInteractOutside),
+      enabled: boxWith(() => enabled),
+      onFocusOutside: boxWith(() => onFocusOutside),
+      isValidEvent: boxWith(() => isValidEvent2),
+      ref
+    });
+    children?.($$renderer2, { props: dismissibleLayerState.props });
+    $$renderer2.push(`<!---->`);
+  });
+}
+globalThis.bitsEscapeLayers ??= /* @__PURE__ */ new Map();
+class EscapeLayerState {
+  static create(opts) {
+    return new EscapeLayerState(opts);
+  }
+  opts;
+  domContext;
+  constructor(opts) {
+    this.opts = opts;
+    this.domContext = new DOMContext(this.opts.ref);
+    let unsubEvents = noop;
+    watch(() => opts.enabled.current, (enabled) => {
+      if (enabled) {
+        globalThis.bitsEscapeLayers.set(this, opts.escapeKeydownBehavior);
+        unsubEvents = this.#addEventListener();
+      }
+      return () => {
+        unsubEvents();
+        globalThis.bitsEscapeLayers.delete(this);
+      };
+    });
+  }
+  #addEventListener = () => {
+    return on(this.domContext.getDocument(), "keydown", this.#onkeydown, { passive: false });
+  };
+  #onkeydown = (e) => {
+    if (e.key !== ESCAPE || !isResponsibleEscapeLayer(this)) return;
+    const clonedEvent = new KeyboardEvent(e.type, e);
+    e.preventDefault();
+    const behaviorType = this.opts.escapeKeydownBehavior.current;
+    if (behaviorType !== "close" && behaviorType !== "defer-otherwise-close") return;
+    this.opts.onEscapeKeydown.current(clonedEvent);
+  };
+}
+function isResponsibleEscapeLayer(instance) {
+  const layersArr = [...globalThis.bitsEscapeLayers];
+  const topMostLayer = layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+  if (topMostLayer) return topMostLayer[0] === instance;
+  const [firstLayerNode] = layersArr[0];
+  return firstLayerNode === instance;
+}
+function Escape_layer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      escapeKeydownBehavior = "close",
+      onEscapeKeydown = noop,
+      children,
+      enabled,
+      ref
+    } = $$props;
+    EscapeLayerState.create({
+      escapeKeydownBehavior: boxWith(() => escapeKeydownBehavior),
+      onEscapeKeydown: boxWith(() => onEscapeKeydown),
+      enabled: boxWith(() => enabled),
+      ref
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+class FocusScopeManager {
+  static instance;
+  #scopeStack = simpleBox([]);
+  #focusHistory = /* @__PURE__ */ new WeakMap();
+  #preFocusHistory = /* @__PURE__ */ new WeakMap();
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new FocusScopeManager();
+    }
+    return this.instance;
+  }
+  register(scope) {
+    const current = this.getActive();
+    if (current && current !== scope) {
+      current.pause();
+    }
+    const activeElement = document.activeElement;
+    if (activeElement && activeElement !== document.body) {
+      this.#preFocusHistory.set(scope, activeElement);
+    }
+    this.#scopeStack.current = this.#scopeStack.current.filter((s) => s !== scope);
+    this.#scopeStack.current.unshift(scope);
+  }
+  unregister(scope) {
+    this.#scopeStack.current = this.#scopeStack.current.filter((s) => s !== scope);
+    const next2 = this.getActive();
+    if (next2) {
+      next2.resume();
+    }
+  }
+  getActive() {
+    return this.#scopeStack.current[0];
+  }
+  setFocusMemory(scope, element) {
+    this.#focusHistory.set(scope, element);
+  }
+  getFocusMemory(scope) {
+    return this.#focusHistory.get(scope);
+  }
+  isActiveScope(scope) {
+    return this.getActive() === scope;
+  }
+  setPreFocusMemory(scope, element) {
+    this.#preFocusHistory.set(scope, element);
+  }
+  getPreFocusMemory(scope) {
+    return this.#preFocusHistory.get(scope);
+  }
+  clearPreFocusMemory(scope) {
+    this.#preFocusHistory.delete(scope);
+  }
+}
+class FocusScope {
+  #paused = false;
+  #container = null;
+  #manager = FocusScopeManager.getInstance();
+  #cleanupFns = [];
+  #opts;
+  constructor(opts) {
+    this.#opts = opts;
+  }
+  get paused() {
+    return this.#paused;
+  }
+  pause() {
+    this.#paused = true;
+  }
+  resume() {
+    this.#paused = false;
+  }
+  #cleanup() {
+    for (const fn of this.#cleanupFns) {
+      fn();
+    }
+    this.#cleanupFns = [];
+  }
+  mount(container) {
+    if (this.#container) {
+      this.unmount();
+    }
+    this.#container = container;
+    this.#manager.register(this);
+    this.#setupEventListeners();
+    this.#handleOpenAutoFocus();
+  }
+  unmount() {
+    if (!this.#container) return;
+    this.#cleanup();
+    this.#handleCloseAutoFocus();
+    this.#manager.unregister(this);
+    this.#manager.clearPreFocusMemory(this);
+    this.#container = null;
+  }
+  #handleOpenAutoFocus() {
+    if (!this.#container) return;
+    const event = new CustomEvent("focusScope.onOpenAutoFocus", { bubbles: false, cancelable: true });
+    this.#opts.onOpenAutoFocus.current(event);
+    if (!event.defaultPrevented) {
+      requestAnimationFrame(() => {
+        if (!this.#container) return;
+        const firstTabbable = this.#getFirstTabbable();
+        if (firstTabbable) {
+          firstTabbable.focus();
+          this.#manager.setFocusMemory(this, firstTabbable);
+        } else {
+          this.#container.focus();
+        }
+      });
+    }
+  }
+  #handleCloseAutoFocus() {
+    const event = new CustomEvent("focusScope.onCloseAutoFocus", { bubbles: false, cancelable: true });
+    this.#opts.onCloseAutoFocus.current?.(event);
+    if (!event.defaultPrevented) {
+      const preFocusedElement = this.#manager.getPreFocusMemory(this);
+      if (preFocusedElement && document.contains(preFocusedElement)) {
+        try {
+          preFocusedElement.focus();
+        } catch {
+          document.body.focus();
+        }
+      }
+    }
+  }
+  #setupEventListeners() {
+    if (!this.#container || !this.#opts.trap.current) return;
+    const container = this.#container;
+    const doc = container.ownerDocument;
+    const handleFocus = (e) => {
+      if (this.#paused || !this.#manager.isActiveScope(this)) return;
+      const target = e.target;
+      if (!target) return;
+      const isInside = container.contains(target);
+      if (isInside) {
+        this.#manager.setFocusMemory(this, target);
+      } else {
+        const lastFocused = this.#manager.getFocusMemory(this);
+        if (lastFocused && container.contains(lastFocused) && isFocusable(lastFocused)) {
+          e.preventDefault();
+          lastFocused.focus();
+        } else {
+          const firstTabbable = this.#getFirstTabbable();
+          const firstFocusable = this.#getAllFocusables()[0];
+          (firstTabbable || firstFocusable || container).focus();
+        }
+      }
+    };
+    const handleKeydown = (e) => {
+      if (!this.#opts.loop || this.#paused || e.key !== "Tab") return;
+      if (!this.#manager.isActiveScope(this)) return;
+      const tabbables = this.#getTabbables();
+      if (tabbables.length === 0) return;
+      const first = tabbables[0];
+      const last = tabbables[tabbables.length - 1];
+      if (!e.shiftKey && doc.activeElement === last) {
+        e.preventDefault();
+        first.focus();
+      } else if (e.shiftKey && doc.activeElement === first) {
+        e.preventDefault();
+        last.focus();
+      }
+    };
+    this.#cleanupFns.push(on(doc, "focusin", handleFocus, { capture: true }), on(container, "keydown", handleKeydown));
+    const observer = new MutationObserver(() => {
+      const lastFocused = this.#manager.getFocusMemory(this);
+      if (lastFocused && !container.contains(lastFocused)) {
+        const firstTabbable = this.#getFirstTabbable();
+        const firstFocusable = this.#getAllFocusables()[0];
+        const elementToFocus = firstTabbable || firstFocusable;
+        if (elementToFocus) {
+          elementToFocus.focus();
+          this.#manager.setFocusMemory(this, elementToFocus);
+        } else {
+          container.focus();
+        }
+      }
+    });
+    observer.observe(container, { childList: true, subtree: true });
+    this.#cleanupFns.push(() => observer.disconnect());
+  }
+  #getTabbables() {
+    if (!this.#container) return [];
+    return tabbable(this.#container, { includeContainer: false, getShadowRoot: true });
+  }
+  #getFirstTabbable() {
+    const tabbables = this.#getTabbables();
+    return tabbables[0] || null;
+  }
+  #getAllFocusables() {
+    if (!this.#container) return [];
+    return focusable(this.#container, { includeContainer: false, getShadowRoot: true });
+  }
+  static use(opts) {
+    let scope = null;
+    watch([() => opts.ref.current, () => opts.enabled.current], ([ref, enabled]) => {
+      if (ref && enabled) {
+        if (!scope) {
+          scope = new FocusScope(opts);
+        }
+        scope.mount(ref);
+      } else if (scope) {
+        scope.unmount();
+        scope = null;
+      }
+    });
+    return {
+      get props() {
+        return { tabindex: -1 };
+      }
+    };
+  }
+}
+function Focus_scope($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      enabled = false,
+      trapFocus = false,
+      loop = false,
+      onCloseAutoFocus = noop,
+      onOpenAutoFocus = noop,
+      focusScope,
+      ref
+    } = $$props;
+    const focusScopeState = FocusScope.use({
+      enabled: boxWith(() => enabled),
+      trap: boxWith(() => trapFocus),
+      loop,
+      onCloseAutoFocus: boxWith(() => onCloseAutoFocus),
+      onOpenAutoFocus: boxWith(() => onOpenAutoFocus),
+      ref
+    });
+    focusScope?.($$renderer2, { props: focusScopeState.props });
+    $$renderer2.push(`<!---->`);
+  });
+}
+const noopPointer = () => {
+};
+globalThis.bitsTextSelectionLayers ??= /* @__PURE__ */ new Map();
+class TextSelectionLayerState {
+  static create(opts) {
+    return new TextSelectionLayerState(opts);
+  }
+  opts;
+  domContext;
+  #unsubSelectionLock = noop;
+  #enabledSnapshot = false;
+  #onPointerDownSnapshot = noopPointer;
+  #onPointerUpSnapshot = noopPointer;
+  constructor(opts) {
+    this.opts = opts;
+    this.domContext = new DOMContext(opts.ref);
+    let unsubEvents = noop;
+    watch(
+      () => [
+        this.opts.enabled.current,
+        this.opts.onPointerDown.current,
+        this.opts.onPointerUp.current
+      ],
+      ([enabled, onPointerDown, onPointerUp]) => {
+        this.#enabledSnapshot = enabled;
+        this.#onPointerDownSnapshot = onPointerDown;
+        this.#onPointerUpSnapshot = onPointerUp;
+        if (enabled) {
+          globalThis.bitsTextSelectionLayers.set(this, this.opts.enabled);
+          unsubEvents();
+          unsubEvents = this.#addEventListeners();
+        }
+        return () => {
+          this.#enabledSnapshot = false;
+          unsubEvents();
+          this.#resetSelectionLock();
+          globalThis.bitsTextSelectionLayers.delete(this);
+        };
+      }
+    );
+  }
+  #addEventListeners() {
+    return executeCallbacks(on(this.domContext.getDocument(), "pointerdown", this.#pointerdown), on(this.domContext.getDocument(), "pointerup", composeHandlers(this.#resetSelectionLock, this.#pointerupUserHandler)));
+  }
+  #pointerupUserHandler = (e) => {
+    this.#onPointerUpSnapshot(e);
+  };
+  #pointerdown = (e) => {
+    const node = this.opts.ref.current;
+    const target = e.target;
+    if (!isHTMLElement$1(node) || !isHTMLElement$1(target) || !this.#enabledSnapshot) return;
+    if (!isHighestLayer(this) || !contains(node, target)) return;
+    this.#onPointerDownSnapshot(e);
+    if (e.defaultPrevented) return;
+    this.#unsubSelectionLock = preventTextSelectionOverflow(node, this.domContext.getDocument().body);
+  };
+  #resetSelectionLock = () => {
+    this.#unsubSelectionLock();
+    this.#unsubSelectionLock = noop;
+  };
+}
+const getUserSelect = (node) => node.style.userSelect || node.style.webkitUserSelect;
+function preventTextSelectionOverflow(node, body) {
+  const originalBodyUserSelect = getUserSelect(body);
+  const originalNodeUserSelect = getUserSelect(node);
+  setUserSelect(body, "none");
+  setUserSelect(node, "text");
+  return () => {
+    setUserSelect(body, originalBodyUserSelect);
+    setUserSelect(node, originalNodeUserSelect);
+  };
+}
+function setUserSelect(node, value) {
+  node.style.userSelect = value;
+  node.style.webkitUserSelect = value;
+}
+function isHighestLayer(instance) {
+  const layersArr = [...globalThis.bitsTextSelectionLayers];
+  if (!layersArr.length) return false;
+  const highestLayer = layersArr.at(-1);
+  if (!highestLayer) return false;
+  return highestLayer[0] === instance;
+}
+function Text_selection_layer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      preventOverflowTextSelection = true,
+      onPointerDown = noop,
+      onPointerUp = noop,
+      id,
+      children,
+      enabled,
+      ref
+    } = $$props;
+    TextSelectionLayerState.create({
+      id: boxWith(() => id),
+      onPointerDown: boxWith(() => onPointerDown),
+      onPointerUp: boxWith(() => onPointerUp),
+      enabled: boxWith(() => enabled && preventOverflowTextSelection),
+      ref
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+globalThis.bitsIdCounter ??= { current: 0 };
+function useId(prefix = "bits") {
+  globalThis.bitsIdCounter.current++;
+  return `${prefix}-${globalThis.bitsIdCounter.current}`;
+}
+class SharedState {
+  #factory;
+  #subscribers = 0;
+  #state;
+  #scope;
+  constructor(factory) {
+    this.#factory = factory;
+  }
+  #dispose() {
+    this.#subscribers -= 1;
+    if (this.#scope && this.#subscribers <= 0) {
+      this.#scope();
+      this.#state = void 0;
+      this.#scope = void 0;
+    }
+  }
+  get(...args) {
+    this.#subscribers += 1;
+    if (this.#state === void 0) {
+      this.#scope = () => {
+      };
+    }
+    return this.#state;
+  }
+}
+const lockMap = new SvelteMap();
+let initialBodyStyle = null;
+let cleanupTimeoutId = null;
+let isInCleanupTransition = false;
+const anyLocked = boxWith(() => {
+  for (const value of lockMap.values()) {
+    if (value) return true;
+  }
+  return false;
+});
+let cleanupScheduledAt = null;
+const bodyLockStackCount = new SharedState(() => {
+  function resetBodyStyle() {
+    return;
+  }
+  function cancelPendingCleanup() {
+    if (cleanupTimeoutId === null) return;
+    window.clearTimeout(cleanupTimeoutId);
+    cleanupTimeoutId = null;
+  }
+  function scheduleCleanupIfNoNewLocks(delay, callback) {
+    cancelPendingCleanup();
+    isInCleanupTransition = true;
+    cleanupScheduledAt = Date.now();
+    const currentCleanupId = cleanupScheduledAt;
+    const cleanupFn = () => {
+      cleanupTimeoutId = null;
+      if (cleanupScheduledAt !== currentCleanupId) return;
+      if (!isAnyLocked(lockMap)) {
+        isInCleanupTransition = false;
+        callback();
+      } else {
+        isInCleanupTransition = false;
+      }
+    };
+    const actualDelay = delay === null ? 24 : delay;
+    cleanupTimeoutId = window.setTimeout(cleanupFn, actualDelay);
+  }
+  function ensureInitialStyleCaptured() {
+    if (initialBodyStyle === null && lockMap.size === 0 && !isInCleanupTransition) {
+      initialBodyStyle = document.body.getAttribute("style");
+    }
+  }
+  watch(() => anyLocked.current, () => {
+    if (!anyLocked.current) return;
+    ensureInitialStyleCaptured();
+    isInCleanupTransition = false;
+    const htmlStyle = getComputedStyle(document.documentElement);
+    const bodyStyle = getComputedStyle(document.body);
+    const hasStableGutter = htmlStyle.scrollbarGutter?.includes("stable") || bodyStyle.scrollbarGutter?.includes("stable");
+    const verticalScrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+    const paddingRight = Number.parseInt(bodyStyle.paddingRight ?? "0", 10);
+    const config = {
+      padding: paddingRight + verticalScrollbarWidth,
+      margin: Number.parseInt(bodyStyle.marginRight ?? "0", 10)
+    };
+    if (verticalScrollbarWidth > 0 && !hasStableGutter) {
+      document.body.style.paddingRight = `${config.padding}px`;
+      document.body.style.marginRight = `${config.margin}px`;
+      document.body.style.setProperty("--scrollbar-width", `${verticalScrollbarWidth}px`);
+    }
+    document.body.style.overflow = "hidden";
+    if (isIOS) {
+      on(
+        document,
+        "touchmove",
+        (e) => {
+          if (e.target !== document.documentElement) return;
+          if (e.touches.length > 1) return;
+          e.preventDefault();
+        },
+        { passive: false }
+      );
+    }
+    afterTick(() => {
+      document.body.style.pointerEvents = "none";
+      document.body.style.overflow = "hidden";
+    });
+  });
+  return {
+    get lockMap() {
+      return lockMap;
+    },
+    resetBodyStyle,
+    scheduleCleanupIfNoNewLocks,
+    cancelPendingCleanup,
+    ensureInitialStyleCaptured
+  };
+});
+class BodyScrollLock {
+  #id = useId();
+  #initialState;
+  #restoreScrollDelay = () => null;
+  #countState;
+  locked;
+  constructor(initialState, restoreScrollDelay = () => null) {
+    this.#initialState = initialState;
+    this.#restoreScrollDelay = restoreScrollDelay;
+    this.#countState = bodyLockStackCount.get();
+    if (!this.#countState) return;
+    this.#countState.cancelPendingCleanup();
+    this.#countState.ensureInitialStyleCaptured();
+    this.#countState.lockMap.set(this.#id, this.#initialState ?? false);
+    this.locked = boxWith(() => this.#countState.lockMap.get(this.#id) ?? false, (v) => this.#countState.lockMap.set(this.#id, v));
+  }
+}
+function isAnyLocked(map) {
+  for (const [_, value] of map) {
+    if (value) return true;
+  }
+  return false;
+}
+function Scroll_lock($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { preventScroll = true, restoreScrollDelay = null } = $$props;
+    if (preventScroll) {
+      new BodyScrollLock(preventScroll, () => restoreScrollDelay);
+    }
+  });
+}
+
+export { AnimationsComplete as A, Dismissible_layer as D, Escape_layer as E, Focus_scope as F, MenuRootState as M, PresenceManager as P, Scroll_lock as S, Text_selection_layer as T, Portal as a, afterTick as b, DOMContext as c, DOMTypeahead as d, backward as e, forward as f, boxAutoReset as g, getNextMatch as h, afterSleep as i, getWindow as j, MenuMenuState as k, DropdownMenuTriggerState as l, MenuContentState as m, next as n, isValidIndex as o, prev as p, MenuItemState as q, MenuSubmenuState as r, MenuSeparatorState as s, MenuSubTriggerState as t, useId as u, MenuOpenEvent as v, SUB_CLOSE_KEYS as w };
+//# sourceMappingURL=scroll-lock.js-BzUpWsKI.js.map