lizaui 12.0.20 → 12.0.21

package/dist/chunks/useHasTabbableChild-CSJ0P5QT.js

@@ -0,0 +1,2577 @@
+import { $ as $6f0c29017aeec335$export$d68d59712b04d9d1, a as $6f0c29017aeec335$export$408d25a4e12db025 } from "./BaseCollection-CdxYWaH6.js";
+import { a as $fe16bffc7a557bf0$export$7f54fc3180508a52, j as $d1116acdf220c2da$export$f9762fab77588ecb, i as $8296dad1a4c5e0dc$export$8f71654801c2f7cd, $ as $48a7d519b337145d$export$4eaf04e54aa8eed6 } from "./useHover-BHCSbkLb.js";
+import { a as $d7f64c32b702fe2c$export$8dc98ba7eadeaa56 } from "./Hidden-C55DpjMP.js";
+import { i as $c7eafbbe1ea5834e$export$535bd6ca7f90a273, g as $c4867b2f328c2698$export$e5c5a5f917a5871c, $ as $7230ffa83bc0c2cf$export$29f1550f4b0d4415, h as $390e54f620492c70$export$f680877a34711e37, d as $bbaa08b3cd72f041$export$9d1611c77c2fe928, j as $a4e76a5424781910$export$e08e3b67e392101e } from "./utils-BCEhcDlv.js";
+import { createPortal, flushSync } from "react-dom";
+import React__default, { useEffect, useMemo, cloneElement, forwardRef, useContext, createContext, useCallback, useState, useRef, isValidElement, version } from "react";
+import { a as $792f28e438b9ad5f$export$c34620ff8881d89f } from "./SharedElementTransition-CJVe1D_I.js";
+import { f as $d447af545b77c9f1$export$b204af158042fbac, g as $23f2114a1b82827e$export$cd4e5573fbe2b576, t as $2add3ce32c6007eb$export$9ac100e40613ea10, C as $d447af545b77c9f1$export$f531f92e2a15358f, w as $2add3ce32c6007eb$export$78551043582a6a98, h as $2add3ce32c6007eb$export$a11b0059900ceec8, a as $23f2114a1b82827e$export$e58f029f0fbfdb29, e as $3b8b240c1bf84ab9$export$4c063cf1350e6fed, v as $2add3ce32c6007eb$export$fedb369cb70207f1, D as $2add3ce32c6007eb$export$e1865c3bedcd822b, c as $23f2114a1b82827e$export$4282f70798064fe0, E as $caaf0dd3060ed57c$export$9a302a45f65d0572, j as $f192c2f16961cbe0$export$80f3e147d781571c, F as $23f2114a1b82827e$export$b4f377a2b6254582, d as $3b8b240c1bf84ab9$export$bebd5a1431fec25d, q as $1969ac565cfec8d0$export$de79e2c695e052f3, k as $8f5a2122b0992be3$export$630ff653c5ada6a9, $ as $d447af545b77c9f1$export$f21a1ffae260145a, s as $caaf0dd3060ed57c$export$95185d699e05d4d7 } from "./focusSafely-DfEgLKh6.js";
+import { a as $535772f9d2c1f38d$export$2d6ec8fc375ceafa } from "./FocusScope-jSNMAXzg.js";
+import { $ as $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7 } from "./I18nProvider-Coj9x7B8.js";
+import { a as $7096878c21af5e66$export$a929f3f93e2cc67e, $ as $d27d541f9569d26d$export$45712eceda6fad21 } from "./usePress-Arf10jW0.js";
+import { $ as $3e6197669829fe11$export$40bfa8c7b0832715 } from "./useControlledState-DZA25XHU.js";
+const $8b2399d051d06d4c$export$447a38995de2c711 = "react-aria-clear-focus";
+const $8b2399d051d06d4c$export$831c820ad60f9d12 = "react-aria-focus";
+function $b72f3f7b3b5f42c6$export$76e4e37e5339496d(to) {
+  let from = $b72f3f7b3b5f42c6$export$759df0d867455a91($d447af545b77c9f1$export$b204af158042fbac(to));
+  if (from !== to) {
+    if (from) $b72f3f7b3b5f42c6$export$6c5dc7e81d2cc29a(from, to);
+    if (to) $b72f3f7b3b5f42c6$export$2b35b76d2e30e129(to, from);
+  }
+}
+function $b72f3f7b3b5f42c6$export$6c5dc7e81d2cc29a(from, to) {
+  from.dispatchEvent(new FocusEvent("blur", {
+    relatedTarget: to
+  }));
+  from.dispatchEvent(new FocusEvent("focusout", {
+    bubbles: true,
+    relatedTarget: to
+  }));
+}
+function $b72f3f7b3b5f42c6$export$2b35b76d2e30e129(to, from) {
+  to.dispatchEvent(new FocusEvent("focus", {
+    relatedTarget: from
+  }));
+  to.dispatchEvent(new FocusEvent("focusin", {
+    bubbles: true,
+    relatedTarget: from
+  }));
+}
+function $b72f3f7b3b5f42c6$export$759df0d867455a91(document2) {
+  let activeElement = $23f2114a1b82827e$export$cd4e5573fbe2b576(document2);
+  let activeDescendant = activeElement?.getAttribute("aria-activedescendant");
+  if (activeDescendant) return document2.getElementById(activeDescendant) || activeElement;
+  return activeElement;
+}
+const $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT = 100;
+const $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT = 600;
+const $bb39c0fc1c19b34c$var$state = {
+  isOpen: false,
+  screenWidth: 0,
+  screenHeight: 0,
+  screenAngle: 0,
+  screenTimeout: 0,
+  startTimeStamp: 0,
+  endTimeStamp: 0,
+  resizeTimeStamp: 0,
+  resizeTimeout: 0
+};
+const $bb39c0fc1c19b34c$var$nonTextInputTypes = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+if (process.env.NODE_ENV === "test" && typeof window !== "undefined" && !Reflect.has(window, "visualViewport")) {
+  const visualViewport = Object.assign(new EventTarget(), {
+    offsetTop: 0,
+    offsetLeft: 0,
+    pageTop: 0,
+    pageLeft: 0,
+    scale: 1
+  });
+  Reflect.defineProperty(visualViewport, "width", {
+    get: () => window.innerWidth,
+    configurable: true
+  });
+  Reflect.defineProperty(visualViewport, "height", {
+    get: () => window.innerHeight,
+    configurable: true
+  });
+  Reflect.defineProperty(window, "visualViewport", {
+    value: visualViewport,
+    configurable: true,
+    writable: true
+  });
+}
+if (process.env.NODE_ENV === "test" && typeof window !== "undefined" && !Reflect.has(window.screen, "orientation")) {
+  const orientation = Object.assign(new EventTarget(), {
+    type: "landscape-primary"
+  });
+  Reflect.defineProperty(window.screen, "orientation", {
+    value: orientation,
+    configurable: true,
+    writable: true
+  });
+  Reflect.defineProperty(window.screen.orientation, "angle", {
+    get: () => window.orientation ?? 0,
+    configurable: true
+  });
+}
+function $bb39c0fc1c19b34c$var$getTouchScreen() {
+  let screenWidth = Number(window.visualViewport?.width ?? window.innerWidth);
+  let screenHeight = Number(window.visualViewport?.height ?? window.innerHeight);
+  let visualScale = Number(window.visualViewport?.scale ?? 1);
+  return {
+    width: screenWidth * visualScale,
+    height: screenHeight * visualScale,
+    angle: window.screen.orientation.angle
+  };
+}
+function $bb39c0fc1c19b34c$var$onResizeStart(e) {
+  if ($bb39c0fc1c19b34c$var$state.resizeTimeStamp <= e.timeStamp + 50) {
+    $bb39c0fc1c19b34c$var$state.resizeTimeStamp = e.timeStamp + 150;
+    window.clearTimeout($bb39c0fc1c19b34c$var$state.resizeTimeout);
+    $bb39c0fc1c19b34c$var$state.resizeTimeout = window.setTimeout($bb39c0fc1c19b34c$var$onResizeEnd, 150);
+  }
+}
+function $bb39c0fc1c19b34c$var$onResizeEnd() {
+  let viewportMeta = $7096878c21af5e66$export$a929f3f93e2cc67e("viewport");
+  if ($2add3ce32c6007eb$export$a11b0059900ceec8() && viewportMeta?.includes("overlays-content")) return;
+  let time = performance.now();
+  let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+  let elapsed = time - $bb39c0fc1c19b34c$var$state.startTimeStamp;
+  let delta = $bb39c0fc1c19b34c$var$state.screenHeight - screen.height;
+  let rotation = $bb39c0fc1c19b34c$var$state.screenAngle - screen.angle;
+  if (Math.abs(rotation) % 180 && $bb39c0fc1c19b34c$var$state.screenWidth - screen.height < $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT) {
+    $bb39c0fc1c19b34c$var$state.screenWidth = screen.width;
+    $bb39c0fc1c19b34c$var$state.screenHeight = screen.height;
+    $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+    delta = 0;
+  }
+  if (elapsed > $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT) {
+    window.clearTimeout($bb39c0fc1c19b34c$var$state.screenTimeout);
+    $bb39c0fc1c19b34c$var$state.screenTimeout = window.setTimeout(() => {
+      let activeElement = document.hasFocus() ? $23f2114a1b82827e$export$cd4e5573fbe2b576() : null;
+      let willKeyboardOpen = $bb39c0fc1c19b34c$export$c57958e35f31ed73(activeElement);
+      let screen2 = $bb39c0fc1c19b34c$var$getTouchScreen();
+      if (Math.abs($bb39c0fc1c19b34c$var$state.screenAngle - screen2.angle) % 180) return;
+      if ($bb39c0fc1c19b34c$var$state.isOpen && willKeyboardOpen) return;
+      $bb39c0fc1c19b34c$var$state.screenWidth = screen2.width;
+      $bb39c0fc1c19b34c$var$state.screenHeight = screen2.height;
+      $bb39c0fc1c19b34c$var$state.screenAngle = screen2.angle;
+      $bb39c0fc1c19b34c$var$state.isOpen = false;
+    }, $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT);
+  }
+  if (elapsed <= $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT && delta >= $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT) $bb39c0fc1c19b34c$var$state.endTimeStamp = time;
+  $bb39c0fc1c19b34c$var$state.isOpen = delta >= $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT;
+}
+function $bb39c0fc1c19b34c$var$onOrientationChange() {
+  let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+  let rotation = $bb39c0fc1c19b34c$var$state.screenAngle - screen.angle;
+  if (Math.abs(rotation) % 180 && !$bb39c0fc1c19b34c$var$state.isOpen) {
+    let width = $bb39c0fc1c19b34c$var$state.screenWidth;
+    let height = $bb39c0fc1c19b34c$var$state.screenHeight;
+    $bb39c0fc1c19b34c$var$state.screenWidth = height;
+    $bb39c0fc1c19b34c$var$state.screenHeight = width;
+  }
+  if (!$bb39c0fc1c19b34c$var$state.isOpen) $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+}
+function $bb39c0fc1c19b34c$var$onFocus(e) {
+  let target = $23f2114a1b82827e$export$e58f029f0fbfdb29(e);
+  let willKeyboardOpen = $bb39c0fc1c19b34c$export$c57958e35f31ed73(target);
+  let time = performance.now();
+  let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+  let delta = $bb39c0fc1c19b34c$var$state.screenHeight - screen.height;
+  if (delta < $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT && willKeyboardOpen) {
+    $bb39c0fc1c19b34c$var$state.screenWidth = screen.width;
+    $bb39c0fc1c19b34c$var$state.screenHeight = screen.height;
+    $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+    $bb39c0fc1c19b34c$var$state.startTimeStamp = time;
+  }
+  if (willKeyboardOpen) window.clearTimeout($bb39c0fc1c19b34c$var$state.screenTimeout);
+  if (delta >= $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT && willKeyboardOpen) $bb39c0fc1c19b34c$var$state.endTimeStamp = time;
+}
+function $bb39c0fc1c19b34c$var$setupGlobalEvents() {
+  let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+  $d447af545b77c9f1$export$f531f92e2a15358f(window.visualViewport, "resize", $2add3ce32c6007eb$export$78551043582a6a98() ? $bb39c0fc1c19b34c$var$onResizeEnd : $bb39c0fc1c19b34c$var$onResizeStart);
+  $d447af545b77c9f1$export$f531f92e2a15358f(window.screen.orientation, "change", $bb39c0fc1c19b34c$var$onOrientationChange);
+  $d447af545b77c9f1$export$f531f92e2a15358f(window, "focus", $bb39c0fc1c19b34c$var$onFocus, {
+    capture: true,
+    passive: true
+  });
+  $bb39c0fc1c19b34c$var$state.screenWidth = screen.width;
+  $bb39c0fc1c19b34c$var$state.screenHeight = screen.height;
+  $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+}
+if (typeof document !== "undefined") {
+  if (document.readyState !== "loading") $bb39c0fc1c19b34c$var$setupGlobalEvents();
+  else $d447af545b77c9f1$export$f531f92e2a15358f(document, "DOMContentLoaded", $bb39c0fc1c19b34c$var$setupGlobalEvents);
+}
+function $bb39c0fc1c19b34c$export$c57958e35f31ed73(target) {
+  if (!(target instanceof Element) || !$3b8b240c1bf84ab9$export$4c063cf1350e6fed(target)) return false;
+  let isTextArea = target instanceof HTMLTextAreaElement;
+  let isEditable = target instanceof HTMLElement && target.isContentEditable;
+  let isTextInput = target instanceof HTMLInputElement && !$bb39c0fc1c19b34c$var$nonTextInputTypes.has(target.type);
+  return isTextArea || isEditable || isTextInput;
+}
+function $bb39c0fc1c19b34c$export$16792effe837dba3(event) {
+  return $2add3ce32c6007eb$export$9ac100e40613ea10() ? event.metaKey : event.ctrlKey;
+}
+function $600b3cf69ae46262$export$90fc3a17d93f704c(ref, event, listener, options) {
+  let handleEvent = $fe16bffc7a557bf0$export$7f54fc3180508a52(listener);
+  let isDisabled = listener == null;
+  useEffect(() => {
+    if (isDisabled || ref.current == null) return;
+    return $d447af545b77c9f1$export$f531f92e2a15358f(ref.current, event, handleEvent, options);
+  }, [
+    ref,
+    event,
+    options,
+    isDisabled
+  ]);
+}
+class $96ead35620b8fd36$export$410b0c854570d131 {
+  constructor(ownerDocument) {
+    this._firstChild = null;
+    this._lastChild = null;
+    this._previousSibling = null;
+    this._nextSibling = null;
+    this._parentNode = null;
+    this._minInvalidChildIndex = null;
+    this.ownerDocument = ownerDocument;
+  }
+  *[Symbol.iterator]() {
+    let node = this.firstChild;
+    while (node) {
+      yield node;
+      node = node.nextSibling;
+    }
+  }
+  get firstChild() {
+    return this._firstChild;
+  }
+  set firstChild(firstChild) {
+    this._firstChild = firstChild;
+    this.ownerDocument.markDirty(this);
+  }
+  get lastChild() {
+    return this._lastChild;
+  }
+  set lastChild(lastChild) {
+    this._lastChild = lastChild;
+    this.ownerDocument.markDirty(this);
+  }
+  get previousSibling() {
+    return this._previousSibling;
+  }
+  set previousSibling(previousSibling) {
+    this._previousSibling = previousSibling;
+    this.ownerDocument.markDirty(this);
+  }
+  get nextSibling() {
+    return this._nextSibling;
+  }
+  set nextSibling(nextSibling) {
+    this._nextSibling = nextSibling;
+    this.ownerDocument.markDirty(this);
+  }
+  get parentNode() {
+    return this._parentNode;
+  }
+  set parentNode(parentNode) {
+    this._parentNode = parentNode;
+    this.ownerDocument.markDirty(this);
+  }
+  get isConnected() {
+    return this.parentNode?.isConnected || false;
+  }
+  invalidateChildIndices(child) {
+    if (this._minInvalidChildIndex == null || !this._minInvalidChildIndex.isConnected || child.index < this._minInvalidChildIndex.index) {
+      this._minInvalidChildIndex = child;
+      this.ownerDocument.markDirty(this);
+    }
+  }
+  updateChildIndices() {
+    let node = this._minInvalidChildIndex;
+    while (node) {
+      node.index = node.previousSibling ? node.previousSibling.index + 1 : 0;
+      node = node.nextSibling;
+    }
+    this._minInvalidChildIndex = null;
+  }
+  appendChild(child) {
+    if (child.parentNode) child.parentNode.removeChild(child);
+    if (this.firstChild == null) this.firstChild = child;
+    if (this.lastChild) {
+      this.lastChild.nextSibling = child;
+      child.index = this.lastChild.index + 1;
+      child.previousSibling = this.lastChild;
+    } else {
+      child.previousSibling = null;
+      child.index = 0;
+    }
+    child.parentNode = this;
+    child.nextSibling = null;
+    this.lastChild = child;
+    this.ownerDocument.markDirty(this);
+    if (this.isConnected) this.ownerDocument.queueUpdate();
+  }
+  insertBefore(newNode, referenceNode) {
+    if (referenceNode == null) return this.appendChild(newNode);
+    if (newNode.parentNode) newNode.parentNode.removeChild(newNode);
+    newNode.nextSibling = referenceNode;
+    newNode.previousSibling = referenceNode.previousSibling;
+    newNode.index = referenceNode.index - 1;
+    if (this.firstChild === referenceNode) this.firstChild = newNode;
+    else if (referenceNode.previousSibling) referenceNode.previousSibling.nextSibling = newNode;
+    referenceNode.previousSibling = newNode;
+    newNode.parentNode = referenceNode.parentNode;
+    this.invalidateChildIndices(newNode);
+    if (this.isConnected) this.ownerDocument.queueUpdate();
+  }
+  removeChild(child) {
+    if (child.parentNode !== this) return;
+    if (this._minInvalidChildIndex === child) this._minInvalidChildIndex = null;
+    if (child.nextSibling) {
+      this.invalidateChildIndices(child.nextSibling);
+      child.nextSibling.previousSibling = child.previousSibling;
+    }
+    if (child.previousSibling) child.previousSibling.nextSibling = child.nextSibling;
+    if (this.firstChild === child) this.firstChild = child.nextSibling;
+    if (this.lastChild === child) this.lastChild = child.previousSibling;
+    child.parentNode = null;
+    child.nextSibling = null;
+    child.previousSibling = null;
+    child.index = 0;
+    this.ownerDocument.markDirty(child);
+    if (this.isConnected) this.ownerDocument.queueUpdate();
+  }
+  addEventListener() {
+  }
+  removeEventListener() {
+  }
+  get previousVisibleSibling() {
+    let node = this.previousSibling;
+    while (node && node.isHidden) node = node.previousSibling;
+    return node;
+  }
+  get nextVisibleSibling() {
+    let node = this.nextSibling;
+    while (node && node.isHidden) node = node.nextSibling;
+    return node;
+  }
+  get firstVisibleChild() {
+    let node = this.firstChild;
+    while (node && node.isHidden) node = node.nextSibling;
+    return node;
+  }
+  get lastVisibleChild() {
+    let node = this.lastChild;
+    while (node && node.isHidden) node = node.previousSibling;
+    return node;
+  }
+}
+class $96ead35620b8fd36$export$dc064fe9e59310fd extends $96ead35620b8fd36$export$410b0c854570d131 {
+  constructor(type, ownerDocument) {
+    super(ownerDocument), this.nodeType = 8, this.isMutated = true, this._index = 0, this.isHidden = false;
+    this.node = null;
+  }
+  get index() {
+    return this._index;
+  }
+  set index(index) {
+    this._index = index;
+    this.ownerDocument.markDirty(this);
+  }
+  get level() {
+    if (this.parentNode instanceof $96ead35620b8fd36$export$dc064fe9e59310fd) return this.parentNode.level + (this.parentNode.node?.type === "item" ? 1 : 0);
+    return 0;
+  }
+  /**
+  * Lazily gets a mutable instance of a Node. If the node has already
+  * been cloned during this update cycle, it just returns the existing one.
+  */
+  getMutableNode() {
+    if (this.node == null) return null;
+    if (!this.isMutated) {
+      this.node = this.node.clone();
+      this.isMutated = true;
+    }
+    this.ownerDocument.markDirty(this);
+    return this.node;
+  }
+  updateNode() {
+    let nextSibling = this.nextVisibleSibling;
+    let node = this.getMutableNode();
+    if (node == null) return;
+    node.index = this.index;
+    node.level = this.level;
+    node.parentKey = this.parentNode instanceof $96ead35620b8fd36$export$dc064fe9e59310fd ? this.parentNode.node?.key ?? null : null;
+    node.prevKey = this.previousVisibleSibling?.node?.key ?? null;
+    node.nextKey = nextSibling?.node?.key ?? null;
+    node.hasChildNodes = !!this.firstChild;
+    node.firstChildKey = this.firstVisibleChild?.node?.key ?? null;
+    node.lastChildKey = this.lastVisibleChild?.node?.key ?? null;
+    if ((node.colSpan != null || node.colIndex != null) && nextSibling) {
+      let nextColIndex = (node.colIndex ?? node.index) + (node.colSpan ?? 1);
+      if (nextSibling.node != null && nextColIndex !== nextSibling.node.colIndex) {
+        let siblingNode = nextSibling.getMutableNode();
+        siblingNode.colIndex = nextColIndex;
+      }
+    }
+  }
+  setProps(obj, ref, CollectionNodeClass, rendered, render) {
+    let node;
+    let { value: value1, textValue, id, ...props } = obj;
+    if (this.node == null) {
+      node = new CollectionNodeClass(id ?? `react-aria-${++this.ownerDocument.nodeId}`);
+      this.node = node;
+    } else node = this.getMutableNode();
+    props.ref = ref;
+    node.props = props;
+    node.rendered = rendered;
+    node.render = render;
+    node.value = value1;
+    if (obj["aria-label"]) node["aria-label"] = obj["aria-label"];
+    node.textValue = textValue || (typeof props.children === "string" ? props.children : "") || obj["aria-label"] || "";
+    if (id != null && id !== node.key) throw new Error("Cannot change the id of an item");
+    if (props.colSpan != null) node.colSpan = props.colSpan;
+    if (this.isConnected) this.ownerDocument.queueUpdate();
+  }
+  get style() {
+    let element = this;
+    return {
+      get display() {
+        return element.isHidden ? "none" : "";
+      },
+      set display(value) {
+        let isHidden = value === "none";
+        if (element.isHidden !== isHidden) {
+          if (element.parentNode?.firstVisibleChild === element || element.parentNode?.lastVisibleChild === element) element.ownerDocument.markDirty(element.parentNode);
+          let prev = element.previousVisibleSibling;
+          let next = element.nextVisibleSibling;
+          if (prev) element.ownerDocument.markDirty(prev);
+          if (next) element.ownerDocument.markDirty(next);
+          element.isHidden = isHidden;
+          element.ownerDocument.markDirty(element);
+        }
+      }
+    };
+  }
+  hasAttribute() {
+  }
+  setAttribute() {
+  }
+  setAttributeNS() {
+  }
+  removeAttribute() {
+  }
+}
+class $96ead35620b8fd36$export$b34a105447964f9f extends $96ead35620b8fd36$export$410b0c854570d131 {
+  constructor(collection) {
+    super(null), this.nodeType = 11, this.ownerDocument = this, this.dirtyNodes = /* @__PURE__ */ new Set(), this.isSSR = false, this.nodeId = 0, this.nodesByProps = /* @__PURE__ */ new WeakMap(), this.keyOwners = /* @__PURE__ */ new Map(), this.nextCollection = null, this.subscriptions = /* @__PURE__ */ new Set(), this.queuedRender = false, this.inSubscription = false;
+    this.collection = collection;
+    this.nextCollection = collection;
+  }
+  get isConnected() {
+    return true;
+  }
+  createElement(type) {
+    return new $96ead35620b8fd36$export$dc064fe9e59310fd(type, this);
+  }
+  getMutableCollection() {
+    if (!this.nextCollection) this.nextCollection = this.collection.clone();
+    return this.nextCollection;
+  }
+  markDirty(node) {
+    this.dirtyNodes.add(node);
+  }
+  addNode(element) {
+    if (element.isHidden || element.node == null) return;
+    if (process.env.NODE_ENV !== "production") {
+      let key = element.node.key;
+      let owner = this.keyOwners.get(key);
+      if (owner && owner !== element) throw new Error(`Duplicate key "${String(key)}" found in collection. Every item in a collection must have a unique key.`);
+      this.keyOwners.set(key, element);
+    }
+    let collection = this.getMutableCollection();
+    if (!collection.getItem(element.node.key)) for (let child of element) this.addNode(child);
+    collection.addNode(element.node);
+  }
+  removeNode(node) {
+    for (let child of node) this.removeNode(child);
+    if (node.node) {
+      let collection = this.getMutableCollection();
+      collection.removeNode(node.node.key);
+      if (process.env.NODE_ENV !== "production" && this.keyOwners.get(node.node.key) === node) this.keyOwners.delete(node.node.key);
+    }
+  }
+  /** Finalizes the collection update, updating all nodes and freezing the collection. */
+  getCollection() {
+    if (this.inSubscription) return this.collection;
+    this.queuedRender = false;
+    this.updateCollection();
+    return this.collection;
+  }
+  updateCollection() {
+    for (let element of this.dirtyNodes) if (element instanceof $96ead35620b8fd36$export$dc064fe9e59310fd && (!element.isConnected || element.isHidden)) this.removeNode(element);
+    else element.updateChildIndices();
+    for (let element of this.dirtyNodes) if (element instanceof $96ead35620b8fd36$export$dc064fe9e59310fd) {
+      if (element.isConnected && !element.isHidden) {
+        element.updateNode();
+        this.addNode(element);
+      }
+      if (element.node) this.dirtyNodes.delete(element);
+      element.isMutated = false;
+    } else this.dirtyNodes.delete(element);
+    if (this.nextCollection) {
+      this.nextCollection.commit(this.firstVisibleChild?.node?.key ?? null, this.lastVisibleChild?.node?.key ?? null, this.isSSR);
+      if (!this.isSSR) {
+        this.collection = this.nextCollection;
+        this.nextCollection = null;
+      }
+    }
+  }
+  queueUpdate() {
+    if (this.dirtyNodes.size === 0 || this.queuedRender) return;
+    this.queuedRender = true;
+    this.inSubscription = true;
+    if (!this.isSSR) this.collection = this.collection.clone();
+    for (let fn of this.subscriptions) fn();
+    this.inSubscription = false;
+  }
+  subscribe(fn) {
+    this.subscriptions.add(fn);
+    if (this.queuedRender) fn();
+    return () => this.subscriptions.delete(fn);
+  }
+  resetAfterSSR() {
+    if (this.isSSR) {
+      this.isSSR = false;
+      this.firstChild = null;
+      this.lastChild = null;
+      this.nodeId = 0;
+      this.keyOwners.clear();
+    }
+  }
+}
+function $a80bd3e9349588e7$export$727c8fc270210f13(props) {
+  let { children, items, idScope, addIdAndValue, dependencies = [] } = props;
+  let childrenString = useMemo(() => process.env.NODE_ENV !== "production" && typeof children === "function" ? children.toString() : void 0, [
+    children
+  ]);
+  let cache = useMemo(() => /* @__PURE__ */ new WeakMap(), [
+    ...dependencies,
+    childrenString
+  ]);
+  return useMemo(() => {
+    if (items && typeof children === "function") {
+      let res = [];
+      for (let item of items) {
+        let cacheKey = $a80bd3e9349588e7$var$isWeakKey(item) ? item : null;
+        let rendered = cacheKey ? cache.get(cacheKey) : null;
+        if (!rendered) {
+          rendered = children(item);
+          let id = rendered.props.id ?? item?.key ?? item?.id;
+          if (idScope != null && rendered.props.id == null && id != null) id = idScope + ":" + id;
+          let key = id ?? res.length;
+          rendered = cloneElement(rendered, addIdAndValue ? {
+            key,
+            id,
+            value: item
+          } : {
+            key
+          });
+          if (cacheKey) cache.set(cacheKey, rendered);
+        }
+        res.push(rendered);
+      }
+      return res;
+    } else if (typeof children !== "function") return children;
+  }, [
+    children,
+    items,
+    cache,
+    idScope,
+    addIdAndValue
+  ]);
+}
+function $a80bd3e9349588e7$var$isWeakKey(value) {
+  switch (typeof value) {
+    case "object":
+      return value != null;
+    case "function":
+    case "symbol":
+      return true;
+    default:
+      return false;
+  }
+}
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production = {};
+var hasRequiredUseSyncExternalStoreShim_production;
+function requireUseSyncExternalStoreShim_production() {
+  if (hasRequiredUseSyncExternalStoreShim_production) return useSyncExternalStoreShim_production;
+  hasRequiredUseSyncExternalStoreShim_production = 1;
+  var React = React__default;
+  function is(x, y) {
+    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+  }
+  var objectIs = "function" === typeof Object.is ? Object.is : is, useState2 = React.useState, useEffect2 = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue;
+  function useSyncExternalStore$2(subscribe, getSnapshot) {
+    var value = getSnapshot(), _useState = useState2({ inst: { value, getSnapshot } }), inst = _useState[0].inst, forceUpdate = _useState[1];
+    useLayoutEffect(
+      function() {
+        inst.value = value;
+        inst.getSnapshot = getSnapshot;
+        checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+      },
+      [subscribe, value, getSnapshot]
+    );
+    useEffect2(
+      function() {
+        checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        return subscribe(function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        });
+      },
+      [subscribe]
+    );
+    useDebugValue(value);
+    return value;
+  }
+  function checkIfSnapshotChanged(inst) {
+    var latestGetSnapshot = inst.getSnapshot;
+    inst = inst.value;
+    try {
+      var nextValue = latestGetSnapshot();
+      return !objectIs(inst, nextValue);
+    } catch (error) {
+      return true;
+    }
+  }
+  function useSyncExternalStore$1(subscribe, getSnapshot) {
+    return getSnapshot();
+  }
+  var shim2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+  useSyncExternalStoreShim_production.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim2;
+  return useSyncExternalStoreShim_production;
+}
+var useSyncExternalStoreShim_development = {};
+var hasRequiredUseSyncExternalStoreShim_development;
+function requireUseSyncExternalStoreShim_development() {
+  if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+  hasRequiredUseSyncExternalStoreShim_development = 1;
+  "production" !== process.env.NODE_ENV && (function() {
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    function useSyncExternalStore$2(subscribe, getSnapshot) {
+      didWarnOld18Alpha || void 0 === React.startTransition || (didWarnOld18Alpha = true, void 0);
+      var value = getSnapshot();
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedValue = getSnapshot();
+        objectIs(value, cachedValue) || (void 0, didWarnUncachedGetSnapshot = true);
+      }
+      cachedValue = useState2({
+        inst: { value, getSnapshot }
+      });
+      var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+      useLayoutEffect(
+        function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        },
+        [subscribe, value, getSnapshot]
+      );
+      useEffect2(
+        function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          return subscribe(function() {
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          });
+        },
+        [subscribe]
+      );
+      useDebugValue(value);
+      return value;
+    }
+    function checkIfSnapshotChanged(inst) {
+      var latestGetSnapshot = inst.getSnapshot;
+      inst = inst.value;
+      try {
+        var nextValue = latestGetSnapshot();
+        return !objectIs(inst, nextValue);
+      } catch (error) {
+        return true;
+      }
+    }
+    function useSyncExternalStore$1(subscribe, getSnapshot) {
+      return getSnapshot();
+    }
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var React = React__default, objectIs = "function" === typeof Object.is ? Object.is : is, useState2 = React.useState, useEffect2 = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+    useSyncExternalStoreShim_development.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim2;
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })();
+  return useSyncExternalStoreShim_development;
+}
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim.exports;
+  hasRequiredShim = 1;
+  if (process.env.NODE_ENV === "production") {
+    shim.exports = requireUseSyncExternalStoreShim_production();
+  } else {
+    shim.exports = requireUseSyncExternalStoreShim_development();
+  }
+  return shim.exports;
+}
+var shimExports = requireShim();
+const $42ceafc619f9c3ba$var$ShallowRenderContext = /* @__PURE__ */ createContext(false);
+const $42ceafc619f9c3ba$var$CollectionDocumentContext = /* @__PURE__ */ createContext(null);
+function $42ceafc619f9c3ba$export$bf788dd355e3a401(props) {
+  let doc = useContext($42ceafc619f9c3ba$var$CollectionDocumentContext);
+  if (doc)
+    return props.content;
+  let { collection, document: document2 } = $42ceafc619f9c3ba$var$useCollectionDocument(props.createCollection);
+  return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement($d7f64c32b702fe2c$export$8dc98ba7eadeaa56, null, /* @__PURE__ */ React__default.createElement($42ceafc619f9c3ba$var$CollectionDocumentContext.Provider, {
+    value: document2
+  }, props.content)), /* @__PURE__ */ React__default.createElement($42ceafc619f9c3ba$var$CollectionInner, {
+    render: props.children,
+    collection
+  }));
+}
+function $42ceafc619f9c3ba$var$CollectionInner({ collection, render }) {
+  return render(collection);
+}
+function $42ceafc619f9c3ba$var$useSyncExternalStoreFallback(subscribe, getSnapshot, getServerSnapshot) {
+  let isSSR = $c7eafbbe1ea5834e$export$535bd6ca7f90a273();
+  let isSSRRef = useRef(isSSR);
+  isSSRRef.current = isSSR;
+  let getSnapshotWrapper = useCallback(() => {
+    return isSSRRef.current ? getServerSnapshot() : getSnapshot();
+  }, [
+    getSnapshot,
+    getServerSnapshot
+  ]);
+  return shimExports.useSyncExternalStore(subscribe, getSnapshotWrapper);
+}
+const $42ceafc619f9c3ba$var$useSyncExternalStore = typeof React__default["useSyncExternalStore"] === "function" ? React__default["useSyncExternalStore"] : $42ceafc619f9c3ba$var$useSyncExternalStoreFallback;
+function $42ceafc619f9c3ba$var$useCollectionDocument(createCollection) {
+  let [document2] = useState(() => new $96ead35620b8fd36$export$b34a105447964f9f(createCollection?.() || new $6f0c29017aeec335$export$408d25a4e12db025()));
+  let subscribe = useCallback((fn) => document2.subscribe(fn), [
+    document2
+  ]);
+  let getSnapshot = useCallback(() => {
+    let collection2 = document2.getCollection();
+    if (document2.isSSR)
+      document2.resetAfterSSR();
+    return collection2;
+  }, [
+    document2
+  ]);
+  let getServerSnapshot = useCallback(() => {
+    document2.isSSR = true;
+    return document2.getCollection();
+  }, [
+    document2
+  ]);
+  let collection = $42ceafc619f9c3ba$var$useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  return {
+    collection,
+    document: document2
+  };
+}
+const $42ceafc619f9c3ba$var$SSRContext = /* @__PURE__ */ createContext(null);
+function $42ceafc619f9c3ba$var$createCollectionNodeClass(type) {
+  var _a;
+  let NodeClass = (_a = class extends $6f0c29017aeec335$export$d68d59712b04d9d1 {
+  }, _a.type = type, _a);
+  return NodeClass;
+}
+function $42ceafc619f9c3ba$var$useSSRCollectionNode(CollectionNodeClass, props, ref, rendered, children, render) {
+  if (typeof CollectionNodeClass === "string")
+    CollectionNodeClass = $42ceafc619f9c3ba$var$createCollectionNodeClass(CollectionNodeClass);
+  let itemRef = useCallback((element) => {
+    element?.setProps(props, ref, CollectionNodeClass, rendered, render);
+  }, [
+    props,
+    ref,
+    rendered,
+    render,
+    CollectionNodeClass
+  ]);
+  let parentNode = useContext($42ceafc619f9c3ba$var$SSRContext);
+  if (parentNode) {
+    let element = parentNode.ownerDocument.nodesByProps.get(props);
+    if (!element) {
+      element = parentNode.ownerDocument.createElement(CollectionNodeClass.type);
+      element.setProps(props, ref, CollectionNodeClass, rendered, render);
+      parentNode.appendChild(element);
+      parentNode.ownerDocument.updateCollection();
+      parentNode.ownerDocument.nodesByProps.set(props, element);
+    }
+    return children ? /* @__PURE__ */ React__default.createElement($42ceafc619f9c3ba$var$SSRContext.Provider, {
+      value: element
+    }, children) : null;
+  }
+  return /* @__PURE__ */ React__default.createElement(CollectionNodeClass.type, {
+    ref: itemRef
+  }, children);
+}
+function $42ceafc619f9c3ba$export$18af5c7a9e9b3664(CollectionNodeClass, render) {
+  let Component = ({ node }) => render(node.props, node.props.ref, node);
+  let Result = forwardRef((props, ref) => {
+    let focusableProps = useContext($d1116acdf220c2da$export$f9762fab77588ecb);
+    let isShallow = useContext($42ceafc619f9c3ba$var$ShallowRenderContext);
+    if (!isShallow) {
+      if (render.length >= 3) throw new Error(render.name + " cannot be rendered outside a collection.");
+      return render(props, ref);
+    }
+    return $42ceafc619f9c3ba$var$useSSRCollectionNode(CollectionNodeClass, props, ref, "children" in props ? props.children : null, null, (node) => (
+      // Forward FocusableContext to real DOM tree so tooltips work.
+      /* @__PURE__ */ React__default.createElement($d1116acdf220c2da$export$f9762fab77588ecb.Provider, {
+        value: focusableProps
+      }, /* @__PURE__ */ React__default.createElement(Component, {
+        node
+      }))
+    ));
+  });
+  Result.displayName = render.name;
+  return Result;
+}
+function $42ceafc619f9c3ba$export$e953bb1cd0f19726(CollectionNodeClass, render, useChildren = $42ceafc619f9c3ba$var$useCollectionChildren) {
+  let Component = ({ node }) => render(node.props, node.props.ref, node);
+  let Result = forwardRef((props, ref) => {
+    let children = useChildren(props);
+    return $42ceafc619f9c3ba$var$useSSRCollectionNode(CollectionNodeClass, props, ref, null, children, (node) => /* @__PURE__ */ React__default.createElement(Component, {
+      node
+    })) ?? /* @__PURE__ */ React__default.createElement(React__default.Fragment, null);
+  });
+  Result.displayName = render.name;
+  return Result;
+}
+function $42ceafc619f9c3ba$var$useCollectionChildren(options) {
+  return $a80bd3e9349588e7$export$727c8fc270210f13({
+    ...options,
+    addIdAndValue: true
+  });
+}
+const $42ceafc619f9c3ba$var$CollectionContext = /* @__PURE__ */ createContext(null);
+function $42ceafc619f9c3ba$export$fb8073518f34e6ec(props) {
+  let ctx = useContext($42ceafc619f9c3ba$var$CollectionContext);
+  let dependencies = (ctx?.dependencies || []).concat(props.dependencies);
+  let idScope = props.idScope ?? ctx?.idScope;
+  let children = $42ceafc619f9c3ba$var$useCollectionChildren({
+    ...props,
+    idScope,
+    dependencies
+  });
+  let doc = useContext($42ceafc619f9c3ba$var$CollectionDocumentContext);
+  if (doc) children = /* @__PURE__ */ React__default.createElement($42ceafc619f9c3ba$var$CollectionRoot, null, children);
+  ctx = useMemo(
+    () => ({
+      dependencies: (
+        // oxlint-disable-next-line react-hooks/exhaustive-deps
+        dependencies
+      ),
+      idScope
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // oxlint-disable-next-line react/react-compiler, react-hooks/exhaustive-deps
+    [
+      idScope,
+      ...dependencies
+    ]
+  );
+  return /* @__PURE__ */ React__default.createElement($42ceafc619f9c3ba$var$CollectionContext.Provider, {
+    value: ctx
+  }, children);
+}
+function $42ceafc619f9c3ba$var$CollectionRoot({ children }) {
+  let doc = useContext($42ceafc619f9c3ba$var$CollectionDocumentContext);
+  let wrappedChildren = useMemo(() => /* @__PURE__ */ React__default.createElement($42ceafc619f9c3ba$var$CollectionDocumentContext.Provider, {
+    value: null
+  }, /* @__PURE__ */ React__default.createElement($42ceafc619f9c3ba$var$ShallowRenderContext.Provider, {
+    value: true
+  }, children)), [
+    children
+  ]);
+  return $c7eafbbe1ea5834e$export$535bd6ca7f90a273() ? /* @__PURE__ */ React__default.createElement($42ceafc619f9c3ba$var$SSRContext.Provider, {
+    value: doc
+  }, wrappedChildren) : /* @__PURE__ */ createPortal(wrappedChildren, doc);
+}
+const $263ab7fc0f95ccdb$export$a164736487e3f0ae = {
+  CollectionRoot({ collection, renderDropIndicator }) {
+    return $263ab7fc0f95ccdb$var$useCollectionRender(collection, null, renderDropIndicator);
+  },
+  CollectionBranch({ collection, parent, renderDropIndicator }) {
+    return $263ab7fc0f95ccdb$var$useCollectionRender(collection, parent, renderDropIndicator);
+  }
+};
+function $263ab7fc0f95ccdb$var$useCollectionRender(collection, parent, renderDropIndicator) {
+  return $a80bd3e9349588e7$export$727c8fc270210f13({
+    items: parent ? collection.getChildren(parent.key) : collection,
+    dependencies: [
+      renderDropIndicator
+    ],
+    children(node) {
+      if (node.type === "content") return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null);
+      let rendered = node.render(node);
+      if (!renderDropIndicator || node.type !== "item") return rendered;
+      return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, renderDropIndicator({
+        type: "item",
+        key: node.key,
+        dropPosition: "before"
+      }), rendered, $263ab7fc0f95ccdb$export$2dbbd341daed716d(collection, node, renderDropIndicator));
+    }
+  });
+}
+function $263ab7fc0f95ccdb$export$2dbbd341daed716d(collection, node, renderDropIndicator) {
+  let key = node.key;
+  let keyAfter = collection.getKeyAfter(key);
+  let nextItemInFlattenedCollection = keyAfter != null ? collection.getItem(keyAfter) : null;
+  while (nextItemInFlattenedCollection != null && nextItemInFlattenedCollection.type !== "item") {
+    keyAfter = collection.getKeyAfter(nextItemInFlattenedCollection.key);
+    nextItemInFlattenedCollection = keyAfter != null ? collection.getItem(keyAfter) : null;
+  }
+  let nextItemInSameLevel = node.nextKey != null ? collection.getItem(node.nextKey) : null;
+  while (nextItemInSameLevel != null && nextItemInSameLevel.type !== "item") nextItemInSameLevel = nextItemInSameLevel.nextKey != null ? collection.getItem(nextItemInSameLevel.nextKey) : null;
+  let afterIndicators = [];
+  if (nextItemInSameLevel == null) {
+    let current = node;
+    while (current?.type === "item" && (!nextItemInFlattenedCollection || current.parentKey !== nextItemInFlattenedCollection.parentKey && nextItemInFlattenedCollection.level < current.level)) {
+      let indicator = renderDropIndicator({
+        type: "item",
+        key: current.key,
+        dropPosition: "after"
+      });
+      if (/* @__PURE__ */ isValidElement(indicator)) afterIndicators.push(/* @__PURE__ */ cloneElement(indicator, {
+        key: `${current.key}-after`
+      }));
+      current = current.parentKey != null ? collection.getItem(current.parentKey) : null;
+    }
+  }
+  return afterIndicators;
+}
+const $263ab7fc0f95ccdb$export$4feb769f8ddf26c5 = /* @__PURE__ */ createContext($263ab7fc0f95ccdb$export$a164736487e3f0ae);
+function $263ab7fc0f95ccdb$export$90e00781bc59d8f9(focusedKey) {
+  return useMemo(() => focusedKey != null ? /* @__PURE__ */ new Set([
+    focusedKey
+  ]) : null, [
+    focusedKey
+  ]);
+}
+function $901761b40e390936$export$2bb74740c4e19def(node, checkForOverflow) {
+  if (!node) return false;
+  let style = window.getComputedStyle(node);
+  let root = document.scrollingElement || document.documentElement;
+  let isScrollable = /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+  if (node === root && style.overflow !== "hidden") isScrollable = true;
+  if (isScrollable && checkForOverflow) isScrollable = node.scrollHeight !== node.clientHeight || node.scrollWidth !== node.clientWidth;
+  return isScrollable;
+}
+function $76d97191f0f90600$export$94ed1c92c7beeb22(node, checkForOverflow) {
+  let parentElements = [];
+  let root = document.scrollingElement || document.documentElement;
+  while (node) {
+    if ($901761b40e390936$export$2bb74740c4e19def(node, checkForOverflow)) parentElements.push(node);
+    if (node === root) break;
+    node = node.parentElement;
+  }
+  return parentElements;
+}
+function $51a3e22a5186a962$export$53a0910f038337bd(scrollView, element, opts = {}) {
+  if (scrollView === element) return;
+  let target = element.getBoundingClientRect();
+  $51a3e22a5186a962$export$f064fd83a2c6e9ca(scrollView, element, target, opts);
+}
+function $51a3e22a5186a962$export$f064fd83a2c6e9ca(scrollView, element, target, opts = {}) {
+  let { block = "nearest", inline = "nearest" } = opts;
+  let y = scrollView.scrollTop;
+  let x = scrollView.scrollLeft;
+  let view = scrollView.getBoundingClientRect();
+  let itemStyle = window.getComputedStyle(element);
+  let viewStyle = window.getComputedStyle(scrollView);
+  let root = document.scrollingElement || document.documentElement;
+  let isRoot = scrollView === root;
+  let viewTop = scrollView === root ? 0 : view.top;
+  let viewBottom = scrollView === root ? scrollView.clientHeight : view.bottom;
+  let viewLeft = scrollView === root ? 0 : view.left;
+  let viewRight = scrollView === root ? scrollView.clientWidth : view.right;
+  let scrollMarginTop = parseFloat(itemStyle.scrollMarginTop) || 0;
+  let scrollMarginBottom = parseFloat(itemStyle.scrollMarginBottom) || 0;
+  let scrollMarginLeft = parseFloat(itemStyle.scrollMarginLeft) || 0;
+  let scrollMarginRight = parseFloat(itemStyle.scrollMarginRight) || 0;
+  let scrollPaddingTop = parseFloat(viewStyle.scrollPaddingTop) || 0;
+  let scrollPaddingBottom = parseFloat(viewStyle.scrollPaddingBottom) || 0;
+  let scrollPaddingLeft = parseFloat(viewStyle.scrollPaddingLeft) || 0;
+  let scrollPaddingRight = parseFloat(viewStyle.scrollPaddingRight) || 0;
+  let borderTopWidth = parseFloat(viewStyle.borderTopWidth) || 0;
+  let borderBottomWidth = parseFloat(viewStyle.borderBottomWidth) || 0;
+  let borderLeftWidth = parseFloat(viewStyle.borderLeftWidth) || 0;
+  let borderRightWidth = parseFloat(viewStyle.borderRightWidth) || 0;
+  let scrollAreaTop = target.top - scrollMarginTop;
+  let scrollAreaBottom = target.bottom + scrollMarginBottom;
+  let scrollAreaLeft = target.left - scrollMarginLeft;
+  let scrollAreaRight = target.right + scrollMarginRight;
+  let scrollBarOffsetX = scrollView === root ? 0 : borderLeftWidth + borderRightWidth;
+  let scrollBarOffsetY = scrollView === root ? 0 : borderTopWidth + borderBottomWidth;
+  let scrollBarWidth = scrollView === root ? 0 : scrollView.offsetWidth - scrollView.clientWidth - scrollBarOffsetX;
+  let scrollBarHeight = scrollView === root ? 0 : scrollView.offsetHeight - scrollView.clientHeight - scrollBarOffsetY;
+  let scrollPortTop = viewTop + (isRoot ? 0 : borderTopWidth) + scrollPaddingTop;
+  let scrollPortBottom = viewBottom - (isRoot ? 0 : borderBottomWidth) - scrollPaddingBottom - scrollBarHeight;
+  let scrollPortLeft = viewLeft + (isRoot ? 0 : borderLeftWidth) + scrollPaddingLeft;
+  let scrollPortRight = viewRight - (isRoot ? 0 : borderRightWidth) - scrollPaddingRight;
+  if ($2add3ce32c6007eb$export$fedb369cb70207f1() && $2add3ce32c6007eb$export$78551043582a6a98() || viewStyle.direction === "ltr") scrollPortRight -= scrollBarWidth;
+  else if (viewStyle.direction === "rtl") scrollPortLeft += scrollBarWidth;
+  let shouldScrollBlock = scrollAreaTop < scrollPortTop || scrollAreaBottom > scrollPortBottom;
+  let shouldScrollInline = scrollAreaLeft < scrollPortLeft || scrollAreaRight > scrollPortRight;
+  if (shouldScrollBlock && block === "start") y += scrollAreaTop - scrollPortTop;
+  else if (shouldScrollBlock && block === "center") y += (scrollAreaTop + scrollAreaBottom) / 2 - (scrollPortTop + scrollPortBottom) / 2;
+  else if (shouldScrollBlock && block === "end") y += scrollAreaBottom - scrollPortBottom;
+  else if (shouldScrollBlock && block === "nearest") {
+    let start = scrollAreaTop - scrollPortTop;
+    let end = scrollAreaBottom - scrollPortBottom;
+    y += Math.abs(start) <= Math.abs(end) ? start : end;
+  }
+  if (shouldScrollInline && inline === "start") x += scrollAreaLeft - scrollPortLeft;
+  else if (shouldScrollInline && inline === "center") x += (scrollAreaLeft + scrollAreaRight) / 2 - (scrollPortLeft + scrollPortRight) / 2;
+  else if (shouldScrollInline && inline === "end") x += scrollAreaRight - scrollPortRight;
+  else if (shouldScrollInline && inline === "nearest") {
+    let start = scrollAreaLeft - scrollPortLeft;
+    let end = scrollAreaRight - scrollPortRight;
+    x += Math.abs(start) <= Math.abs(end) ? start : end;
+  }
+  if (process.env.NODE_ENV === "test") {
+    scrollView.scrollLeft = x;
+    scrollView.scrollTop = y;
+    return;
+  }
+  scrollView.scrollTo({
+    left: x,
+    top: y
+  });
+}
+function $51a3e22a5186a962$export$c826860796309d1b(targetElement, opts = {}) {
+  let { containingElement } = opts;
+  if (targetElement && targetElement.isConnected) {
+    let root = document.scrollingElement || document.documentElement;
+    let isScrollPrevented = window.getComputedStyle(root).overflow === "hidden";
+    if (!isScrollPrevented) {
+      let { left: originalLeft, top: originalTop } = targetElement.getBoundingClientRect();
+      targetElement?.scrollIntoView?.({
+        block: "nearest"
+      });
+      let { left: newLeft, top: newTop } = targetElement.getBoundingClientRect();
+      if (Math.abs(originalLeft - newLeft) > 1 || Math.abs(originalTop - newTop) > 1) {
+        containingElement?.scrollIntoView?.({
+          block: "center",
+          inline: "center"
+        });
+        targetElement.scrollIntoView?.({
+          block: "nearest"
+        });
+      }
+    } else {
+      let { left: originalLeft, top: originalTop } = targetElement.getBoundingClientRect();
+      let scrollParents = $76d97191f0f90600$export$94ed1c92c7beeb22(targetElement, true);
+      for (let scrollParent of scrollParents) $51a3e22a5186a962$export$53a0910f038337bd(scrollParent, targetElement);
+      let { left: newLeft, top: newTop } = targetElement.getBoundingClientRect();
+      if (Math.abs(originalLeft - newLeft) > 1 || Math.abs(originalTop - newTop) > 1) {
+        scrollParents = containingElement ? $76d97191f0f90600$export$94ed1c92c7beeb22(containingElement, true) : [];
+        for (let scrollParent of scrollParents) $51a3e22a5186a962$export$53a0910f038337bd(scrollParent, containingElement, {
+          block: "center",
+          inline: "center"
+        });
+        for (let scrollParent of $76d97191f0f90600$export$94ed1c92c7beeb22(targetElement, true)) $51a3e22a5186a962$export$53a0910f038337bd(scrollParent, targetElement);
+      }
+    }
+  }
+}
+let $121970af65029459$var$descriptionId = 0;
+const $121970af65029459$var$descriptionNodes = /* @__PURE__ */ new Map();
+function $121970af65029459$export$f8aeda7b10753fa1(description) {
+  let [id, setId] = useState();
+  $c4867b2f328c2698$export$e5c5a5f917a5871c(() => {
+    if (!description) return;
+    let desc = $121970af65029459$var$descriptionNodes.get(description);
+    if (!desc) {
+      let id2 = `react-aria-description-${$121970af65029459$var$descriptionId++}`;
+      setId(id2);
+      let node = document.createElement("div");
+      node.id = id2;
+      node.style.display = "none";
+      node.textContent = description;
+      document.body.appendChild(node);
+      desc = {
+        refCount: 0,
+        element: node
+      };
+      $121970af65029459$var$descriptionNodes.set(description, desc);
+    } else setId(desc.element.id);
+    desc.refCount++;
+    return () => {
+      if (desc && --desc.refCount === 0) {
+        desc.element.remove();
+        $121970af65029459$var$descriptionNodes.delete(description);
+      }
+    };
+  }, [
+    description
+  ]);
+  return {
+    "aria-describedby": description ? id : void 0
+  };
+}
+const $91fe5e721c7f36c1$export$c9549807523555e0 = /* @__PURE__ */ createContext({
+  isSelected: false
+});
+const $91fe5e721c7f36c1$export$17f80983afe4e444 = /* @__PURE__ */ forwardRef(function SelectionIndicator(props, ref) {
+  [props, ref] = $7230ffa83bc0c2cf$export$29f1550f4b0d4415(props, ref, $91fe5e721c7f36c1$export$c9549807523555e0);
+  let { isSelected, ...otherProps } = props;
+  return /* @__PURE__ */ React__default.createElement($792f28e438b9ad5f$export$c34620ff8881d89f, {
+    ...otherProps,
+    ref,
+    className: props.className || "react-aria-SelectionIndicator",
+    name: "SelectionIndicator",
+    isVisible: isSelected
+  });
+});
+function $22bbea12c2567021$export$d3e3bd3e26688c04(e) {
+  return $2add3ce32c6007eb$export$e1865c3bedcd822b() ? e.altKey : e.ctrlKey;
+}
+function $22bbea12c2567021$export$c3d8340acf92597f(collectionRef, key) {
+  let selector = `[data-key="${CSS.escape(String(key))}"]`;
+  let collection = collectionRef.current?.dataset.collection;
+  if (collection) selector = `[data-collection="${CSS.escape(collection)}"]${selector}`;
+  return collectionRef.current?.querySelector(selector);
+}
+const $22bbea12c2567021$var$collectionMap = /* @__PURE__ */ new WeakMap();
+function $22bbea12c2567021$export$881eb0d9f3605d9d(collection) {
+  let id = $390e54f620492c70$export$f680877a34711e37();
+  $22bbea12c2567021$var$collectionMap.set(collection, id);
+  return id;
+}
+function $22bbea12c2567021$export$6aeb1680a0ae8741(collection) {
+  return $22bbea12c2567021$var$collectionMap.get(collection);
+}
+const $f5a4a9a3486154da$var$TYPEAHEAD_DEBOUNCE_WAIT_MS = 1e3;
+function $f5a4a9a3486154da$export$e32c88dfddc6e1d8(options) {
+  let { keyboardDelegate, selectionManager, onTypeSelect } = options;
+  let state = useRef({
+    search: "",
+    timeout: void 0
+  });
+  let onKeyDownCapture = (e) => {
+    if (state.current.search.length > 0 && e.key === " ") {
+      e.preventDefault();
+      if (!("continuePropagation" in e) || "continuePropagation" in e && !e.isPropagationStopped()) e.stopPropagation();
+      state.current.search += " ";
+      if (keyboardDelegate.getKeyForSearch != null) {
+        let key = keyboardDelegate.getKeyForSearch(state.current.search, selectionManager.focusedKey);
+        if (key == null) key = keyboardDelegate.getKeyForSearch(state.current.search);
+        if (key != null) {
+          selectionManager.setFocusedKey(key);
+          if (onTypeSelect) onTypeSelect(key);
+        }
+      }
+      clearTimeout(state.current.timeout);
+      state.current.timeout = setTimeout(() => {
+        state.current.search = "";
+      }, $f5a4a9a3486154da$var$TYPEAHEAD_DEBOUNCE_WAIT_MS);
+    }
+  };
+  let onKeyDown = (e) => {
+    let character = $f5a4a9a3486154da$var$getStringForKey(e.key);
+    if (!character || e.ctrlKey || e.metaKey || e.altKey || !$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e)) || state.current.search.length === 0 && character === " ") return;
+    state.current.search += character;
+    if (keyboardDelegate.getKeyForSearch != null) {
+      let key = keyboardDelegate.getKeyForSearch(state.current.search, selectionManager.focusedKey);
+      if (key == null) key = keyboardDelegate.getKeyForSearch(state.current.search);
+      if (key != null) {
+        selectionManager.setFocusedKey(key);
+        if (onTypeSelect) onTypeSelect(key);
+        e.preventDefault();
+        if (!("continuePropagation" in e)) e.stopPropagation();
+      } else {
+        state.current.search = "";
+        clearTimeout(state.current.timeout);
+        state.current.timeout = void 0;
+        return;
+      }
+    }
+    clearTimeout(state.current.timeout);
+    state.current.timeout = setTimeout(() => {
+      state.current.search = "";
+    }, $f5a4a9a3486154da$var$TYPEAHEAD_DEBOUNCE_WAIT_MS);
+  };
+  useEffect(() => {
+    let timeout = state.current.timeout;
+    return () => {
+      clearTimeout(timeout);
+    };
+  }, [
+    state
+  ]);
+  return {
+    typeSelectProps: {
+      // Using a capturing listener to catch the keydown event before
+      // other hooks in order to handle the Spacebar event.
+      onKeyDownCapture: keyboardDelegate.getKeyForSearch ? onKeyDownCapture : void 0,
+      onKeyDown: keyboardDelegate.getKeyForSearch ? onKeyDown : void 0
+    }
+  };
+}
+function $f5a4a9a3486154da$var$getStringForKey(key) {
+  if (key.length === 1 || !/^[A-Z]/i.test(key)) return key;
+  return "";
+}
+function $a475cdc2445827b5$export$72ef708ab07251f1(effect, dependencies) {
+  const isInitialMount = useRef(true);
+  const lastDeps = useRef(null);
+  $c4867b2f328c2698$export$e5c5a5f917a5871c(() => {
+    isInitialMount.current = true;
+    return () => {
+      isInitialMount.current = false;
+    };
+  }, []);
+  $c4867b2f328c2698$export$e5c5a5f917a5871c(() => {
+    if (isInitialMount.current) isInitialMount.current = false;
+    else if (!lastDeps.current || dependencies.some((dep, i) => !Object.is(dep, lastDeps[i]))) effect();
+    lastDeps.current = dependencies;
+  }, dependencies);
+}
+function $d667c2af82d35a98$export$d6daf82dcd84e87c(options) {
+  let { selectionManager: manager, keyboardDelegate: delegate, ref, autoFocus = false, shouldFocusWrap = false, disallowEmptySelection = false, disallowSelectAll = false, escapeKeyBehavior = "clearSelection", selectOnFocus = manager.selectionBehavior === "replace", disallowTypeAhead = false, shouldUseVirtualFocus, allowsTabNavigation = false, scrollRef = ref, linkBehavior = "action", UNSTABLE_focusOnEntry } = options;
+  let { direction } = $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7();
+  let router = $caaf0dd3060ed57c$export$9a302a45f65d0572();
+  const navigateToKey = (e, key, childFocus) => {
+    if (key != null) {
+      if (manager.isLink(key) && linkBehavior === "selection" && selectOnFocus && !$22bbea12c2567021$export$d3e3bd3e26688c04(e)) {
+        flushSync(() => {
+          manager.setFocusedKey(key, childFocus);
+        });
+        let item = $22bbea12c2567021$export$c3d8340acf92597f(ref, key);
+        let itemProps = manager.getItemProps(key);
+        if (item) {
+          router.open(item, e, itemProps.href, itemProps.routerOptions);
+          return;
+        }
+        return false;
+      }
+      manager.setFocusedKey(key, childFocus);
+      if (manager.isLink(key) && linkBehavior === "override") return false;
+      if (e.shiftKey && manager.selectionMode === "multiple") {
+        manager.extendSelection(key);
+        return;
+      } else if (selectOnFocus && !$22bbea12c2567021$export$d3e3bd3e26688c04(e)) {
+        manager.replaceSelection(key);
+        return;
+      }
+    }
+    return false;
+  };
+  let arrowDown = (e) => {
+    if (delegate.getKeyBelow) {
+      let nextKey = manager.focusedKey != null ? delegate.getKeyBelow?.(manager.focusedKey) : delegate.getFirstKey?.();
+      if (nextKey == null && shouldFocusWrap) nextKey = delegate.getFirstKey?.(manager.focusedKey);
+      if (nextKey != null) {
+        navigateToKey(e, nextKey);
+        return;
+      }
+    }
+    return false;
+  };
+  let arrowUp = (e) => {
+    if (delegate.getKeyAbove) {
+      let nextKey = manager.focusedKey != null ? delegate.getKeyAbove?.(manager.focusedKey) : delegate.getLastKey?.();
+      if (nextKey == null && shouldFocusWrap) nextKey = delegate.getLastKey?.(manager.focusedKey);
+      if (nextKey != null) {
+        navigateToKey(e, nextKey);
+        return;
+      }
+    }
+    return false;
+  };
+  let home = (e) => {
+    if (delegate.getFirstKey) {
+      if (manager.focusedKey === null && e.shiftKey) return false;
+      let firstKey2 = delegate.getFirstKey(manager.focusedKey, $bb39c0fc1c19b34c$export$16792effe837dba3(e));
+      manager.setFocusedKey(firstKey2);
+      if (firstKey2 != null) {
+        if ($bb39c0fc1c19b34c$export$16792effe837dba3(e) && e.shiftKey && manager.selectionMode === "multiple") {
+          manager.extendSelection(firstKey2);
+          return;
+        } else if (selectOnFocus) {
+          manager.replaceSelection(firstKey2);
+          return;
+        }
+      }
+    }
+    return false;
+  };
+  let arrowLeft = (e) => {
+    if (delegate.getKeyLeftOf) {
+      let nextKey = manager.focusedKey != null ? delegate.getKeyLeftOf?.(manager.focusedKey) : delegate.getFirstKey?.();
+      if (nextKey == null && shouldFocusWrap) nextKey = direction === "rtl" ? delegate.getFirstKey?.(manager.focusedKey) : delegate.getLastKey?.(manager.focusedKey);
+      if (nextKey != null) {
+        navigateToKey(e, nextKey, direction === "rtl" ? "first" : "last");
+        return;
+      }
+    }
+    return false;
+  };
+  let arrowRight = (e) => {
+    if (delegate.getKeyRightOf) {
+      let nextKey = manager.focusedKey != null ? delegate.getKeyRightOf?.(manager.focusedKey) : delegate.getFirstKey?.();
+      if (nextKey == null && shouldFocusWrap) nextKey = direction === "rtl" ? delegate.getLastKey?.(manager.focusedKey) : delegate.getFirstKey?.(manager.focusedKey);
+      if (nextKey != null) {
+        navigateToKey(e, nextKey, direction === "rtl" ? "last" : "first");
+        return;
+      }
+    }
+    return false;
+  };
+  let end = (e) => {
+    if (delegate.getLastKey) {
+      if (manager.focusedKey === null && e.shiftKey) return false;
+      let lastKey = delegate.getLastKey(manager.focusedKey, $bb39c0fc1c19b34c$export$16792effe837dba3(e));
+      manager.setFocusedKey(lastKey);
+      if (lastKey != null) {
+        if ($bb39c0fc1c19b34c$export$16792effe837dba3(e) && e.shiftKey && manager.selectionMode === "multiple") {
+          manager.extendSelection(lastKey);
+          return;
+        } else if (selectOnFocus) {
+          manager.replaceSelection(lastKey);
+          return;
+        }
+      }
+    }
+    return false;
+  };
+  let pageDown = (e) => {
+    if (delegate.getKeyPageBelow && manager.focusedKey != null) {
+      let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
+      if (nextKey != null) return navigateToKey(e, nextKey);
+    }
+    return false;
+  };
+  let pageUp = (e) => {
+    if (delegate.getKeyPageAbove && manager.focusedKey != null) {
+      let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
+      if (nextKey != null) return navigateToKey(e, nextKey);
+    }
+    return false;
+  };
+  let aHandler = () => {
+    if (manager.selectionMode === "multiple" && disallowSelectAll !== true) {
+      manager.selectAll();
+      return;
+    }
+    return false;
+  };
+  let escape = () => {
+    if (escapeKeyBehavior === "clearSelection" && !disallowEmptySelection && manager.selectedKeys.size !== 0) {
+      manager.clearSelection();
+      return;
+    }
+    return false;
+  };
+  let tab = () => {
+    if (!allowsTabNavigation && ref.current) {
+      let walker = $535772f9d2c1f38d$export$2d6ec8fc375ceafa(ref.current, {
+        tabbable: true
+      });
+      let next = void 0;
+      let last;
+      do {
+        last = walker.lastChild();
+        if (last) next = last;
+      } while (last);
+      let activeElement = $23f2114a1b82827e$export$cd4e5573fbe2b576();
+      if (next && (!$23f2114a1b82827e$export$b4f377a2b6254582(next) || activeElement && !$3b8b240c1bf84ab9$export$bebd5a1431fec25d(activeElement))) $1969ac565cfec8d0$export$de79e2c695e052f3(next);
+    }
+    return {
+      shouldContinuePropagation: true,
+      shouldPreventDefault: false
+    };
+  };
+  let shiftTab = () => {
+    if (!allowsTabNavigation && ref.current) ref.current.focus();
+    return {
+      shouldContinuePropagation: true,
+      shouldPreventDefault: false
+    };
+  };
+  let withShiftSel = (key, callback) => {
+    return {
+      [$2add3ce32c6007eb$export$9ac100e40613ea10() ? key + "+Shift+Alt" : key + "+Shift+Control"]: callback,
+      [key + "+Shift"]: callback,
+      [$2add3ce32c6007eb$export$9ac100e40613ea10() ? key + "+Alt" : key + "+Control"]: callback,
+      [key]: callback
+    };
+  };
+  let { keyboardProps: repeatKeyboardProps } = $8296dad1a4c5e0dc$export$8f71654801c2f7cd({
+    shortcuts: {
+      ...withShiftSel("ArrowDown", arrowDown),
+      ...withShiftSel("ArrowUp", arrowUp),
+      ...withShiftSel("ArrowLeft", arrowLeft),
+      ...withShiftSel("ArrowRight", arrowRight),
+      ...withShiftSel("PageDown", pageDown),
+      ...withShiftSel("PageUp", pageUp)
+    },
+    allowRepeats: true
+  });
+  let { keyboardProps } = $8296dad1a4c5e0dc$export$8f71654801c2f7cd({
+    shortcuts: {
+      ...withShiftSel("Home", home),
+      ...withShiftSel("End", end),
+      "Mod+A": aHandler,
+      Escape: escape,
+      Tab: tab,
+      "Tab+Shift": shiftTab
+    }
+  });
+  let scrollPos = useRef({
+    top: 0,
+    left: 0
+  });
+  $600b3cf69ae46262$export$90fc3a17d93f704c(scrollRef, "scroll", () => {
+    scrollPos.current = {
+      top: scrollRef.current?.scrollTop ?? 0,
+      left: scrollRef.current?.scrollLeft ?? 0
+    };
+  });
+  let onFocus = (e) => {
+    if (manager.isFocused) {
+      if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) manager.setFocused(false);
+      return;
+    }
+    if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+    let modality = $8f5a2122b0992be3$export$630ff653c5ada6a9();
+    manager.setFocused(true);
+    let navigateToKey2 = (key) => {
+      if (key != null) {
+        manager.setFocusedKey(key);
+        if (selectOnFocus && !manager.isSelected(key)) manager.replaceSelection(key);
+      }
+    };
+    if (UNSTABLE_focusOnEntry && (modality === "keyboard" || modality === "virtual"))
+      navigateToKey2(UNSTABLE_focusOnEntry === "first" ? delegate.getFirstKey?.() : delegate.getLastKey?.());
+    else if (manager.focusedKey == null) {
+      let relatedTarget = e.relatedTarget;
+      if (relatedTarget && e.currentTarget.compareDocumentPosition(relatedTarget) & Node.DOCUMENT_POSITION_FOLLOWING) navigateToKey2(manager.lastSelectedKey ?? delegate.getLastKey?.());
+      else navigateToKey2(manager.firstSelectedKey ?? delegate.getFirstKey?.());
+    } else if (scrollRef.current) {
+      scrollRef.current.scrollTop = scrollPos.current.top;
+      scrollRef.current.scrollLeft = scrollPos.current.left;
+    }
+    if (manager.focusedKey != null && scrollRef.current) {
+      let element = $22bbea12c2567021$export$c3d8340acf92597f(ref, manager.focusedKey);
+      if (element instanceof HTMLElement) {
+        if (!$23f2114a1b82827e$export$b4f377a2b6254582(element) && !shouldUseVirtualFocus) $1969ac565cfec8d0$export$de79e2c695e052f3(element);
+        if (modality === "keyboard" || UNSTABLE_focusOnEntry && modality === "virtual") $51a3e22a5186a962$export$c826860796309d1b(element, {
+          containingElement: ref.current
+        });
+      }
+    }
+  };
+  let onBlur = (e) => {
+    if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, e.relatedTarget)) manager.setFocused(false);
+  };
+  let shouldVirtualFocusFirst = useRef(false);
+  $600b3cf69ae46262$export$90fc3a17d93f704c(ref, $8b2399d051d06d4c$export$831c820ad60f9d12, !shouldUseVirtualFocus ? void 0 : (e) => {
+    let { detail } = e;
+    e.stopPropagation();
+    manager.setFocused(true);
+    if (detail?.focusStrategy === "first") shouldVirtualFocusFirst.current = true;
+  });
+  let firstKey = delegate.getFirstKey?.() ?? null;
+  $a475cdc2445827b5$export$72ef708ab07251f1(() => {
+    if (shouldVirtualFocusFirst.current) {
+      if (firstKey == null) {
+        let previousActiveElement = $23f2114a1b82827e$export$cd4e5573fbe2b576();
+        $b72f3f7b3b5f42c6$export$76e4e37e5339496d(ref.current);
+        $b72f3f7b3b5f42c6$export$2b35b76d2e30e129(previousActiveElement, null);
+        if (manager.collection.size > 0) shouldVirtualFocusFirst.current = false;
+      } else {
+        manager.setFocusedKey(firstKey);
+        shouldVirtualFocusFirst.current = false;
+      }
+    }
+  }, [
+    firstKey,
+    manager.collection.size
+  ]);
+  $a475cdc2445827b5$export$72ef708ab07251f1(() => {
+    if (manager.collection.size > 0) shouldVirtualFocusFirst.current = false;
+  }, [
+    manager.focusedKey
+  ]);
+  $600b3cf69ae46262$export$90fc3a17d93f704c(ref, $8b2399d051d06d4c$export$447a38995de2c711, !shouldUseVirtualFocus ? void 0 : (e) => {
+    e.stopPropagation();
+    manager.setFocused(false);
+    if (e.detail?.clearFocusKey) manager.setFocusedKey(null);
+  });
+  const autoFocusRef = useRef(autoFocus);
+  const didAutoFocusRef = useRef(false);
+  useEffect(() => {
+    if (autoFocusRef.current) {
+      let focusedKey = null;
+      if (autoFocus === "first") focusedKey = delegate.getFirstKey?.() ?? null;
+      if (autoFocus === "last") focusedKey = delegate.getLastKey?.() ?? null;
+      let selectedKeys = manager.selectedKeys;
+      if (selectedKeys.size) {
+        for (let key of selectedKeys) if (manager.canSelectItem(key)) {
+          focusedKey = key;
+          break;
+        }
+      }
+      manager.setFocused(true);
+      manager.setFocusedKey(focusedKey);
+      if (focusedKey != null && selectOnFocus && !selectedKeys.size && manager.canSelectItem(focusedKey)) manager.replaceSelection(focusedKey);
+      if (focusedKey == null && !shouldUseVirtualFocus && ref.current) $f192c2f16961cbe0$export$80f3e147d781571c(ref.current);
+      if (manager.collection.size > 0) {
+        autoFocusRef.current = false;
+        didAutoFocusRef.current = true;
+      }
+    }
+  });
+  let lastFocusedKey = useRef(manager.focusedKey);
+  let raf = useRef(null);
+  useEffect(() => {
+    if (manager.isFocused && manager.focusedKey != null && (manager.focusedKey !== lastFocusedKey.current || didAutoFocusRef.current) && scrollRef.current && ref.current) {
+      let modality = $8f5a2122b0992be3$export$630ff653c5ada6a9();
+      let element = $22bbea12c2567021$export$c3d8340acf92597f(ref, manager.focusedKey);
+      if (!(element instanceof HTMLElement))
+        return;
+      if (modality === "keyboard" || didAutoFocusRef.current) {
+        if (raf.current) cancelAnimationFrame(raf.current);
+        raf.current = requestAnimationFrame(() => {
+          if (scrollRef.current) {
+            $51a3e22a5186a962$export$53a0910f038337bd(scrollRef.current, element);
+            if (modality !== "virtual") $51a3e22a5186a962$export$c826860796309d1b(element, {
+              containingElement: ref.current
+            });
+          }
+        });
+      }
+    }
+    if (!shouldUseVirtualFocus && manager.isFocused && manager.focusedKey == null && lastFocusedKey.current != null && ref.current) $f192c2f16961cbe0$export$80f3e147d781571c(ref.current);
+    lastFocusedKey.current = manager.focusedKey;
+    didAutoFocusRef.current = false;
+  });
+  useEffect(() => {
+    return () => {
+      if (raf.current) cancelAnimationFrame(raf.current);
+    };
+  }, []);
+  $600b3cf69ae46262$export$90fc3a17d93f704c(ref, "react-aria-focus-scope-restore", (e) => {
+    e.preventDefault();
+    manager.setFocused(true);
+  });
+  let handlers = {
+    ...$bbaa08b3cd72f041$export$9d1611c77c2fe928(keyboardProps, repeatKeyboardProps),
+    onFocus,
+    onBlur,
+    onMouseDown(e) {
+      if (scrollRef.current === $23f2114a1b82827e$export$e58f029f0fbfdb29(e))
+        e.preventDefault();
+    }
+  };
+  let { typeSelectProps } = $f5a4a9a3486154da$export$e32c88dfddc6e1d8({
+    keyboardDelegate: delegate,
+    selectionManager: manager
+  });
+  if (!disallowTypeAhead)
+    handlers = $bbaa08b3cd72f041$export$9d1611c77c2fe928(typeSelectProps, handlers);
+  let tabIndex = void 0;
+  if (!shouldUseVirtualFocus) tabIndex = manager.focusedKey == null ? 0 : -1;
+  let collectionId = $22bbea12c2567021$export$881eb0d9f3605d9d(manager.collection);
+  return {
+    // oxlint-disable-next-line react/react-compiler
+    collectionProps: $bbaa08b3cd72f041$export$9d1611c77c2fe928(handlers, {
+      tabIndex,
+      "data-collection": collectionId
+    })
+  };
+}
+const $7b01448eaad0fe7c$var$DEFAULT_THRESHOLD = 500;
+function $7b01448eaad0fe7c$export$c24ed0104d07eab9(props) {
+  let { isDisabled, pointerType, onLongPressStart, onLongPressEnd, onLongPress, threshold = $7b01448eaad0fe7c$var$DEFAULT_THRESHOLD, accessibilityDescription } = props;
+  const timeRef = useRef(void 0);
+  let { addGlobalListener, removeAllGlobalListeners } = $48a7d519b337145d$export$4eaf04e54aa8eed6();
+  let isAcceptedPointerType = (e) => pointerType ? e.pointerType === pointerType : e.pointerType === "mouse" || e.pointerType === "touch";
+  let { pressProps } = $d27d541f9569d26d$export$45712eceda6fad21({
+    isDisabled,
+    onPressStart(e) {
+      e.continuePropagation();
+      if (isAcceptedPointerType(e)) {
+        if (onLongPressStart) onLongPressStart({
+          ...e,
+          type: "longpressstart"
+        });
+        timeRef.current = setTimeout(() => {
+          e.target.dispatchEvent(new PointerEvent("pointercancel", {
+            bubbles: true
+          }));
+          addGlobalListener(e.target, "click", (e2) => e2.preventDefault(), {
+            once: true
+          });
+          if ($d447af545b77c9f1$export$b204af158042fbac(e.target).activeElement !== e.target) $1969ac565cfec8d0$export$de79e2c695e052f3(e.target);
+          if (onLongPress) onLongPress({
+            ...e,
+            type: "longpress"
+          });
+          timeRef.current = void 0;
+        }, threshold);
+        if (e.pointerType === "touch") addGlobalListener(e.target, "contextmenu", (e2) => e2.preventDefault(), {
+          once: true
+        });
+        let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a(e.target);
+        addGlobalListener(ownerWindow, "pointerup", () => {
+          setTimeout(() => {
+            removeAllGlobalListeners();
+          }, 100);
+        }, {
+          once: true
+        });
+      }
+    },
+    onPressEnd(e) {
+      if (timeRef.current) clearTimeout(timeRef.current);
+      if (onLongPressEnd && isAcceptedPointerType(e)) onLongPressEnd({
+        ...e,
+        type: "longpressend"
+      });
+    }
+  });
+  let descriptionProps = $121970af65029459$export$f8aeda7b10753fa1(onLongPress && !isDisabled ? accessibilityDescription : void 0);
+  return {
+    longPressProps: $bbaa08b3cd72f041$export$9d1611c77c2fe928(pressProps, descriptionProps)
+  };
+}
+function $f6ba6936bfd098a0$export$ecf600387e221c37(options) {
+  let { id, selectionManager: manager, key, ref, shouldSelectOnPressUp, shouldUseVirtualFocus, focus, isDisabled, onAction, allowsDifferentPressOrigin, linkBehavior = "action" } = options;
+  let router = $caaf0dd3060ed57c$export$9a302a45f65d0572();
+  id = $390e54f620492c70$export$f680877a34711e37(id);
+  let onSelect = (e) => {
+    if (e.pointerType === "keyboard" && $22bbea12c2567021$export$d3e3bd3e26688c04(e)) manager.toggleSelection(key);
+    else {
+      if (manager.selectionMode === "none") return;
+      if (manager.isLink(key)) {
+        if (linkBehavior === "selection" && ref.current) {
+          let itemProps2 = manager.getItemProps(key);
+          router.open(ref.current, e, itemProps2.href, itemProps2.routerOptions);
+          manager.setSelectedKeys(manager.selectedKeys);
+          return;
+        } else if (linkBehavior === "override" || linkBehavior === "none") return;
+      }
+      if (manager.selectionMode === "single") {
+        if (manager.isSelected(key) && !manager.disallowEmptySelection) manager.toggleSelection(key);
+        else manager.replaceSelection(key);
+      } else if (e && e.shiftKey) manager.extendSelection(key);
+      else if (manager.selectionBehavior === "toggle" || e && ($bb39c0fc1c19b34c$export$16792effe837dba3(e) || e.pointerType === "touch" || e.pointerType === "virtual"))
+        manager.toggleSelection(key);
+      else manager.replaceSelection(key);
+    }
+  };
+  useEffect(() => {
+    let isFocused = key === manager.focusedKey;
+    if (isFocused && manager.isFocused) {
+      if (!shouldUseVirtualFocus) {
+        if (focus) focus();
+        else if ($23f2114a1b82827e$export$cd4e5573fbe2b576() !== ref.current && ref.current) $f192c2f16961cbe0$export$80f3e147d781571c(ref.current);
+      } else $b72f3f7b3b5f42c6$export$76e4e37e5339496d(ref.current);
+    }
+  }, [
+    ref,
+    key,
+    manager.focusedKey,
+    manager.childFocusStrategy,
+    manager.isFocused,
+    shouldUseVirtualFocus
+  ]);
+  isDisabled = isDisabled || manager.isDisabled(key);
+  let itemProps = {};
+  if (!shouldUseVirtualFocus && !isDisabled) itemProps = {
+    tabIndex: key === manager.focusedKey ? 0 : -1,
+    onFocus(e) {
+      if ($23f2114a1b82827e$export$e58f029f0fbfdb29(e) === ref.current) manager.setFocusedKey(key);
+    }
+  };
+  else if (isDisabled) itemProps.onMouseDown = (e) => {
+    e.preventDefault();
+  };
+  useEffect(() => {
+    if (isDisabled && manager.focusedKey === key) manager.setFocusedKey(null);
+  }, [
+    manager,
+    isDisabled,
+    key
+  ]);
+  let isLinkOverride = manager.isLink(key) && linkBehavior === "override";
+  let isActionOverride = onAction && options["UNSTABLE_itemBehavior"] === "action";
+  let hasLinkAction = manager.isLink(key) && linkBehavior !== "selection" && linkBehavior !== "none";
+  let allowsSelection = !isDisabled && manager.canSelectItem(key) && !isLinkOverride && !isActionOverride;
+  let allowsActions = (onAction || hasLinkAction) && !isDisabled;
+  let hasPrimaryAction = allowsActions && (manager.selectionBehavior === "replace" ? !allowsSelection : !allowsSelection || manager.isEmpty);
+  let hasSecondaryAction = allowsActions && allowsSelection && manager.selectionBehavior === "replace";
+  let hasAction = hasPrimaryAction || hasSecondaryAction;
+  let modality = useRef(null);
+  let longPressEnabled = hasAction && allowsSelection;
+  let longPressEnabledOnPressStart = useRef(false);
+  let hadPrimaryActionOnPressStart = useRef(false);
+  let collectionItemProps = manager.getItemProps(key);
+  let performAction = (e) => {
+    if (onAction) {
+      onAction();
+      ref.current?.dispatchEvent(new CustomEvent("react-aria-item-action", {
+        bubbles: true
+      }));
+    }
+    if (hasLinkAction && ref.current) router.open(ref.current, e, collectionItemProps.href, collectionItemProps.routerOptions);
+  };
+  let itemPressProps = {
+    ref
+  };
+  if (shouldSelectOnPressUp) {
+    itemPressProps.onPressStart = (e) => {
+      modality.current = e.pointerType;
+      longPressEnabledOnPressStart.current = longPressEnabled;
+      if (e.pointerType === "keyboard" && (!hasAction || $f6ba6936bfd098a0$var$isSelectionKey(e.key))) onSelect(e);
+    };
+    if (!allowsDifferentPressOrigin)
+      itemPressProps.onPress = (e) => {
+        if (hasPrimaryAction || hasSecondaryAction && e.pointerType !== "mouse") {
+          if (e.pointerType === "keyboard" && !$f6ba6936bfd098a0$var$isActionKey(e.key)) return;
+          performAction(e);
+        } else if (e.pointerType !== "keyboard" && allowsSelection) onSelect(e);
+      };
+    else {
+      itemPressProps.onPressUp = hasPrimaryAction ? void 0 : (e) => {
+        if (e.pointerType === "mouse" && allowsSelection) onSelect(e);
+      };
+      itemPressProps.onPress = hasPrimaryAction ? performAction : (e) => {
+        if (e.pointerType !== "keyboard" && e.pointerType !== "mouse" && allowsSelection) onSelect(e);
+      };
+    }
+  } else {
+    itemPressProps.onPressStart = (e) => {
+      modality.current = e.pointerType;
+      longPressEnabledOnPressStart.current = longPressEnabled;
+      hadPrimaryActionOnPressStart.current = hasPrimaryAction;
+      if (allowsSelection && (e.pointerType === "mouse" && !hasPrimaryAction || e.pointerType === "keyboard" && (!allowsActions || $f6ba6936bfd098a0$var$isSelectionKey(e.key)))) onSelect(e);
+    };
+    itemPressProps.onPress = (e) => {
+      if (e.pointerType === "touch" || e.pointerType === "pen" || e.pointerType === "virtual" || e.pointerType === "keyboard" && hasAction && $f6ba6936bfd098a0$var$isActionKey(e.key) || e.pointerType === "mouse" && hadPrimaryActionOnPressStart.current) {
+        if (hasAction) performAction(e);
+        else if (allowsSelection) onSelect(e);
+      }
+    };
+  }
+  let collectionId = $22bbea12c2567021$export$6aeb1680a0ae8741(manager.collection);
+  itemProps["data-collection"] = collectionId;
+  itemProps["data-key"] = key;
+  itemPressProps.preventFocusOnPress = shouldUseVirtualFocus;
+  if (shouldUseVirtualFocus)
+    itemPressProps = $bbaa08b3cd72f041$export$9d1611c77c2fe928(itemPressProps, {
+      onPressStart(e) {
+        if (e.pointerType !== "touch") {
+          manager.setFocused(true);
+          manager.setFocusedKey(key);
+        }
+      },
+      onPress(e) {
+        if (e.pointerType === "touch") {
+          manager.setFocused(true);
+          manager.setFocusedKey(key);
+        }
+      }
+    });
+  if (collectionItemProps) {
+    for (let key2 of [
+      "onPressStart",
+      "onPressEnd",
+      "onPressChange",
+      "onPress",
+      "onPressUp",
+      "onClick"
+    ]) if (collectionItemProps[key2])
+      itemPressProps[key2] = $a4e76a5424781910$export$e08e3b67e392101e(itemPressProps[key2], collectionItemProps[key2]);
+  }
+  let { pressProps, isPressed } = $d27d541f9569d26d$export$45712eceda6fad21(itemPressProps);
+  let onDoubleClick = hasSecondaryAction ? (e) => {
+    if (modality.current === "mouse") {
+      e.stopPropagation();
+      e.preventDefault();
+      performAction(e);
+    }
+  } : void 0;
+  let { longPressProps } = $7b01448eaad0fe7c$export$c24ed0104d07eab9({
+    isDisabled: !longPressEnabled,
+    onLongPress(e) {
+      if (e.pointerType === "touch") {
+        onSelect(e);
+        manager.setSelectionBehavior("toggle");
+      }
+    }
+  });
+  let onDragStartCapture = (e) => {
+    if (modality.current === "touch" && longPressEnabledOnPressStart.current) e.preventDefault();
+  };
+  let onClick = linkBehavior !== "none" && manager.isLink(key) ? (e) => {
+    if (!$caaf0dd3060ed57c$export$95185d699e05d4d7.isOpening) e.preventDefault();
+  } : void 0;
+  let mergedItemProps = $bbaa08b3cd72f041$export$9d1611c77c2fe928(
+    // oxlint-disable-next-line react/react-compiler
+    itemProps,
+    allowsSelection || hasPrimaryAction || shouldUseVirtualFocus && !isDisabled ? pressProps : {},
+    longPressEnabled ? longPressProps : {},
+    // oxlint-disable-next-line react/react-compiler
+    {
+      onDoubleClick,
+      onDragStartCapture,
+      onClick,
+      id
+    },
+    // Prevent DOM focus from moving on mouse down when using virtual focus
+    shouldUseVirtualFocus ? {
+      onMouseDown: (e) => e.preventDefault()
+    } : void 0
+  );
+  let isChildInteraction = (target) => {
+    let el = target;
+    while (el && el !== ref.current) {
+      let elCollection = el.getAttribute("data-collection");
+      if (elCollection != null) return elCollection !== collectionId;
+      el = el.parentElement;
+    }
+    return $3b8b240c1bf84ab9$export$bebd5a1431fec25d(target);
+  };
+  let baseOnPointerDown = mergedItemProps.onPointerDown;
+  mergedItemProps.onPointerDown = (e) => {
+    let target = $23f2114a1b82827e$export$e58f029f0fbfdb29(e);
+    if (target && target !== ref.current && isChildInteraction(target)) {
+      e.stopPropagation();
+      return;
+    }
+    baseOnPointerDown?.(e);
+  };
+  let baseOnMouseDown = mergedItemProps.onMouseDown;
+  mergedItemProps.onMouseDown = (e) => {
+    let target = $23f2114a1b82827e$export$e58f029f0fbfdb29(e);
+    if (target && target !== ref.current && isChildInteraction(target)) {
+      e.stopPropagation();
+      return;
+    }
+    baseOnMouseDown?.(e);
+  };
+  return {
+    itemProps: mergedItemProps,
+    isPressed,
+    isSelected: manager.isSelected(key),
+    isFocused: manager.isFocused && manager.focusedKey === key,
+    isDisabled,
+    allowsSelection,
+    hasAction
+  };
+}
+function $f6ba6936bfd098a0$var$isActionKey(key) {
+  return key === "Enter";
+}
+function $f6ba6936bfd098a0$var$isSelectionKey(key) {
+  return key === " ";
+}
+function $cd5ea4b915021f1d$export$1005530eda016c13(node, collection) {
+  if (typeof collection.getChildren === "function") return collection.getChildren(node.key);
+  return node.childNodes;
+}
+function $cd5ea4b915021f1d$export$fbdeaa6a76694f71(iterable) {
+  return $cd5ea4b915021f1d$export$5f3398f8733f90e2(iterable, 0);
+}
+function $cd5ea4b915021f1d$export$5f3398f8733f90e2(iterable, index) {
+  if (index < 0) return void 0;
+  let i = 0;
+  for (let item of iterable) {
+    if (i === index) return item;
+    i++;
+  }
+}
+function $cd5ea4b915021f1d$export$7475b2c64539e4cf(iterable) {
+  let lastItem = void 0;
+  for (let value of iterable) lastItem = value;
+  return lastItem;
+}
+function $cd5ea4b915021f1d$export$8c434b3a7a4dad6(collection, a, b) {
+  if (a.parentKey === b.parentKey) return a.index - b.index;
+  let aAncestors = [
+    ...$cd5ea4b915021f1d$var$getAncestors(collection, a),
+    a
+  ];
+  let bAncestors = [
+    ...$cd5ea4b915021f1d$var$getAncestors(collection, b),
+    b
+  ];
+  let firstNonMatchingAncestor = aAncestors.slice(0, bAncestors.length).findIndex((a2, i) => a2 !== bAncestors[i]);
+  if (firstNonMatchingAncestor !== -1) {
+    a = aAncestors[firstNonMatchingAncestor];
+    b = bAncestors[firstNonMatchingAncestor];
+    return a.index - b.index;
+  }
+  if (aAncestors.findIndex((node) => node === b) >= 0) return 1;
+  else if (bAncestors.findIndex((node) => node === a) >= 0) return -1;
+  return -1;
+}
+function $cd5ea4b915021f1d$var$getAncestors(collection, node) {
+  let parents = [];
+  let currNode = node;
+  while (currNode?.parentKey != null) {
+    currNode = collection.getItem(currNode.parentKey);
+    if (currNode) parents.unshift(currNode);
+  }
+  return parents;
+}
+function $b24d1bc31a0f941d$export$a9d04c5684123369(value) {
+  const pieces = version.split(".");
+  const major = parseInt(pieces[0], 10);
+  if (major >= 19) return value;
+  return value ? "true" : void 0;
+}
+class $8b2540e09867b15e$export$52baac22726c72bf extends Set {
+  constructor(keys, anchorKey, currentKey) {
+    super(keys);
+    if (keys instanceof $8b2540e09867b15e$export$52baac22726c72bf) {
+      this.anchorKey = anchorKey ?? keys.anchorKey;
+      this.currentKey = currentKey ?? keys.currentKey;
+    } else {
+      this.anchorKey = anchorKey ?? null;
+      this.currentKey = currentKey ?? null;
+    }
+  }
+}
+function $60f19cefd567a3e4$var$equalSets(setA, setB) {
+  if (setA.size !== setB.size) return false;
+  for (let item of setA) {
+    if (!setB.has(item)) return false;
+  }
+  return true;
+}
+function $60f19cefd567a3e4$export$253fe78d46329472(props) {
+  let { selectionMode = "none", disallowEmptySelection = false, allowDuplicateSelectionEvents, selectionBehavior: selectionBehaviorProp = "toggle", disabledBehavior = "all" } = props;
+  let isFocusedRef = useRef(false);
+  let [, setFocused] = useState(false);
+  let focusedKeyRef = useRef(null);
+  let childFocusStrategyRef = useRef(null);
+  let [, setFocusedKey] = useState(null);
+  let selectedKeysProp = useMemo(() => $60f19cefd567a3e4$var$convertSelection(props.selectedKeys), [
+    props.selectedKeys
+  ]);
+  let defaultSelectedKeys = useMemo(() => $60f19cefd567a3e4$var$convertSelection(props.defaultSelectedKeys, new $8b2540e09867b15e$export$52baac22726c72bf()), [
+    props.defaultSelectedKeys
+  ]);
+  let [selectedKeys, setSelectedKeys] = $3e6197669829fe11$export$40bfa8c7b0832715(selectedKeysProp, defaultSelectedKeys, props.onSelectionChange);
+  let disabledKeysProp = useMemo(() => props.disabledKeys ? new Set(props.disabledKeys) : /* @__PURE__ */ new Set(), [
+    props.disabledKeys
+  ]);
+  let [selectionBehavior, setSelectionBehavior] = useState(selectionBehaviorProp);
+  if (selectionBehaviorProp === "replace" && selectionBehavior === "toggle" && typeof selectedKeys === "object" && selectedKeys.size === 0) setSelectionBehavior("replace");
+  let lastSelectionBehavior = useRef(selectionBehaviorProp);
+  useEffect(() => {
+    if (selectionBehaviorProp !== lastSelectionBehavior.current) {
+      setSelectionBehavior(selectionBehaviorProp);
+      lastSelectionBehavior.current = selectionBehaviorProp;
+    }
+  }, [
+    selectionBehaviorProp
+  ]);
+  return {
+    selectionMode,
+    disallowEmptySelection,
+    selectionBehavior,
+    setSelectionBehavior,
+    get isFocused() {
+      return isFocusedRef.current;
+    },
+    setFocused(f) {
+      isFocusedRef.current = f;
+      setFocused(f);
+    },
+    get focusedKey() {
+      return focusedKeyRef.current;
+    },
+    get childFocusStrategy() {
+      return childFocusStrategyRef.current;
+    },
+    setFocusedKey(k, childFocusStrategy = "first") {
+      focusedKeyRef.current = k;
+      childFocusStrategyRef.current = childFocusStrategy;
+      setFocusedKey(k);
+    },
+    selectedKeys,
+    setSelectedKeys(keys) {
+      if (allowDuplicateSelectionEvents || !$60f19cefd567a3e4$var$equalSets(keys, selectedKeys)) setSelectedKeys(keys);
+    },
+    disabledKeys: disabledKeysProp,
+    disabledBehavior
+  };
+}
+function $60f19cefd567a3e4$var$convertSelection(selection, defaultValue) {
+  if (!selection) return defaultValue;
+  return selection === "all" ? "all" : new $8b2540e09867b15e$export$52baac22726c72bf(selection);
+}
+class $4a07ac835f260f78$export$6c8a5aaad13c9852 {
+  constructor(collection, state, options) {
+    this.collection = collection;
+    this.state = state;
+    this.allowsCellSelection = options?.allowsCellSelection ?? false;
+    this._isSelectAll = null;
+    this.layoutDelegate = options?.layoutDelegate || null;
+    this.fullCollection = options?.fullCollection || null;
+  }
+  /**
+  * The type of selection that is allowed in the collection.
+  */
+  get selectionMode() {
+    return this.state.selectionMode;
+  }
+  /**
+  * Whether the collection allows empty selection.
+  */
+  get disallowEmptySelection() {
+    return this.state.disallowEmptySelection;
+  }
+  /**
+  * The selection behavior for the collection.
+  */
+  get selectionBehavior() {
+    return this.state.selectionBehavior;
+  }
+  /**
+  * Sets the selection behavior for the collection.
+  */
+  setSelectionBehavior(selectionBehavior) {
+    this.state.setSelectionBehavior(selectionBehavior);
+  }
+  /**
+  * Whether the collection is currently focused.
+  */
+  get isFocused() {
+    return this.state.isFocused;
+  }
+  /**
+  * Sets whether the collection is focused.
+  */
+  setFocused(isFocused) {
+    this.state.setFocused(isFocused);
+  }
+  /**
+  * The current focused key in the collection.
+  */
+  get focusedKey() {
+    return this.state.focusedKey;
+  }
+  /** Whether the first or last child of the focused key should receive focus. */
+  get childFocusStrategy() {
+    return this.state.childFocusStrategy;
+  }
+  /**
+  * Sets the focused key.
+  */
+  setFocusedKey(key, childFocusStrategy) {
+    if (key == null || this.collection.getItem(key)) this.state.setFocusedKey(key, childFocusStrategy);
+  }
+  /**
+  * The currently selected keys in the collection.
+  */
+  get selectedKeys() {
+    return this.state.selectedKeys === "all" ? new Set(this.getSelectAllKeys()) : this.state.selectedKeys;
+  }
+  /**
+  * The raw selection value for the collection.
+  * Either 'all' for select all, or a set of keys.
+  */
+  get rawSelection() {
+    return this.state.selectedKeys;
+  }
+  /**
+  * Returns whether a key is selected.
+  */
+  isSelected(key) {
+    if (this.state.selectionMode === "none") return false;
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return false;
+    return this.state.selectedKeys === "all" ? this.canSelectItem(mappedKey) : this.state.selectedKeys.has(mappedKey);
+  }
+  /**
+  * Whether the selection is empty.
+  */
+  get isEmpty() {
+    return this.state.selectedKeys !== "all" && this.state.selectedKeys.size === 0;
+  }
+  /**
+  * Whether all items in the collection are selected.
+  */
+  get isSelectAll() {
+    if (this.isEmpty) return false;
+    if (this.state.selectedKeys === "all") return true;
+    if (this._isSelectAll != null) return this._isSelectAll;
+    let allKeys = this.getSelectAllKeys();
+    let selectedKeys = this.state.selectedKeys;
+    this._isSelectAll = allKeys.every((k) => selectedKeys.has(k));
+    return this._isSelectAll;
+  }
+  get firstSelectedKey() {
+    let first = null;
+    for (let key of this.state.selectedKeys) {
+      let item = this.collection.getItem(key);
+      if (!first || item && $cd5ea4b915021f1d$export$8c434b3a7a4dad6(this.collection, item, first) < 0) first = item;
+    }
+    return first?.key ?? null;
+  }
+  get lastSelectedKey() {
+    let last = null;
+    for (let key of this.state.selectedKeys) {
+      let item = this.collection.getItem(key);
+      if (!last || item && $cd5ea4b915021f1d$export$8c434b3a7a4dad6(this.collection, item, last) > 0) last = item;
+    }
+    return last?.key ?? null;
+  }
+  get disabledKeys() {
+    return this.state.disabledKeys;
+  }
+  get disabledBehavior() {
+    return this.state.disabledBehavior;
+  }
+  /**
+  * Extends the selection to the given key.
+  */
+  extendSelection(toKey) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single") {
+      this.replaceSelection(toKey);
+      return;
+    }
+    let mappedToKey = this.getKey(toKey);
+    if (mappedToKey == null) return;
+    let selection;
+    if (this.state.selectedKeys === "all") selection = new $8b2540e09867b15e$export$52baac22726c72bf([
+      mappedToKey
+    ], mappedToKey, mappedToKey);
+    else {
+      let selectedKeys = this.state.selectedKeys;
+      let anchorKey = selectedKeys.anchorKey ?? mappedToKey;
+      selection = new $8b2540e09867b15e$export$52baac22726c72bf(selectedKeys, anchorKey, mappedToKey);
+      for (let key of this.getKeyRange(anchorKey, selectedKeys.currentKey ?? mappedToKey)) selection.delete(key);
+      for (let key of this.getKeyRange(mappedToKey, anchorKey)) if (this.canSelectItem(key)) selection.add(key);
+    }
+    this.state.setSelectedKeys(selection);
+  }
+  getKeyRange(from, to) {
+    let fromItem = this.collection.getItem(from);
+    let toItem = this.collection.getItem(to);
+    if (fromItem && toItem) {
+      if ($cd5ea4b915021f1d$export$8c434b3a7a4dad6(this.collection, fromItem, toItem) <= 0) return this.getKeyRangeInternal(from, to);
+      return this.getKeyRangeInternal(to, from);
+    }
+    return [];
+  }
+  getKeyRangeInternal(from, to) {
+    if (this.layoutDelegate?.getKeyRange) return this.layoutDelegate.getKeyRange(from, to);
+    let keys = [];
+    let key = from;
+    while (key != null) {
+      let item = this.collection.getItem(key);
+      if (item && (item.type === "item" || item.type === "cell" && this.allowsCellSelection)) keys.push(key);
+      if (key === to) return keys;
+      key = this.collection.getKeyAfter(key);
+    }
+    return [];
+  }
+  getKey(key) {
+    let item = this.collection.getItem(key);
+    if (!item)
+      return key;
+    if (item.type === "cell" && this.allowsCellSelection) return key;
+    while (item && item.type !== "item" && item.parentKey != null) item = this.collection.getItem(item.parentKey);
+    if (!item || item.type !== "item") return null;
+    return item.key;
+  }
+  /**
+  * Toggles whether the given key is selected.
+  */
+  toggleSelection(key) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single" && !this.isSelected(key)) {
+      this.replaceSelection(key);
+      return;
+    }
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return;
+    let keys = new $8b2540e09867b15e$export$52baac22726c72bf(this.state.selectedKeys === "all" ? this.getSelectAllKeys() : this.state.selectedKeys);
+    if (keys.has(mappedKey)) keys.delete(mappedKey);
+    else if (this.canSelectItem(mappedKey)) {
+      keys.add(mappedKey);
+      keys.anchorKey = mappedKey;
+      keys.currentKey = mappedKey;
+    }
+    if (this.disallowEmptySelection && keys.size === 0) return;
+    this.state.setSelectedKeys(keys);
+  }
+  /**
+  * Replaces the selection with only the given key.
+  */
+  replaceSelection(key) {
+    if (this.selectionMode === "none") return;
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return;
+    let selection = this.canSelectItem(mappedKey) ? new $8b2540e09867b15e$export$52baac22726c72bf([
+      mappedKey
+    ], mappedKey, mappedKey) : new $8b2540e09867b15e$export$52baac22726c72bf();
+    this.state.setSelectedKeys(selection);
+  }
+  /**
+  * Replaces the selection with the given keys.
+  */
+  setSelectedKeys(keys) {
+    if (this.selectionMode === "none") return;
+    let selection = new $8b2540e09867b15e$export$52baac22726c72bf();
+    for (let key of keys) {
+      let mappedKey = this.getKey(key);
+      if (mappedKey != null) {
+        selection.add(mappedKey);
+        if (this.selectionMode === "single") break;
+      }
+    }
+    this.state.setSelectedKeys(selection);
+  }
+  getSelectAllKeys() {
+    let collection = this.fullCollection ?? this.collection;
+    let keys = [];
+    let addKeys = (key) => {
+      while (key != null) {
+        if (this.canSelectItemIn(key, collection)) {
+          let item = collection.getItem(key);
+          if (item?.type === "item") keys.push(key);
+          if (item?.hasChildNodes && (this.allowsCellSelection || item.type !== "item")) addKeys($cd5ea4b915021f1d$export$fbdeaa6a76694f71($cd5ea4b915021f1d$export$1005530eda016c13(item, collection))?.key ?? null);
+        }
+        key = collection.getKeyAfter(key);
+      }
+    };
+    addKeys(collection.getFirstKey());
+    return keys;
+  }
+  /**
+  * Selects all items in the collection.
+  */
+  selectAll() {
+    if (!this.isSelectAll && this.selectionMode === "multiple") this.state.setSelectedKeys("all");
+  }
+  /**
+  * Removes all keys from the selection.
+  */
+  clearSelection() {
+    if (!this.disallowEmptySelection && (this.state.selectedKeys === "all" || this.state.selectedKeys.size > 0)) this.state.setSelectedKeys(new $8b2540e09867b15e$export$52baac22726c72bf());
+  }
+  /**
+  * Toggles between select all and an empty selection.
+  */
+  toggleSelectAll() {
+    if (this.isSelectAll) this.clearSelection();
+    else this.selectAll();
+  }
+  select(key, e) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single") {
+      if (this.isSelected(key) && !this.disallowEmptySelection) this.toggleSelection(key);
+      else this.replaceSelection(key);
+    } else if (this.selectionBehavior === "toggle" || e && (e.pointerType === "touch" || e.pointerType === "virtual"))
+      this.toggleSelection(key);
+    else this.replaceSelection(key);
+  }
+  /**
+  * Returns whether the current selection is equal to the given selection.
+  */
+  isSelectionEqual(selection) {
+    if (selection === this.state.selectedKeys) return true;
+    let selectedKeys = this.selectedKeys;
+    if (selection.size !== selectedKeys.size) return false;
+    for (let key of selection) {
+      if (!selectedKeys.has(key)) return false;
+    }
+    for (let key of selectedKeys) {
+      if (!selection.has(key)) return false;
+    }
+    return true;
+  }
+  canSelectItem(key) {
+    return this.canSelectItemIn(key, this.collection);
+  }
+  canSelectItemIn(key, collection) {
+    if (this.state.selectionMode === "none" || this.state.disabledKeys.has(key)) return false;
+    let item = collection.getItem(key);
+    if (!item || item?.props?.isDisabled || item.type === "cell" && !this.allowsCellSelection) return false;
+    return true;
+  }
+  isDisabled(key) {
+    let item = this.collection.getItem(key);
+    return this.state.disabledBehavior === "all" && (this.state.disabledKeys.has(key) || !!item?.props?.isDisabled) && item?.props?.disabledBehavior !== "selection";
+  }
+  isLink(key) {
+    return !!this.collection.getItem(key)?.props?.href;
+  }
+  getItemProps(key) {
+    return this.collection.getItem(key)?.props;
+  }
+  withCollection(collection) {
+    return new $4a07ac835f260f78$export$6c8a5aaad13c9852(collection, this.state, {
+      allowsCellSelection: this.allowsCellSelection,
+      layoutDelegate: this.layoutDelegate || void 0,
+      fullCollection: this.fullCollection ?? this.collection
+    });
+  }
+}
+class $bda7a7e55e1ff206$export$bf788dd355e3a401 {
+  build(props, context) {
+    this.context = context;
+    return $bda7a7e55e1ff206$var$iterable(() => this.iterateCollection(props));
+  }
+  *iterateCollection(props) {
+    let { children, items } = props;
+    if (React__default.isValidElement(children) && children.type === React__default.Fragment) yield* this.iterateCollection({
+      children: children.props.children,
+      items
+    });
+    else if (typeof children === "function") {
+      if (!items) throw new Error("props.children was a function but props.items is missing");
+      let index = 0;
+      for (let item of items) {
+        yield* this.getFullNode({
+          value: item,
+          index
+        }, {
+          renderer: children
+        });
+        index++;
+      }
+    } else {
+      let items2 = [];
+      React__default.Children.forEach(children, (child) => {
+        if (child) items2.push(child);
+      });
+      let index = 0;
+      for (let item of items2) {
+        let nodes = this.getFullNode({
+          element: item,
+          index
+        }, {});
+        for (let node of nodes) {
+          index++;
+          yield node;
+        }
+      }
+    }
+  }
+  getKey(item, partialNode, state, parentKey) {
+    if (item.key != null) return item.key;
+    if (partialNode.type === "cell" && partialNode.key != null) return `${parentKey}${partialNode.key}`;
+    let v = partialNode.value;
+    if (v != null) {
+      let key = v.key ?? v.id;
+      if (key == null) throw new Error("No key found for item");
+      return key;
+    }
+    return parentKey ? `${parentKey}.${partialNode.index}` : `$.${partialNode.index}`;
+  }
+  getChildState(state, partialNode) {
+    return {
+      renderer: partialNode.renderer || state.renderer
+    };
+  }
+  *getFullNode(partialNode, state, parentKey, parentNode) {
+    if (React__default.isValidElement(partialNode.element) && partialNode.element.type === React__default.Fragment) {
+      let children = [];
+      React__default.Children.forEach(partialNode.element.props.children, (child) => {
+        children.push(child);
+      });
+      let index = partialNode.index ?? 0;
+      for (const child of children) yield* this.getFullNode({
+        element: child,
+        index: index++
+      }, state, parentKey, parentNode);
+      return;
+    }
+    let element = partialNode.element;
+    if (!element && partialNode.value && state && state.renderer) {
+      let cached = this.cache.get(partialNode.value);
+      if (cached && (!cached.shouldInvalidate || !cached.shouldInvalidate(this.context))) {
+        cached.index = partialNode.index;
+        cached.parentKey = parentNode ? parentNode.key : null;
+        yield cached;
+        return;
+      }
+      element = state.renderer(partialNode.value);
+    }
+    if (React__default.isValidElement(element)) {
+      let type = element.type;
+      if (typeof type !== "function" && typeof type.getCollectionNode !== "function") {
+        let name = element.type;
+        throw new Error(`Unknown element <${name}> in collection.`);
+      }
+      let childNodes = type.getCollectionNode(element.props, this.context);
+      let index = partialNode.index ?? 0;
+      let result = childNodes.next();
+      while (!result.done && result.value) {
+        let childNode = result.value;
+        partialNode.index = index;
+        let nodeKey = childNode.key ?? null;
+        if (nodeKey == null) nodeKey = childNode.element ? null : this.getKey(element, partialNode, state, parentKey);
+        let nodes = this.getFullNode({
+          ...childNode,
+          key: nodeKey,
+          index,
+          wrapper: $bda7a7e55e1ff206$var$compose(partialNode.wrapper, childNode.wrapper)
+        }, this.getChildState(state, childNode), parentKey ? `${parentKey}${element.key}` : element.key, parentNode);
+        let children = [
+          ...nodes
+        ];
+        for (let node2 of children) {
+          node2.value = childNode.value ?? partialNode.value ?? null;
+          if (node2.value) this.cache.set(node2.value, node2);
+          if (partialNode.type && node2.type !== partialNode.type) throw new Error(`Unsupported type <${$bda7a7e55e1ff206$var$capitalize(node2.type)}> in <${$bda7a7e55e1ff206$var$capitalize(parentNode?.type ?? "unknown parent type")}>. Only <${$bda7a7e55e1ff206$var$capitalize(partialNode.type)}> is supported.`);
+          index++;
+          yield node2;
+        }
+        result = childNodes.next(children);
+      }
+      return;
+    }
+    if (partialNode.key == null || partialNode.type == null) return;
+    let builder = this;
+    let node = {
+      type: partialNode.type,
+      props: partialNode.props,
+      key: partialNode.key,
+      parentKey: parentNode ? parentNode.key : null,
+      value: partialNode.value ?? null,
+      level: (parentNode?.level ?? 0) + (parentNode?.type === "item" ? 1 : 0),
+      index: partialNode.index,
+      rendered: partialNode.rendered,
+      textValue: partialNode.textValue ?? "",
+      "aria-label": partialNode["aria-label"],
+      wrapper: partialNode.wrapper,
+      shouldInvalidate: partialNode.shouldInvalidate,
+      hasChildNodes: partialNode.hasChildNodes || false,
+      childNodes: $bda7a7e55e1ff206$var$iterable(function* () {
+        if (!partialNode.hasChildNodes || !partialNode.childNodes) return;
+        let index = 0;
+        for (let child of partialNode.childNodes()) {
+          if (child.key != null)
+            child.key = `${node.key}${child.key}`;
+          let nodes = builder.getFullNode({
+            ...child,
+            index
+          }, builder.getChildState(state, child), node.key, node);
+          for (let node2 of nodes) {
+            index++;
+            yield node2;
+          }
+        }
+      })
+    };
+    yield node;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+}
+function $bda7a7e55e1ff206$var$iterable(iterator) {
+  let cache = [];
+  let iterable = null;
+  return {
+    *[Symbol.iterator]() {
+      for (let item of cache) yield item;
+      if (!iterable) iterable = iterator();
+      for (let item of iterable) {
+        cache.push(item);
+        yield item;
+      }
+    }
+  };
+}
+function $bda7a7e55e1ff206$var$compose(outer, inner) {
+  if (outer && inner) return (element) => outer(inner(element));
+  if (outer) return outer;
+  if (inner) return inner;
+}
+function $bda7a7e55e1ff206$var$capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1);
+}
+function $d03379b88399b8c5$export$6cd28814d92fa9c9(props, factory, context) {
+  let builder = useMemo(() => new $bda7a7e55e1ff206$export$bf788dd355e3a401(), []);
+  let { children, items, collection } = props;
+  let result = useMemo(() => {
+    if (collection) return collection;
+    let nodes = builder.build({
+      children,
+      items
+    }, context);
+    return factory(nodes);
+  }, [
+    builder,
+    children,
+    items,
+    collection,
+    context,
+    factory
+  ]);
+  return result;
+}
+function $bf14c9739fda2eb3$export$eac1895992b9f3d6(ref, options) {
+  let isDisabled = options?.isDisabled;
+  let [hasTabbableChild, setHasTabbableChild] = useState(false);
+  $c4867b2f328c2698$export$e5c5a5f917a5871c(() => {
+    if (ref?.current && !isDisabled) {
+      let update = () => {
+        if (ref.current) {
+          let walker = $535772f9d2c1f38d$export$2d6ec8fc375ceafa(ref.current, {
+            tabbable: true
+          });
+          setHasTabbableChild(!!walker.nextNode());
+        }
+      };
+      update();
+      let observer = new MutationObserver(update);
+      observer.observe(ref.current, {
+        subtree: true,
+        childList: true,
+        attributes: true,
+        attributeFilter: [
+          "tabIndex",
+          "disabled"
+        ]
+      });
+      return () => {
+        observer.disconnect();
+      };
+    }
+  });
+  return isDisabled ? false : hasTabbableChild;
+}
+export {
+  $60f19cefd567a3e4$export$253fe78d46329472 as $,
+  $d03379b88399b8c5$export$6cd28814d92fa9c9 as a,
+  $4a07ac835f260f78$export$6c8a5aaad13c9852 as b,
+  $f6ba6936bfd098a0$export$ecf600387e221c37 as c,
+  $bf14c9739fda2eb3$export$eac1895992b9f3d6 as d,
+  $d667c2af82d35a98$export$d6daf82dcd84e87c as e,
+  $42ceafc619f9c3ba$export$bf788dd355e3a401 as f,
+  $42ceafc619f9c3ba$export$18af5c7a9e9b3664 as g,
+  $91fe5e721c7f36c1$export$c9549807523555e0 as h,
+  $42ceafc619f9c3ba$export$fb8073518f34e6ec as i,
+  $b24d1bc31a0f941d$export$a9d04c5684123369 as j,
+  $263ab7fc0f95ccdb$export$4feb769f8ddf26c5 as k,
+  $263ab7fc0f95ccdb$export$a164736487e3f0ae as l,
+  $263ab7fc0f95ccdb$export$90e00781bc59d8f9 as m,
+  $91fe5e721c7f36c1$export$17f80983afe4e444 as n,
+  $901761b40e390936$export$2bb74740c4e19def as o,
+  $22bbea12c2567021$export$c3d8340acf92597f as p,
+  $121970af65029459$export$f8aeda7b10753fa1 as q,
+  $cd5ea4b915021f1d$export$fbdeaa6a76694f71 as r,
+  $cd5ea4b915021f1d$export$7475b2c64539e4cf as s,
+  $cd5ea4b915021f1d$export$1005530eda016c13 as t,
+  $cd5ea4b915021f1d$export$5f3398f8733f90e2 as u,
+  $51a3e22a5186a962$export$c826860796309d1b as v,
+  $42ceafc619f9c3ba$export$e953bb1cd0f19726 as w,
+  $a80bd3e9349588e7$export$727c8fc270210f13 as x
+};
+//# sourceMappingURL=useHasTabbableChild-CSJ0P5QT.js.map