@selvajs/selva 2.0.11 → 4.0.0

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

@@ -1,1558 +0,0 @@
-import 'clsx';
-import { w as watch, n as noop, C as Context, i as isBrowser, a as ESCAPE, b as isHTMLElement$1, c as isIOS, d as isElementOrSVGElement } from './noop-CzO8kTeB.js';
-import { av as ssr_context, aw as getAllContexts, ax as lifecycle_function_unavailable, _ as derived } from './renderer-BFEBS3DQ.js';
-import { b as boxWith, s as simpleBox, c as createBitsAttrs, i as executeCallbacks, j as composeHandlers, k as isObject } from './create-id-BYuAt6fp.js';
-import { o as on } from './events-Dh5zddQQ.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, Dismissible_layer as D, Escape_layer as E, Focus_scope as F, PresenceManager as P, Scroll_lock as S, Text_selection_layer as T, afterTick as a, Portal as b, DOMContext as c, afterSleep as d, getWindow as g, onDestroy as o, tick as t, useId as u };
-//# sourceMappingURL=scroll-lock-BNv9iOMl.js.map