@selvajs/selva 2.0.11 → 4.0.0

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

@@ -0,0 +1,1558 @@
+import 'clsx';
+import { w as watch, n as noop, C as Context, i as isBrowser, e as ESCAPE, j as isHTMLElement$1, k as isIOS, h as isElementOrSVGElement } from './noop-iPXixleG.js';
+import { aB as ssr_context, X as getAllContexts, ag as lifecycle_function_unavailable, I as derived } from './renderer-x4cX3Aau.js';
+import { h as boxWith, w as simpleBox, k as createBitsAttrs, n as executeCallbacks, i as composeHandlers, s as isObject } from './create-id-B-AKukLt.js';
+import { o as on } from './events-qfxQNxtp.js';
+import { S as SvelteMap } from './index-server-DMc-UvjC.js';
+
+function onDestroy(fn) {
+  /** @type {SSRContext} */
+  ssr_context.r.on_destroy(fn);
+}
+function mount() {
+  lifecycle_function_unavailable("mount");
+}
+function unmount() {
+  lifecycle_function_unavailable("unmount");
+}
+async function tick() {
+}
+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 next = child;
+    while (next) {
+      if (parent === next)
+        return true;
+      next = next.parentNode || next.host;
+    }
+  }
+  return false;
+}
+function getDocument(node) {
+  if (isDocument(node))
+    return node;
+  if (isWindow(node))
+    return node.document;
+  return node?.ownerDocument ?? document;
+}
+function 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(`<!--]-->`);
+  });
+}
+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;
+}
+var candidateSelectors = ["input:not([inert]):not([inert] *)", "select:not([inert]):not([inert] *)", "textarea:not([inert]):not([inert] *)", "a[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;
+    }
+  }
+  if (getComputedStyle(node).visibility === "hidden") {
+    return true;
+  }
+  var isDirectSummary = matches.call(node, "details>summary:first-of-type");
+  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
+  if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
+    return true;
+  }
+  if (!displayCheck || displayCheck === "full" || // full-native can run this branch when it falls through in case
+  // Element#checkVisibility is unsupported
+  displayCheck === "full-native" || displayCheck === "legacy-full") {
+    if (typeof getShadowRoot === "function") {
+      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 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);
+};
+const CONTEXT_MENU_TRIGGER_ATTR = "data-context-menu-trigger";
+const CONTEXT_MENU_CONTENT_ATTR = "data-context-menu-content";
+createBitsAttrs({
+  component: "menu",
+  parts: [
+    "trigger",
+    "content",
+    "sub-trigger",
+    "item",
+    "group",
+    "group-heading",
+    "checkbox-group",
+    "checkbox-item",
+    "radio-group",
+    "radio-item",
+    "separator",
+    "sub-content",
+    "arrow"
+  ]
+});
+globalThis.bitsDismissableLayers ??= /* @__PURE__ */ new Map();
+class DismissibleLayerState {
+  static create(opts) {
+    return new DismissibleLayerState(opts);
+  }
+  opts;
+  #interactOutsideProp;
+  #behaviorType;
+  #interceptedEvents = { pointerdown: false };
+  #isResponsibleLayer = false;
+  #isFocusInsideDOMTree = false;
+  #documentObj = void 0;
+  #onFocusOutside;
+  #unsubClickListener = noop;
+  constructor(opts) {
+    this.opts = opts;
+    this.#behaviorType = opts.interactOutsideBehavior;
+    this.#interactOutsideProp = opts.onInteractOutside;
+    this.#onFocusOutside = opts.onFocusOutside;
+    let unsubEvents = noop;
+    const cleanup = () => {
+      this.#resetState();
+      globalThis.bitsDismissableLayers.delete(this);
+      this.#handleInteractOutside.destroy();
+      unsubEvents();
+    };
+    watch([() => this.opts.enabled.current, () => this.opts.ref.current], () => {
+      if (!this.opts.enabled.current || !this.opts.ref.current) return;
+      afterSleep(1, () => {
+        if (!this.opts.ref.current) return;
+        globalThis.bitsDismissableLayers.set(this, this.#behaviorType);
+        unsubEvents();
+        unsubEvents = this.#addEventListeners();
+      });
+      return cleanup;
+    });
+  }
+  #handleFocus = (event) => {
+    if (event.defaultPrevented) return;
+    if (!this.opts.ref.current) return;
+    afterTick(() => {
+      if (!this.opts.ref.current || this.#isTargetWithinLayer(event.target)) return;
+      if (event.target && !this.#isFocusInsideDOMTree) {
+        this.#onFocusOutside.current?.(event);
+      }
+    });
+  };
+  #addEventListeners() {
+    return executeCallbacks(
+      /**
+       * CAPTURE INTERACTION START
+       * mark interaction-start event as intercepted.
+       * mark responsible layer during interaction start
+       * to avoid checking if is responsible layer during interaction end
+       * when a new floating element may have been opened.
+       */
+      on(this.#documentObj, "pointerdown", executeCallbacks(this.#markInterceptedEvent, this.#markResponsibleLayer), { capture: true }),
+      /**
+       * BUBBLE INTERACTION START
+       * Mark interaction-start event as non-intercepted. Debounce `onInteractOutsideStart`
+       * to avoid prematurely checking if other events were intercepted.
+       */
+      on(this.#documentObj, "pointerdown", executeCallbacks(this.#markNonInterceptedEvent, this.#handleInteractOutside)),
+      /**
+       * HANDLE FOCUS OUTSIDE
+       */
+      on(this.#documentObj, "focusin", this.#handleFocus)
+    );
+  }
+  #handleDismiss = (e) => {
+    let event = e;
+    if (event.defaultPrevented) {
+      event = createWrappedEvent(e);
+    }
+    this.#interactOutsideProp.current(e);
+  };
+  #handleInteractOutside = debounce(
+    (e) => {
+      if (!this.opts.ref.current) {
+        this.#unsubClickListener();
+        return;
+      }
+      const isEventValid = this.opts.isValidEvent.current(e, this.opts.ref.current) || isValidEvent(e, this.opts.ref.current);
+      if (!this.#isResponsibleLayer || this.#isAnyEventIntercepted() || !isEventValid) {
+        this.#unsubClickListener();
+        return;
+      }
+      let event = e;
+      if (event.defaultPrevented) {
+        event = createWrappedEvent(event);
+      }
+      if (this.#behaviorType.current !== "close" && this.#behaviorType.current !== "defer-otherwise-close") {
+        this.#unsubClickListener();
+        return;
+      }
+      if (e.pointerType === "touch") {
+        this.#unsubClickListener();
+        this.#unsubClickListener = on(this.#documentObj, "click", this.#handleDismiss, { once: true });
+      } else {
+        this.#interactOutsideProp.current(event);
+      }
+    },
+    10
+  );
+  #markInterceptedEvent = (e) => {
+    this.#interceptedEvents[e.type] = true;
+  };
+  #markNonInterceptedEvent = (e) => {
+    this.#interceptedEvents[e.type] = false;
+  };
+  #markResponsibleLayer = () => {
+    if (!this.opts.ref.current) return;
+    this.#isResponsibleLayer = isResponsibleLayer(this.opts.ref.current);
+  };
+  #isTargetWithinLayer = (target) => {
+    if (!this.opts.ref.current) return false;
+    return isOrContainsTarget(this.opts.ref.current, target);
+  };
+  #resetState = debounce(
+    () => {
+      for (const eventType in this.#interceptedEvents) {
+        this.#interceptedEvents[eventType] = false;
+      }
+      this.#isResponsibleLayer = false;
+    },
+    20
+  );
+  #isAnyEventIntercepted() {
+    const i = Object.values(this.#interceptedEvents).some(Boolean);
+    return i;
+  }
+  #onfocuscapture = () => {
+    this.#isFocusInsideDOMTree = true;
+  };
+  #onblurcapture = () => {
+    this.#isFocusInsideDOMTree = false;
+  };
+  props = {
+    onfocuscapture: this.#onfocuscapture,
+    onblurcapture: this.#onblurcapture
+  };
+}
+function getTopMostDismissableLayer(layersArr = [...globalThis.bitsDismissableLayers]) {
+  return layersArr.findLast(([_, { current: behaviorType }]) => behaviorType === "close" || behaviorType === "ignore");
+}
+function isResponsibleLayer(node) {
+  const layersArr = [...globalThis.bitsDismissableLayers];
+  const topMostLayer = getTopMostDismissableLayer(layersArr);
+  if (topMostLayer) return topMostLayer[0].opts.ref.current === node;
+  const [firstLayerNode] = layersArr[0];
+  return firstLayerNode.opts.ref.current === node;
+}
+function isValidEvent(e, node) {
+  const target = e.target;
+  if (!isElementOrSVGElement(target)) return false;
+  const targetIsContextMenuTrigger = Boolean(target.closest(`[${CONTEXT_MENU_TRIGGER_ATTR}]`));
+  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 next = this.getActive();
+    if (next) {
+      next.resume();
+    }
+  }
+  getActive() {
+    return this.#scopeStack.current[0];
+  }
+  setFocusMemory(scope, element) {
+    this.#focusHistory.set(scope, element);
+  }
+  getFocusMemory(scope) {
+    return this.#focusHistory.get(scope);
+  }
+  isActiveScope(scope) {
+    return this.getActive() === scope;
+  }
+  setPreFocusMemory(scope, element) {
+    this.#preFocusHistory.set(scope, element);
+  }
+  getPreFocusMemory(scope) {
+    return this.#preFocusHistory.get(scope);
+  }
+  clearPreFocusMemory(scope) {
+    this.#preFocusHistory.delete(scope);
+  }
+}
+class FocusScope {
+  #paused = false;
+  #container = null;
+  #manager = FocusScopeManager.getInstance();
+  #cleanupFns = [];
+  #opts;
+  constructor(opts) {
+    this.#opts = opts;
+  }
+  get paused() {
+    return this.#paused;
+  }
+  pause() {
+    this.#paused = true;
+  }
+  resume() {
+    this.#paused = false;
+  }
+  #cleanup() {
+    for (const fn of this.#cleanupFns) {
+      fn();
+    }
+    this.#cleanupFns = [];
+  }
+  mount(container) {
+    if (this.#container) {
+      this.unmount();
+    }
+    this.#container = container;
+    this.#manager.register(this);
+    this.#setupEventListeners();
+    this.#handleOpenAutoFocus();
+  }
+  unmount() {
+    if (!this.#container) return;
+    this.#cleanup();
+    this.#handleCloseAutoFocus();
+    this.#manager.unregister(this);
+    this.#manager.clearPreFocusMemory(this);
+    this.#container = null;
+  }
+  #handleOpenAutoFocus() {
+    if (!this.#container) return;
+    const event = new CustomEvent("focusScope.onOpenAutoFocus", { bubbles: false, cancelable: true });
+    this.#opts.onOpenAutoFocus.current(event);
+    if (!event.defaultPrevented) {
+      requestAnimationFrame(() => {
+        if (!this.#container) return;
+        const firstTabbable = this.#getFirstTabbable();
+        if (firstTabbable) {
+          firstTabbable.focus();
+          this.#manager.setFocusMemory(this, firstTabbable);
+        } else {
+          this.#container.focus();
+        }
+      });
+    }
+  }
+  #handleCloseAutoFocus() {
+    const event = new CustomEvent("focusScope.onCloseAutoFocus", { bubbles: false, cancelable: true });
+    this.#opts.onCloseAutoFocus.current?.(event);
+    if (!event.defaultPrevented) {
+      const preFocusedElement = this.#manager.getPreFocusMemory(this);
+      if (preFocusedElement && document.contains(preFocusedElement)) {
+        try {
+          preFocusedElement.focus();
+        } catch {
+          document.body.focus();
+        }
+      }
+    }
+  }
+  #setupEventListeners() {
+    if (!this.#container || !this.#opts.trap.current) return;
+    const container = this.#container;
+    const doc = container.ownerDocument;
+    const handleFocus = (e) => {
+      if (this.#paused || !this.#manager.isActiveScope(this)) return;
+      const target = e.target;
+      if (!target) return;
+      const isInside = container.contains(target);
+      if (isInside) {
+        this.#manager.setFocusMemory(this, target);
+      } else {
+        const lastFocused = this.#manager.getFocusMemory(this);
+        if (lastFocused && container.contains(lastFocused) && isFocusable(lastFocused)) {
+          e.preventDefault();
+          lastFocused.focus();
+        } else {
+          const firstTabbable = this.#getFirstTabbable();
+          const firstFocusable = this.#getAllFocusables()[0];
+          (firstTabbable || firstFocusable || container).focus();
+        }
+      }
+    };
+    const handleKeydown = (e) => {
+      if (!this.#opts.loop || this.#paused || e.key !== "Tab") return;
+      if (!this.#manager.isActiveScope(this)) return;
+      const tabbables = this.#getTabbables();
+      if (tabbables.length === 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, DOMContext as D, Escape_layer as E, Focus_scope as F, Portal as P, Scroll_lock as S, Text_selection_layer as T, Dismissible_layer as a, PresenceManager as b, afterSleep as c, afterTick as d, getWindow as g, onDestroy as o, tick as t, useId as u };
+//# sourceMappingURL=scroll-lock-BVxv0Dsn.js.map