mimir-ui-kit 1.15.1 → 1.15.2

package/dist/SelectSearchOption-snHM9uZX.js

@@ -1,3796 +0,0 @@
-import { jsx, jsxs } from "react/jsx-runtime";
-import { c as classNames } from "./index-CweZ_OcN.js";
-import { Icon } from "./icons/Icon.js";
-import { ESelectSearchSize } from "./components/SelectSearch/constants.js";
-import { n as n$2, u as u$3, d as o$1, s as s$3, o as o$2, p as p$1, t as t$3, e as s$4, W as W$1, y as y$3, T, H, M as M$1, a as u$5, $ as $f7dceffc5ad7768b$export$4e328f61c538687f, b as $6179b936705e76d3$export$ae780daf29e6d456, D as D$2, c as o$3 } from "./keyboard-B256ZoM-.js";
-import * as React from "react";
-import React__default, { useReducer, useMemo, useSyncExternalStore, useId as useId$1, useEffect, useCallback, useRef, useLayoutEffect, createContext, useContext, useState, Fragment, createRef } from "react";
-import * as ReactDOM from "react-dom";
-import { flushSync, createPortal } from "react-dom";
-import { w } from "./use-active-press-B6yeSopF.js";
-import { u as u$4 } from "./use-by-comparator-BUO78DGe.js";
-import { K, a as a$5, l as l$3, T as T$1, z, j as j$1, u as u$6, I as I$1, G } from "./label-C_5Syaoj.js";
-import { A, h as h$1, f as f$6, _ } from "./focus-management-1rQPII7Z.js";
-import { T as T$2 } from "./use-resolve-button-type-B6LE6gU3.js";
-import { c as c$2, i as i$2, u as u$7, V, A as A$1 } from "./open-closed-CbXq00et.js";
-import { r as r$2 } from "./bugs-CSBdWk0R.js";
-import './assets/SelectSearchOption.css';function memo(getDeps, fn, opts) {
-  let deps = opts.initialDeps ?? [];
-  let result;
-  return () => {
-    var _a, _b, _c, _d;
-    let depTime;
-    if (opts.key && ((_a = opts.debug) == null ? void 0 : _a.call(opts))) depTime = Date.now();
-    const newDeps = getDeps();
-    const depsChanged = newDeps.length !== deps.length || newDeps.some((dep, index2) => deps[index2] !== dep);
-    if (!depsChanged) {
-      return result;
-    }
-    deps = newDeps;
-    let resultTime;
-    if (opts.key && ((_b = opts.debug) == null ? void 0 : _b.call(opts))) resultTime = Date.now();
-    result = fn(...newDeps);
-    if (opts.key && ((_c = opts.debug) == null ? void 0 : _c.call(opts))) {
-      const depEndTime = Math.round((Date.now() - depTime) * 100) / 100;
-      const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100;
-      const resultFpsPercentage = resultEndTime / 16;
-      const pad = (str, num) => {
-        str = String(str);
-        while (str.length < num) {
-          str = " " + str;
-        }
-        return str;
-      };
-      console.info(
-        `%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`,
-        `
-            font-size: .6rem;
-            font-weight: bold;
-            color: hsl(${Math.max(
-          0,
-          Math.min(120 - 120 * resultFpsPercentage, 120)
-        )}deg 100% 31%);`,
-        opts == null ? void 0 : opts.key
-      );
-    }
-    (_d = opts == null ? void 0 : opts.onChange) == null ? void 0 : _d.call(opts, result);
-    return result;
-  };
-}
-function notUndefined(value, msg) {
-  if (value === void 0) {
-    throw new Error(`Unexpected undefined${""}`);
-  } else {
-    return value;
-  }
-}
-const approxEqual = (a3, b) => Math.abs(a3 - b) < 1;
-const debounce = (targetWindow, fn, ms) => {
-  let timeoutId;
-  return function(...args) {
-    targetWindow.clearTimeout(timeoutId);
-    timeoutId = targetWindow.setTimeout(() => fn.apply(this, args), ms);
-  };
-};
-const defaultKeyExtractor = (index2) => index2;
-const defaultRangeExtractor = (range) => {
-  const start = Math.max(range.startIndex - range.overscan, 0);
-  const end = Math.min(range.endIndex + range.overscan, range.count - 1);
-  const arr = [];
-  for (let i2 = start; i2 <= end; i2++) {
-    arr.push(i2);
-  }
-  return arr;
-};
-const observeElementRect = (instance, cb) => {
-  const element = instance.scrollElement;
-  if (!element) {
-    return;
-  }
-  const targetWindow = instance.targetWindow;
-  if (!targetWindow) {
-    return;
-  }
-  const handler = (rect) => {
-    const { width, height } = rect;
-    cb({ width: Math.round(width), height: Math.round(height) });
-  };
-  handler(element.getBoundingClientRect());
-  if (!targetWindow.ResizeObserver) {
-    return () => {
-    };
-  }
-  const observer = new targetWindow.ResizeObserver((entries) => {
-    const entry = entries[0];
-    if (entry == null ? void 0 : entry.borderBoxSize) {
-      const box = entry.borderBoxSize[0];
-      if (box) {
-        handler({ width: box.inlineSize, height: box.blockSize });
-        return;
-      }
-    }
-    handler(element.getBoundingClientRect());
-  });
-  observer.observe(element, { box: "border-box" });
-  return () => {
-    observer.unobserve(element);
-  };
-};
-const addEventListenerOptions = {
-  passive: true
-};
-const supportsScrollend = typeof window == "undefined" ? true : "onscrollend" in window;
-const observeElementOffset = (instance, cb) => {
-  const element = instance.scrollElement;
-  if (!element) {
-    return;
-  }
-  const targetWindow = instance.targetWindow;
-  if (!targetWindow) {
-    return;
-  }
-  let offset2 = 0;
-  const fallback = supportsScrollend ? () => void 0 : debounce(
-    targetWindow,
-    () => {
-      cb(offset2, false);
-    },
-    instance.options.isScrollingResetDelay
-  );
-  const createHandler = (isScrolling) => () => {
-    offset2 = element[instance.options.horizontal ? "scrollLeft" : "scrollTop"];
-    fallback();
-    cb(offset2, isScrolling);
-  };
-  const handler = createHandler(true);
-  const endHandler = createHandler(false);
-  endHandler();
-  element.addEventListener("scroll", handler, addEventListenerOptions);
-  element.addEventListener("scrollend", endHandler, addEventListenerOptions);
-  return () => {
-    element.removeEventListener("scroll", handler);
-    element.removeEventListener("scrollend", endHandler);
-  };
-};
-const measureElement = (element, entry, instance) => {
-  if (entry == null ? void 0 : entry.borderBoxSize) {
-    const box = entry.borderBoxSize[0];
-    if (box) {
-      const size2 = Math.round(
-        box[instance.options.horizontal ? "inlineSize" : "blockSize"]
-      );
-      return size2;
-    }
-  }
-  return Math.round(
-    element.getBoundingClientRect()[instance.options.horizontal ? "width" : "height"]
-  );
-};
-const elementScroll = (offset2, {
-  adjustments = 0,
-  behavior
-}, instance) => {
-  var _a, _b;
-  const toOffset = offset2 + adjustments;
-  (_b = (_a = instance.scrollElement) == null ? void 0 : _a.scrollTo) == null ? void 0 : _b.call(_a, {
-    [instance.options.horizontal ? "left" : "top"]: toOffset,
-    behavior
-  });
-};
-class Virtualizer {
-  constructor(opts) {
-    this.unsubs = [];
-    this.scrollElement = null;
-    this.targetWindow = null;
-    this.isScrolling = false;
-    this.scrollToIndexTimeoutId = null;
-    this.measurementsCache = [];
-    this.itemSizeCache = /* @__PURE__ */ new Map();
-    this.pendingMeasuredCacheIndexes = [];
-    this.scrollRect = null;
-    this.scrollOffset = null;
-    this.scrollDirection = null;
-    this.scrollAdjustments = 0;
-    this.elementsCache = /* @__PURE__ */ new Map();
-    this.observer = /* @__PURE__ */ (() => {
-      let _ro = null;
-      const get = () => {
-        if (_ro) {
-          return _ro;
-        }
-        if (!this.targetWindow || !this.targetWindow.ResizeObserver) {
-          return null;
-        }
-        return _ro = new this.targetWindow.ResizeObserver((entries) => {
-          entries.forEach((entry) => {
-            this._measureElement(entry.target, entry);
-          });
-        });
-      };
-      return {
-        disconnect: () => {
-          var _a;
-          return (_a = get()) == null ? void 0 : _a.disconnect();
-        },
-        observe: (target) => {
-          var _a;
-          return (_a = get()) == null ? void 0 : _a.observe(target, { box: "border-box" });
-        },
-        unobserve: (target) => {
-          var _a;
-          return (_a = get()) == null ? void 0 : _a.unobserve(target);
-        }
-      };
-    })();
-    this.range = null;
-    this.setOptions = (opts2) => {
-      Object.entries(opts2).forEach(([key, value]) => {
-        if (typeof value === "undefined") delete opts2[key];
-      });
-      this.options = {
-        debug: false,
-        initialOffset: 0,
-        overscan: 1,
-        paddingStart: 0,
-        paddingEnd: 0,
-        scrollPaddingStart: 0,
-        scrollPaddingEnd: 0,
-        horizontal: false,
-        getItemKey: defaultKeyExtractor,
-        rangeExtractor: defaultRangeExtractor,
-        onChange: () => {
-        },
-        measureElement,
-        initialRect: { width: 0, height: 0 },
-        scrollMargin: 0,
-        gap: 0,
-        indexAttribute: "data-index",
-        initialMeasurementsCache: [],
-        lanes: 1,
-        isScrollingResetDelay: 150,
-        enabled: true,
-        ...opts2
-      };
-    };
-    this.notify = (force, sync) => {
-      var _a, _b;
-      const { startIndex, endIndex } = this.range ?? {
-        startIndex: void 0,
-        endIndex: void 0
-      };
-      const range = this.calculateRange();
-      if (force || startIndex !== (range == null ? void 0 : range.startIndex) || endIndex !== (range == null ? void 0 : range.endIndex)) {
-        (_b = (_a = this.options).onChange) == null ? void 0 : _b.call(_a, this, sync);
-      }
-    };
-    this.cleanup = () => {
-      this.unsubs.filter(Boolean).forEach((d2) => d2());
-      this.unsubs = [];
-      this.scrollElement = null;
-      this.targetWindow = null;
-      this.observer.disconnect();
-      this.elementsCache.clear();
-    };
-    this._didMount = () => {
-      return () => {
-        this.cleanup();
-      };
-    };
-    this._willUpdate = () => {
-      var _a;
-      const scrollElement = this.options.enabled ? this.options.getScrollElement() : null;
-      if (this.scrollElement !== scrollElement) {
-        this.cleanup();
-        if (!scrollElement) {
-          this.notify(false, false);
-          return;
-        }
-        this.scrollElement = scrollElement;
-        if (this.scrollElement && "ownerDocument" in this.scrollElement) {
-          this.targetWindow = this.scrollElement.ownerDocument.defaultView;
-        } else {
-          this.targetWindow = ((_a = this.scrollElement) == null ? void 0 : _a.window) ?? null;
-        }
-        this._scrollToOffset(this.getScrollOffset(), {
-          adjustments: void 0,
-          behavior: void 0
-        });
-        this.unsubs.push(
-          this.options.observeElementRect(this, (rect) => {
-            this.scrollRect = rect;
-            this.notify(false, false);
-          })
-        );
-        this.unsubs.push(
-          this.options.observeElementOffset(this, (offset2, isScrolling) => {
-            this.scrollAdjustments = 0;
-            this.scrollDirection = isScrolling ? this.getScrollOffset() < offset2 ? "forward" : "backward" : null;
-            this.scrollOffset = offset2;
-            const prevIsScrolling = this.isScrolling;
-            this.isScrolling = isScrolling;
-            this.notify(prevIsScrolling !== isScrolling, isScrolling);
-          })
-        );
-      }
-    };
-    this.getSize = () => {
-      if (!this.options.enabled) {
-        this.scrollRect = null;
-        return 0;
-      }
-      this.scrollRect = this.scrollRect ?? this.options.initialRect;
-      return this.scrollRect[this.options.horizontal ? "width" : "height"];
-    };
-    this.getScrollOffset = () => {
-      if (!this.options.enabled) {
-        this.scrollOffset = null;
-        return 0;
-      }
-      this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset === "function" ? this.options.initialOffset() : this.options.initialOffset);
-      return this.scrollOffset;
-    };
-    this.getFurthestMeasurement = (measurements, index2) => {
-      const furthestMeasurementsFound = /* @__PURE__ */ new Map();
-      const furthestMeasurements = /* @__PURE__ */ new Map();
-      for (let m2 = index2 - 1; m2 >= 0; m2--) {
-        const measurement = measurements[m2];
-        if (furthestMeasurementsFound.has(measurement.lane)) {
-          continue;
-        }
-        const previousFurthestMeasurement = furthestMeasurements.get(
-          measurement.lane
-        );
-        if (previousFurthestMeasurement == null || measurement.end > previousFurthestMeasurement.end) {
-          furthestMeasurements.set(measurement.lane, measurement);
-        } else if (measurement.end < previousFurthestMeasurement.end) {
-          furthestMeasurementsFound.set(measurement.lane, true);
-        }
-        if (furthestMeasurementsFound.size === this.options.lanes) {
-          break;
-        }
-      }
-      return furthestMeasurements.size === this.options.lanes ? Array.from(furthestMeasurements.values()).sort((a3, b) => {
-        if (a3.end === b.end) {
-          return a3.index - b.index;
-        }
-        return a3.end - b.end;
-      })[0] : void 0;
-    };
-    this.getMeasurementOptions = memo(
-      () => [
-        this.options.count,
-        this.options.paddingStart,
-        this.options.scrollMargin,
-        this.options.getItemKey,
-        this.options.enabled
-      ],
-      (count2, paddingStart, scrollMargin, getItemKey, enabled) => {
-        this.pendingMeasuredCacheIndexes = [];
-        return {
-          count: count2,
-          paddingStart,
-          scrollMargin,
-          getItemKey,
-          enabled
-        };
-      },
-      {
-        key: false
-      }
-    );
-    this.getMeasurements = memo(
-      () => [this.getMeasurementOptions(), this.itemSizeCache],
-      ({ count: count2, paddingStart, scrollMargin, getItemKey, enabled }, itemSizeCache) => {
-        var _a;
-        if (!enabled) {
-          this.measurementsCache = [];
-          this.itemSizeCache.clear();
-          return [];
-        }
-        if (this.measurementsCache.length === 0) {
-          this.measurementsCache = this.options.initialMeasurementsCache;
-          this.measurementsCache.forEach((item) => {
-            this.itemSizeCache.set(item.key, item.size);
-          });
-        }
-        const min2 = this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
-        this.pendingMeasuredCacheIndexes = [];
-        const measurements = this.measurementsCache.slice(0, min2);
-        for (let i2 = min2; i2 < count2; i2++) {
-          let measureElement2 = (_a = this.measurementsCache[i2]) == null ? void 0 : _a.measureElement;
-          if (!measureElement2) {
-            measureElement2 = (node) => {
-              const key2 = getItemKey(i2);
-              const prevNode = this.elementsCache.get(key2);
-              if (!node) {
-                if (prevNode) {
-                  this.observer.unobserve(prevNode);
-                  this.elementsCache.delete(key2);
-                }
-                return;
-              }
-              if (prevNode !== node) {
-                if (prevNode) {
-                  this.observer.unobserve(prevNode);
-                }
-                this.observer.observe(node);
-                this.elementsCache.set(key2, node);
-              }
-              if (node.isConnected) {
-                this.resizeItem(
-                  i2,
-                  this.options.measureElement(node, void 0, this)
-                );
-              }
-            };
-          }
-          const key = getItemKey(i2);
-          const furthestMeasurement = this.options.lanes === 1 ? measurements[i2 - 1] : this.getFurthestMeasurement(measurements, i2);
-          const start = furthestMeasurement ? furthestMeasurement.end + this.options.gap : paddingStart + scrollMargin;
-          const measuredSize = itemSizeCache.get(key);
-          const size2 = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i2);
-          const end = start + size2;
-          const lane = furthestMeasurement ? furthestMeasurement.lane : i2 % this.options.lanes;
-          measurements[i2] = {
-            index: i2,
-            start,
-            size: size2,
-            end,
-            key,
-            lane,
-            measureElement: measureElement2
-          };
-        }
-        this.measurementsCache = measurements;
-        return measurements;
-      },
-      {
-        key: process.env.NODE_ENV !== "production" && "getMeasurements",
-        debug: () => this.options.debug
-      }
-    );
-    this.calculateRange = memo(
-      () => [this.getMeasurements(), this.getSize(), this.getScrollOffset()],
-      (measurements, outerSize, scrollOffset) => {
-        return this.range = measurements.length > 0 && outerSize > 0 ? calculateRange({
-          measurements,
-          outerSize,
-          scrollOffset
-        }) : null;
-      },
-      {
-        key: process.env.NODE_ENV !== "production" && "calculateRange",
-        debug: () => this.options.debug
-      }
-    );
-    this.getIndexes = memo(
-      () => [
-        this.options.rangeExtractor,
-        this.calculateRange(),
-        this.options.overscan,
-        this.options.count
-      ],
-      (rangeExtractor, range, overscan, count2) => {
-        return range === null ? [] : rangeExtractor({
-          startIndex: range.startIndex,
-          endIndex: range.endIndex,
-          overscan,
-          count: count2
-        });
-      },
-      {
-        key: process.env.NODE_ENV !== "production" && "getIndexes",
-        debug: () => this.options.debug
-      }
-    );
-    this.indexFromElement = (node) => {
-      const attributeName = this.options.indexAttribute;
-      const indexStr = node.getAttribute(attributeName);
-      if (!indexStr) {
-        console.warn(
-          `Missing attribute name '${attributeName}={index}' on measured element.`
-        );
-        return -1;
-      }
-      return parseInt(indexStr, 10);
-    };
-    this._measureElement = (node, entry) => {
-      const i2 = this.indexFromElement(node);
-      const item = this.getMeasurements()[i2];
-      if (!item || !node.isConnected) {
-        this.elementsCache.forEach((cached, key) => {
-          if (cached === node) {
-            this.observer.unobserve(node);
-            this.elementsCache.delete(key);
-          }
-        });
-        return;
-      }
-      const prevNode = this.elementsCache.get(item.key);
-      if (prevNode !== node) {
-        if (prevNode) {
-          this.observer.unobserve(prevNode);
-        }
-        this.observer.observe(node);
-        this.elementsCache.set(item.key, node);
-      }
-      this.resizeItem(i2, this.options.measureElement(node, entry, this));
-    };
-    this.resizeItem = (index2, size2) => {
-      const item = this.getMeasurements()[index2];
-      if (!item) {
-        return;
-      }
-      const itemSize = this.itemSizeCache.get(item.key) ?? item.size;
-      const delta = size2 - itemSize;
-      if (delta !== 0) {
-        if (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(item, delta, this) : item.start < this.getScrollOffset() + this.scrollAdjustments) {
-          if (process.env.NODE_ENV !== "production" && this.options.debug) {
-            console.info("correction", delta);
-          }
-          this._scrollToOffset(this.getScrollOffset(), {
-            adjustments: this.scrollAdjustments += delta,
-            behavior: void 0
-          });
-        }
-        this.pendingMeasuredCacheIndexes.push(item.index);
-        this.itemSizeCache = new Map(this.itemSizeCache.set(item.key, size2));
-        this.notify(true, false);
-      }
-    };
-    this.measureElement = (node) => {
-      if (!node) {
-        return;
-      }
-      this._measureElement(node, void 0);
-    };
-    this.getVirtualItems = memo(
-      () => [this.getIndexes(), this.getMeasurements()],
-      (indexes, measurements) => {
-        const virtualItems = [];
-        for (let k = 0, len = indexes.length; k < len; k++) {
-          const i2 = indexes[k];
-          const measurement = measurements[i2];
-          virtualItems.push(measurement);
-        }
-        return virtualItems;
-      },
-      {
-        key: process.env.NODE_ENV !== "production" && "getIndexes",
-        debug: () => this.options.debug
-      }
-    );
-    this.getVirtualItemForOffset = (offset2) => {
-      const measurements = this.getMeasurements();
-      if (measurements.length === 0) {
-        return void 0;
-      }
-      return notUndefined(
-        measurements[findNearestBinarySearch(
-          0,
-          measurements.length - 1,
-          (index2) => notUndefined(measurements[index2]).start,
-          offset2
-        )]
-      );
-    };
-    this.getOffsetForAlignment = (toOffset, align) => {
-      const size2 = this.getSize();
-      const scrollOffset = this.getScrollOffset();
-      if (align === "auto") {
-        if (toOffset <= scrollOffset) {
-          align = "start";
-        } else if (toOffset >= scrollOffset + size2) {
-          align = "end";
-        } else {
-          align = "start";
-        }
-      }
-      if (align === "start") {
-        toOffset = toOffset;
-      } else if (align === "end") {
-        toOffset = toOffset - size2;
-      } else if (align === "center") {
-        toOffset = toOffset - size2 / 2;
-      }
-      const scrollSizeProp = this.options.horizontal ? "scrollWidth" : "scrollHeight";
-      const scrollSize = this.scrollElement ? "document" in this.scrollElement ? this.scrollElement.document.documentElement[scrollSizeProp] : this.scrollElement[scrollSizeProp] : 0;
-      const maxOffset = scrollSize - size2;
-      return Math.max(Math.min(maxOffset, toOffset), 0);
-    };
-    this.getOffsetForIndex = (index2, align = "auto") => {
-      index2 = Math.max(0, Math.min(index2, this.options.count - 1));
-      const item = this.getMeasurements()[index2];
-      if (!item) {
-        return void 0;
-      }
-      const size2 = this.getSize();
-      const scrollOffset = this.getScrollOffset();
-      if (align === "auto") {
-        if (item.end >= scrollOffset + size2 - this.options.scrollPaddingEnd) {
-          align = "end";
-        } else if (item.start <= scrollOffset + this.options.scrollPaddingStart) {
-          align = "start";
-        } else {
-          return [scrollOffset, align];
-        }
-      }
-      const toOffset = align === "end" ? item.end + this.options.scrollPaddingEnd : item.start - this.options.scrollPaddingStart;
-      return [this.getOffsetForAlignment(toOffset, align), align];
-    };
-    this.isDynamicMode = () => this.elementsCache.size > 0;
-    this.cancelScrollToIndex = () => {
-      if (this.scrollToIndexTimeoutId !== null && this.targetWindow) {
-        this.targetWindow.clearTimeout(this.scrollToIndexTimeoutId);
-        this.scrollToIndexTimeoutId = null;
-      }
-    };
-    this.scrollToOffset = (toOffset, { align = "start", behavior } = {}) => {
-      this.cancelScrollToIndex();
-      if (behavior === "smooth" && this.isDynamicMode()) {
-        console.warn(
-          "The `smooth` scroll behavior is not fully supported with dynamic size."
-        );
-      }
-      this._scrollToOffset(this.getOffsetForAlignment(toOffset, align), {
-        adjustments: void 0,
-        behavior
-      });
-    };
-    this.scrollToIndex = (index2, { align: initialAlign = "auto", behavior } = {}) => {
-      index2 = Math.max(0, Math.min(index2, this.options.count - 1));
-      this.cancelScrollToIndex();
-      if (behavior === "smooth" && this.isDynamicMode()) {
-        console.warn(
-          "The `smooth` scroll behavior is not fully supported with dynamic size."
-        );
-      }
-      const offsetAndAlign = this.getOffsetForIndex(index2, initialAlign);
-      if (!offsetAndAlign) return;
-      const [offset2, align] = offsetAndAlign;
-      this._scrollToOffset(offset2, { adjustments: void 0, behavior });
-      if (behavior !== "smooth" && this.isDynamicMode() && this.targetWindow) {
-        this.scrollToIndexTimeoutId = this.targetWindow.setTimeout(() => {
-          this.scrollToIndexTimeoutId = null;
-          const elementInDOM = this.elementsCache.has(
-            this.options.getItemKey(index2)
-          );
-          if (elementInDOM) {
-            const [latestOffset] = notUndefined(
-              this.getOffsetForIndex(index2, align)
-            );
-            if (!approxEqual(latestOffset, this.getScrollOffset())) {
-              this.scrollToIndex(index2, { align, behavior });
-            }
-          } else {
-            this.scrollToIndex(index2, { align, behavior });
-          }
-        });
-      }
-    };
-    this.scrollBy = (delta, { behavior } = {}) => {
-      this.cancelScrollToIndex();
-      if (behavior === "smooth" && this.isDynamicMode()) {
-        console.warn(
-          "The `smooth` scroll behavior is not fully supported with dynamic size."
-        );
-      }
-      this._scrollToOffset(this.getScrollOffset() + delta, {
-        adjustments: void 0,
-        behavior
-      });
-    };
-    this.getTotalSize = () => {
-      var _a;
-      const measurements = this.getMeasurements();
-      let end;
-      if (measurements.length === 0) {
-        end = this.options.paddingStart;
-      } else {
-        end = this.options.lanes === 1 ? ((_a = measurements[measurements.length - 1]) == null ? void 0 : _a.end) ?? 0 : Math.max(
-          ...measurements.slice(-this.options.lanes).map((m2) => m2.end)
-        );
-      }
-      return end - this.options.scrollMargin + this.options.paddingEnd;
-    };
-    this._scrollToOffset = (offset2, {
-      adjustments,
-      behavior
-    }) => {
-      this.options.scrollToFn(offset2, { behavior, adjustments }, this);
-    };
-    this.measure = () => {
-      var _a, _b;
-      this.itemSizeCache = /* @__PURE__ */ new Map();
-      (_b = (_a = this.options).onChange) == null ? void 0 : _b.call(_a, this, false);
-    };
-    this.setOptions(opts);
-  }
-}
-const findNearestBinarySearch = (low, high, getCurrentValue, value) => {
-  while (low <= high) {
-    const middle = (low + high) / 2 | 0;
-    const currentValue = getCurrentValue(middle);
-    if (currentValue < value) {
-      low = middle + 1;
-    } else if (currentValue > value) {
-      high = middle - 1;
-    } else {
-      return middle;
-    }
-  }
-  if (low > 0) {
-    return low - 1;
-  } else {
-    return 0;
-  }
-};
-function calculateRange({
-  measurements,
-  outerSize,
-  scrollOffset
-}) {
-  const count2 = measurements.length - 1;
-  const getOffset = (index2) => measurements[index2].start;
-  const startIndex = findNearestBinarySearch(0, count2, getOffset, scrollOffset);
-  let endIndex = startIndex;
-  while (endIndex < count2 && measurements[endIndex].end < scrollOffset + outerSize) {
-    endIndex++;
-  }
-  return { startIndex, endIndex };
-}
-const useIsomorphicLayoutEffect = typeof document !== "undefined" ? React.useLayoutEffect : React.useEffect;
-function useVirtualizerBase(options) {
-  const rerender = React.useReducer(() => ({}), {})[1];
-  const resolvedOptions = {
-    ...options,
-    onChange: (instance2, sync) => {
-      var _a;
-      if (sync) {
-        flushSync(rerender);
-      } else {
-        rerender();
-      }
-      (_a = options.onChange) == null ? void 0 : _a.call(options, instance2, sync);
-    }
-  };
-  const [instance] = React.useState(
-    () => new Virtualizer(resolvedOptions)
-  );
-  instance.setOptions(resolvedOptions);
-  React.useEffect(() => {
-    return instance._didMount();
-  }, []);
-  useIsomorphicLayoutEffect(() => {
-    return instance._willUpdate();
-  });
-  return instance;
-}
-function useVirtualizer(options) {
-  return useVirtualizerBase({
-    observeElementRect,
-    observeElementOffset,
-    scrollToFn: elementScroll,
-    ...options
-  });
-}
-function s$2(e2) {
-  if (e2 === null) return { width: 0, height: 0 };
-  let { width: n2, height: t2 } = e2.getBoundingClientRect();
-  return { width: n2, height: t2 };
-}
-function f$5(e2, n2 = false) {
-  let t2 = e2 === null ? null : "current" in e2 ? e2.current : e2, [l2, u2] = useReducer(() => ({}), {}), r2 = useMemo(() => s$2(t2), [t2, l2]);
-  return n$2(() => {
-    if (!t2) return;
-    let i2 = new ResizeObserver(u2);
-    return i2.observe(t2), () => {
-      i2.disconnect();
-    };
-  }, [t2]), n2 ? { width: `${r2.width}px`, height: `${r2.height}px` } : r2;
-}
-let a$4 = class a extends Map {
-  constructor(t2) {
-    super();
-    this.factory = t2;
-  }
-  get(t2) {
-    let e2 = super.get(t2);
-    return e2 === void 0 && (e2 = this.factory(t2), this.set(t2, e2)), e2;
-  }
-};
-function a$3(o2, r2) {
-  let t2 = o2(), n2 = /* @__PURE__ */ new Set();
-  return { getSnapshot() {
-    return t2;
-  }, subscribe(e2) {
-    return n2.add(e2), () => n2.delete(e2);
-  }, dispatch(e2, ...s2) {
-    let i2 = r2[e2].call(t2, ...s2);
-    i2 && (t2 = i2, n2.forEach((c2) => c2()));
-  } };
-}
-function o(t2) {
-  return useSyncExternalStore(t2.subscribe, t2.getSnapshot, t2.getSnapshot);
-}
-let p = new a$4(() => a$3(() => [], { ADD(r2) {
-  return this.includes(r2) ? this : [...this, r2];
-}, REMOVE(r2) {
-  let e2 = this.indexOf(r2);
-  if (e2 === -1) return this;
-  let t2 = this.slice();
-  return t2.splice(e2, 1), t2;
-} }));
-function x(r2, e2) {
-  let t2 = p.get(e2), i2 = useId$1(), h2 = o(t2);
-  if (n$2(() => {
-    if (r2) return t2.dispatch("ADD", i2), () => t2.dispatch("REMOVE", i2);
-  }, [t2, r2]), !r2) return false;
-  let s2 = h2.indexOf(i2), o$12 = h2.length;
-  return s2 === -1 && (s2 = o$12, o$12 += 1), s2 === o$12 - 1;
-}
-let f$4 = /* @__PURE__ */ new Map(), u$2 = /* @__PURE__ */ new Map();
-function h(t2) {
-  var e2;
-  let r2 = (e2 = u$2.get(t2)) != null ? e2 : 0;
-  return u$2.set(t2, r2 + 1), r2 !== 0 ? () => m$4(t2) : (f$4.set(t2, { "aria-hidden": t2.getAttribute("aria-hidden"), inert: t2.inert }), t2.setAttribute("aria-hidden", "true"), t2.inert = true, () => m$4(t2));
-}
-function m$4(t2) {
-  var i2;
-  let r2 = (i2 = u$2.get(t2)) != null ? i2 : 1;
-  if (r2 === 1 ? u$2.delete(t2) : u$2.set(t2, r2 - 1), r2 !== 1) return;
-  let e2 = f$4.get(t2);
-  e2 && (e2["aria-hidden"] === null ? t2.removeAttribute("aria-hidden") : t2.setAttribute("aria-hidden", e2["aria-hidden"]), t2.inert = e2.inert, f$4.delete(t2));
-}
-function y$2(t2, { allowed: r2, disallowed: e2 } = {}) {
-  let i2 = x(t2, "inert-others");
-  n$2(() => {
-    var d2, c2;
-    if (!i2) return;
-    let a3 = o$1();
-    for (let n2 of (d2 = e2 == null ? void 0 : e2()) != null ? d2 : []) n2 && a3.add(h(n2));
-    let s2 = (c2 = r2 == null ? void 0 : r2()) != null ? c2 : [];
-    for (let n2 of s2) {
-      if (!n2) continue;
-      let l2 = u$3(n2);
-      if (!l2) continue;
-      let o2 = n2.parentElement;
-      for (; o2 && o2 !== l2.body; ) {
-        for (let p2 of o2.children) s2.some((E2) => p2.contains(E2)) || a3.add(h(p2));
-        o2 = o2.parentElement;
-      }
-    }
-    return a3.dispose;
-  }, [i2, r2, e2]);
-}
-function m$3(s2, n2, l2) {
-  let i2 = s$3((t2) => {
-    let e2 = t2.getBoundingClientRect();
-    e2.x === 0 && e2.y === 0 && e2.width === 0 && e2.height === 0 && l2();
-  });
-  useEffect(() => {
-    if (!s2) return;
-    let t2 = n2 === null ? null : n2 instanceof HTMLElement ? n2 : n2.current;
-    if (!t2) return;
-    let e2 = o$1();
-    if (typeof ResizeObserver != "undefined") {
-      let r2 = new ResizeObserver(() => i2.current(t2));
-      r2.observe(t2), e2.add(() => r2.disconnect());
-    }
-    if (typeof IntersectionObserver != "undefined") {
-      let r2 = new IntersectionObserver(() => i2.current(t2));
-      r2.observe(t2), e2.add(() => r2.disconnect());
-    }
-    return () => e2.dispose();
-  }, [n2, i2, s2]);
-}
-function t$2() {
-  return /iPhone/gi.test(window.navigator.platform) || /Mac/gi.test(window.navigator.platform) && window.navigator.maxTouchPoints > 0;
-}
-function i$1() {
-  return /Android/gi.test(window.navigator.userAgent);
-}
-function n$1() {
-  return t$2() || i$1();
-}
-function i(t2, e2, o2, n2) {
-  let u2 = s$3(o2);
-  useEffect(() => {
-    if (!t2) return;
-    function r2(m2) {
-      u2.current(m2);
-    }
-    return document.addEventListener(e2, r2, n2), () => document.removeEventListener(e2, r2, n2);
-  }, [t2, e2, n2]);
-}
-function s$1(t2, e2, o2, n2) {
-  let i2 = s$3(o2);
-  useEffect(() => {
-    if (!t2) return;
-    function r2(d2) {
-      i2.current(d2);
-    }
-    return window.addEventListener(e2, r2, n2), () => window.removeEventListener(e2, r2, n2);
-  }, [t2, e2, n2]);
-}
-const d$2 = 30;
-function F$1(E2, p2, C) {
-  let u2 = x(E2, "outside-click"), f2 = s$3(C), s2 = useCallback(function(e2, o2) {
-    if (e2.defaultPrevented) return;
-    let r2 = o2(e2);
-    if (r2 === null || !r2.getRootNode().contains(r2) || !r2.isConnected) return;
-    let T2 = function i2(n2) {
-      return typeof n2 == "function" ? i2(n2()) : Array.isArray(n2) || n2 instanceof Set ? n2 : [n2];
-    }(p2);
-    for (let i2 of T2) {
-      if (i2 === null) continue;
-      let n2 = i2 instanceof HTMLElement ? i2 : i2.current;
-      if (n2 != null && n2.contains(r2) || e2.composed && e2.composedPath().includes(n2)) return;
-    }
-    return !A(r2, h$1.Loose) && r2.tabIndex !== -1 && e2.preventDefault(), f2.current(e2, r2);
-  }, [f2]), l2 = useRef(null);
-  i(u2, "pointerdown", (t2) => {
-    var e2, o2;
-    l2.current = ((o2 = (e2 = t2.composedPath) == null ? void 0 : e2.call(t2)) == null ? void 0 : o2[0]) || t2.target;
-  }, true), i(u2, "mousedown", (t2) => {
-    var e2, o2;
-    l2.current = ((o2 = (e2 = t2.composedPath) == null ? void 0 : e2.call(t2)) == null ? void 0 : o2[0]) || t2.target;
-  }, true), i(u2, "click", (t2) => {
-    n$1() || l2.current && (s2(t2, () => l2.current), l2.current = null);
-  }, true);
-  let a3 = useRef({ x: 0, y: 0 });
-  i(u2, "touchstart", (t2) => {
-    a3.current.x = t2.touches[0].clientX, a3.current.y = t2.touches[0].clientY;
-  }, true), i(u2, "touchend", (t2) => {
-    let e2 = { x: t2.changedTouches[0].clientX, y: t2.changedTouches[0].clientY };
-    if (!(Math.abs(e2.x - a3.current.x) >= d$2 || Math.abs(e2.y - a3.current.y) >= d$2)) return s2(t2, () => t2.target instanceof HTMLElement ? t2.target : null);
-  }, true), s$1(u2, "blur", (t2) => s2(t2, () => window.document.activeElement instanceof HTMLIFrameElement ? window.document.activeElement : null), true);
-}
-function n(...e2) {
-  return useMemo(() => u$3(...e2), [...e2]);
-}
-function E(n2, e2, a3, t2) {
-  let i2 = s$3(a3);
-  useEffect(() => {
-    n2 = n2 != null ? n2 : window;
-    function r2(o2) {
-      i2.current(o2);
-    }
-    return n2.addEventListener(e2, r2, t2), () => n2.removeEventListener(e2, r2, t2);
-  }, [n2, e2, t2]);
-}
-function f$3(l2) {
-  let n2 = useRef({ value: "", selectionStart: null, selectionEnd: null });
-  return E(l2.current, "blur", (e2) => {
-    let t2 = e2.target;
-    t2 instanceof HTMLInputElement && (n2.current = { value: t2.value, selectionStart: t2.selectionStart, selectionEnd: t2.selectionEnd });
-  }), o$2(() => {
-    let e2 = l2.current;
-    if (document.activeElement !== e2 && e2 instanceof HTMLInputElement && e2.isConnected) {
-      if (e2.focus({ preventScroll: true }), e2.value !== n2.current.value) e2.setSelectionRange(e2.value.length, e2.value.length);
-      else {
-        let { selectionStart: t2, selectionEnd: u2 } = n2.current;
-        t2 !== null && u2 !== null && e2.setSelectionRange(t2, u2);
-      }
-      n2.current = { value: "", selectionStart: null, selectionEnd: null };
-    }
-  });
-}
-function d$1() {
-  let r2;
-  return { before({ doc: e2 }) {
-    var l2;
-    let o2 = e2.documentElement, t2 = (l2 = e2.defaultView) != null ? l2 : window;
-    r2 = Math.max(0, t2.innerWidth - o2.clientWidth);
-  }, after({ doc: e2, d: o2 }) {
-    let t2 = e2.documentElement, l2 = Math.max(0, t2.clientWidth - t2.offsetWidth), n2 = Math.max(0, r2 - l2);
-    o2.style(t2, "paddingRight", `${n2}px`);
-  } };
-}
-function d() {
-  return t$2() ? { before({ doc: r2, d: n2, meta: c2 }) {
-    function o2(a3) {
-      return c2.containers.flatMap((l2) => l2()).some((l2) => l2.contains(a3));
-    }
-    n2.microTask(() => {
-      var s2;
-      if (window.getComputedStyle(r2.documentElement).scrollBehavior !== "auto") {
-        let t2 = o$1();
-        t2.style(r2.documentElement, "scrollBehavior", "auto"), n2.add(() => n2.microTask(() => t2.dispose()));
-      }
-      let a3 = (s2 = window.scrollY) != null ? s2 : window.pageYOffset, l2 = null;
-      n2.addEventListener(r2, "click", (t2) => {
-        if (t2.target instanceof HTMLElement) try {
-          let e2 = t2.target.closest("a");
-          if (!e2) return;
-          let { hash: f2 } = new URL(e2.href), i2 = r2.querySelector(f2);
-          i2 && !o2(i2) && (l2 = i2);
-        } catch {
-        }
-      }, true), n2.addEventListener(r2, "touchstart", (t2) => {
-        if (t2.target instanceof HTMLElement) if (o2(t2.target)) {
-          let e2 = t2.target;
-          for (; e2.parentElement && o2(e2.parentElement); ) e2 = e2.parentElement;
-          n2.style(e2, "overscrollBehavior", "contain");
-        } else n2.style(t2.target, "touchAction", "none");
-      }), n2.addEventListener(r2, "touchmove", (t2) => {
-        if (t2.target instanceof HTMLElement) {
-          if (t2.target.tagName === "INPUT") return;
-          if (o2(t2.target)) {
-            let e2 = t2.target;
-            for (; e2.parentElement && e2.dataset.headlessuiPortal !== "" && !(e2.scrollHeight > e2.clientHeight || e2.scrollWidth > e2.clientWidth); ) e2 = e2.parentElement;
-            e2.dataset.headlessuiPortal === "" && t2.preventDefault();
-          } else t2.preventDefault();
-        }
-      }, { passive: false }), n2.add(() => {
-        var e2;
-        let t2 = (e2 = window.scrollY) != null ? e2 : window.pageYOffset;
-        a3 !== t2 && window.scrollTo(0, a3), l2 && l2.isConnected && (l2.scrollIntoView({ block: "nearest" }), l2 = null);
-      });
-    });
-  } } : {};
-}
-function r$1() {
-  return { before({ doc: e2, d: o2 }) {
-    o2.style(e2.documentElement, "overflow", "hidden");
-  } };
-}
-function m$2(e2) {
-  let n2 = {};
-  for (let t2 of e2) Object.assign(n2, t2(n2));
-  return n2;
-}
-let a$2 = a$3(() => /* @__PURE__ */ new Map(), { PUSH(e2, n2) {
-  var o2;
-  let t2 = (o2 = this.get(e2)) != null ? o2 : { doc: e2, count: 0, d: o$1(), meta: /* @__PURE__ */ new Set() };
-  return t2.count++, t2.meta.add(n2), this.set(e2, t2), this;
-}, POP(e2, n2) {
-  let t2 = this.get(e2);
-  return t2 && (t2.count--, t2.meta.delete(n2)), this;
-}, SCROLL_PREVENT({ doc: e2, d: n2, meta: t2 }) {
-  let o2 = { doc: e2, d: n2, meta: m$2(t2) }, c2 = [d(), d$1(), r$1()];
-  c2.forEach(({ before: r2 }) => r2 == null ? void 0 : r2(o2)), c2.forEach(({ after: r2 }) => r2 == null ? void 0 : r2(o2));
-}, SCROLL_ALLOW({ d: e2 }) {
-  e2.dispose();
-}, TEARDOWN({ doc: e2 }) {
-  this.delete(e2);
-} });
-a$2.subscribe(() => {
-  let e2 = a$2.getSnapshot(), n2 = /* @__PURE__ */ new Map();
-  for (let [t2] of e2) n2.set(t2, t2.documentElement.style.overflow);
-  for (let t2 of e2.values()) {
-    let o2 = n2.get(t2.doc) === "hidden", c2 = t2.count !== 0;
-    (c2 && !o2 || !c2 && o2) && a$2.dispatch(t2.count > 0 ? "SCROLL_PREVENT" : "SCROLL_ALLOW", t2), t2.count === 0 && a$2.dispatch("TEARDOWN", t2);
-  }
-});
-function a$1(r2, e2, n2 = () => ({ containers: [] })) {
-  let f2 = o(a$2), o$12 = e2 ? f2.get(e2) : void 0, i2 = o$12 ? o$12.count > 0 : false;
-  return n$2(() => {
-    if (!(!e2 || !r2)) return a$2.dispatch("PUSH", e2, n2), () => a$2.dispatch("POP", e2, n2);
-  }, [r2, e2]), i2;
-}
-function f$2(e2, c2, n2 = () => [document.body]) {
-  let r2 = x(e2, "scroll-lock");
-  a$1(r2, c2, (t2) => {
-    var o2;
-    return { containers: [...(o2 = t2.containers) != null ? o2 : [], n2] };
-  });
-}
-function t$1(e2) {
-  return [e2.screenX, e2.screenY];
-}
-function u$1() {
-  let e2 = useRef([-1, -1]);
-  return { wasMoved(r2) {
-    let n2 = t$1(r2);
-    return e2.current[0] === n2[0] && e2.current[1] === n2[1] ? false : (e2.current = n2, true);
-  }, update(r2) {
-    e2.current = t$1(r2);
-  } };
-}
-function F(c2, { container: e2, accept: t2, walk: r2 }) {
-  let o2 = useRef(t2), l2 = useRef(r2);
-  useEffect(() => {
-    o2.current = t2, l2.current = r2;
-  }, [t2, r2]), n$2(() => {
-    if (!e2 || !c2) return;
-    let n2 = u$3(e2);
-    if (!n2) return;
-    let f2 = o2.current, p2 = l2.current, i2 = Object.assign((m2) => f2(m2), { acceptNode: f2 }), u2 = n2.createTreeWalker(e2, NodeFilter.SHOW_ELEMENT, i2, false);
-    for (; u2.nextNode(); ) p2(u2.currentNode);
-  }, [e2, c2, o2, l2]);
-}
-function m$1(u2, t2) {
-  let e2 = useRef([]), r2 = o$2(u2);
-  useEffect(() => {
-    let o2 = [...e2.current];
-    for (let [a3, l2] of t2.entries()) if (e2.current[a3] !== l2) {
-      let n2 = r2(t2, o2);
-      return e2.current = t2, n2;
-    }
-  }, [r2, ...t2]);
-}
-function getNodeName(node) {
-  if (isNode(node)) {
-    return (node.nodeName || "").toLowerCase();
-  }
-  return "#document";
-}
-function getWindow(node) {
-  var _node$ownerDocument;
-  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
-}
-function getDocumentElement(node) {
-  var _ref;
-  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
-}
-function isNode(value) {
-  return value instanceof Node || value instanceof getWindow(value).Node;
-}
-function isElement(value) {
-  return value instanceof Element || value instanceof getWindow(value).Element;
-}
-function isHTMLElement(value) {
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
-}
-function isShadowRoot(value) {
-  if (typeof ShadowRoot === "undefined") {
-    return false;
-  }
-  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
-}
-function isOverflowElement(element) {
-  const {
-    overflow,
-    overflowX,
-    overflowY,
-    display
-  } = getComputedStyle$1(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
-}
-function isTableElement(element) {
-  return ["table", "td", "th"].includes(getNodeName(element));
-}
-function isTopLayer(element) {
-  return [":popover-open", ":modal"].some((selector) => {
-    try {
-      return element.matches(selector);
-    } catch (e2) {
-      return false;
-    }
-  });
-}
-function isContainingBlock(element) {
-  const webkit = isWebKit();
-  const css = getComputedStyle$1(element);
-  return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
-}
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    if (isTopLayer(currentNode)) {
-      return null;
-    }
-    if (isContainingBlock(currentNode)) {
-      return currentNode;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  return null;
-}
-function isWebKit() {
-  if (typeof CSS === "undefined" || !CSS.supports) return false;
-  return CSS.supports("-webkit-backdrop-filter", "none");
-}
-function isLastTraversableNode(node) {
-  return ["html", "body", "#document"].includes(getNodeName(node));
-}
-function getComputedStyle$1(element) {
-  return getWindow(element).getComputedStyle(element);
-}
-function getNodeScroll(element) {
-  if (isElement(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.scrollX,
-    scrollTop: element.scrollY
-  };
-}
-function getParentNode(node) {
-  if (getNodeName(node) === "html") {
-    return node;
-  }
-  const result = (
-    // Step into the shadow DOM of the parent of a slotted node.
-    node.assignedSlot || // DOM Element detected.
-    node.parentNode || // ShadowRoot detected.
-    isShadowRoot(node) && node.host || // Fallback.
-    getDocumentElement(node)
-  );
-  return isShadowRoot(result) ? result.host : result;
-}
-function getNearestOverflowAncestor(node) {
-  const parentNode = getParentNode(node);
-  if (isLastTraversableNode(parentNode)) {
-    return node.ownerDocument ? node.ownerDocument.body : node.body;
-  }
-  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
-    return parentNode;
-  }
-  return getNearestOverflowAncestor(parentNode);
-}
-function getOverflowAncestors(node, list, traverseIframes) {
-  var _node$ownerDocument2;
-  if (list === void 0) {
-    list = [];
-  }
-  if (traverseIframes === void 0) {
-    traverseIframes = true;
-  }
-  const scrollableAncestor = getNearestOverflowAncestor(node);
-  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
-  const win = getWindow(scrollableAncestor);
-  if (isBody) {
-    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
-  }
-  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
-}
-function getUserAgent() {
-  const uaData = navigator.userAgentData;
-  if (uaData && Array.isArray(uaData.brands)) {
-    return uaData.brands.map((_ref) => {
-      let {
-        brand,
-        version
-      } = _ref;
-      return brand + "/" + version;
-    }).join(" ");
-  }
-  return navigator.userAgent;
-}
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const floor = Math.floor;
-const createCoords = (v2) => ({
-  x: v2,
-  y: v2
-});
-const oppositeSideMap = {
-  left: "right",
-  right: "left",
-  bottom: "top",
-  top: "bottom"
-};
-const oppositeAlignmentMap = {
-  start: "end",
-  end: "start"
-};
-function clamp(start, value, end) {
-  return max(start, min(value, end));
-}
-function evaluate(value, param) {
-  return typeof value === "function" ? value(param) : value;
-}
-function getSide(placement) {
-  return placement.split("-")[0];
-}
-function getAlignment(placement) {
-  return placement.split("-")[1];
-}
-function getOppositeAxis(axis) {
-  return axis === "x" ? "y" : "x";
-}
-function getAxisLength(axis) {
-  return axis === "y" ? "height" : "width";
-}
-function getSideAxis(placement) {
-  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
-}
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
-}
-function getAlignmentSides(placement, rects, rtl) {
-  if (rtl === void 0) {
-    rtl = false;
-  }
-  const alignment = getAlignment(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const length = getAxisLength(alignmentAxis);
-  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
-  if (rects.reference[length] > rects.floating[length]) {
-    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-  }
-  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
-}
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-function getOppositeAlignmentPlacement(placement) {
-  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
-}
-function getSideList(side, isStart, rtl) {
-  const lr = ["left", "right"];
-  const rl = ["right", "left"];
-  const tb = ["top", "bottom"];
-  const bt = ["bottom", "top"];
-  switch (side) {
-    case "top":
-    case "bottom":
-      if (rtl) return isStart ? rl : lr;
-      return isStart ? lr : rl;
-    case "left":
-    case "right":
-      return isStart ? tb : bt;
-    default:
-      return [];
-  }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list = getSideList(getSide(placement), direction === "start", rtl);
-  if (alignment) {
-    list = list.map((side) => side + "-" + alignment);
-    if (flipAlignment) {
-      list = list.concat(list.map(getOppositeAlignmentPlacement));
-    }
-  }
-  return list;
-}
-function getOppositePlacement(placement) {
-  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
-}
-function expandPaddingObject(padding) {
-  return {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0,
-    ...padding
-  };
-}
-function getPaddingObject(padding) {
-  return typeof padding !== "number" ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
-  };
-}
-function rectToClientRect(rect) {
-  const {
-    x: x2,
-    y: y2,
-    width,
-    height
-  } = rect;
-  return {
-    width,
-    height,
-    top: y2,
-    left: x2,
-    right: x2 + width,
-    bottom: y2 + height,
-    x: x2,
-    y: y2
-  };
-}
-function computeCoordsFromPlacement(_ref, placement, rtl) {
-  let {
-    reference,
-    floating
-  } = _ref;
-  const sideAxis = getSideAxis(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const alignLength = getAxisLength(alignmentAxis);
-  const side = getSide(placement);
-  const isVertical = sideAxis === "y";
-  const commonX = reference.x + reference.width / 2 - floating.width / 2;
-  const commonY = reference.y + reference.height / 2 - floating.height / 2;
-  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
-  let coords;
-  switch (side) {
-    case "top":
-      coords = {
-        x: commonX,
-        y: reference.y - floating.height
-      };
-      break;
-    case "bottom":
-      coords = {
-        x: commonX,
-        y: reference.y + reference.height
-      };
-      break;
-    case "right":
-      coords = {
-        x: reference.x + reference.width,
-        y: commonY
-      };
-      break;
-    case "left":
-      coords = {
-        x: reference.x - floating.width,
-        y: commonY
-      };
-      break;
-    default:
-      coords = {
-        x: reference.x,
-        y: reference.y
-      };
-  }
-  switch (getAlignment(placement)) {
-    case "start":
-      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
-      break;
-    case "end":
-      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
-      break;
-  }
-  return coords;
-}
-const computePosition$1 = async (reference, floating, config) => {
-  const {
-    placement = "bottom",
-    strategy = "absolute",
-    middleware = [],
-    platform: platform2
-  } = config;
-  const validMiddleware = middleware.filter(Boolean);
-  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
-  let rects = await platform2.getElementRects({
-    reference,
-    floating,
-    strategy
-  });
-  let {
-    x: x2,
-    y: y2
-  } = computeCoordsFromPlacement(rects, placement, rtl);
-  let statefulPlacement = placement;
-  let middlewareData = {};
-  let resetCount = 0;
-  for (let i2 = 0; i2 < validMiddleware.length; i2++) {
-    const {
-      name,
-      fn
-    } = validMiddleware[i2];
-    const {
-      x: nextX,
-      y: nextY,
-      data,
-      reset
-    } = await fn({
-      x: x2,
-      y: y2,
-      initialPlacement: placement,
-      placement: statefulPlacement,
-      strategy,
-      middlewareData,
-      rects,
-      platform: platform2,
-      elements: {
-        reference,
-        floating
-      }
-    });
-    x2 = nextX != null ? nextX : x2;
-    y2 = nextY != null ? nextY : y2;
-    middlewareData = {
-      ...middlewareData,
-      [name]: {
-        ...middlewareData[name],
-        ...data
-      }
-    };
-    if (reset && resetCount <= 50) {
-      resetCount++;
-      if (typeof reset === "object") {
-        if (reset.placement) {
-          statefulPlacement = reset.placement;
-        }
-        if (reset.rects) {
-          rects = reset.rects === true ? await platform2.getElementRects({
-            reference,
-            floating,
-            strategy
-          }) : reset.rects;
-        }
-        ({
-          x: x2,
-          y: y2
-        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
-      }
-      i2 = -1;
-    }
-  }
-  return {
-    x: x2,
-    y: y2,
-    placement: statefulPlacement,
-    strategy,
-    middlewareData
-  };
-};
-async function detectOverflow$1(state, options) {
-  var _await$platform$isEle;
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    x: x2,
-    y: y2,
-    platform: platform2,
-    rects,
-    elements,
-    strategy
-  } = state;
-  const {
-    boundary = "clippingAncestors",
-    rootBoundary = "viewport",
-    elementContext = "floating",
-    altBoundary = false,
-    padding = 0
-  } = evaluate(options, state);
-  const paddingObject = getPaddingObject(padding);
-  const altContext = elementContext === "floating" ? "reference" : "floating";
-  const element = elements[altBoundary ? altContext : elementContext];
-  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
-    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
-    boundary,
-    rootBoundary,
-    strategy
-  }));
-  const rect = elementContext === "floating" ? {
-    x: x2,
-    y: y2,
-    width: rects.floating.width,
-    height: rects.floating.height
-  } : rects.reference;
-  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
-  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  };
-  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements,
-    rect,
-    offsetParent,
-    strategy
-  }) : rect);
-  return {
-    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
-    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
-    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
-    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
-  };
-}
-const flip$2 = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    name: "flip",
-    options,
-    async fn(state) {
-      var _middlewareData$arrow, _middlewareData$flip;
-      const {
-        placement,
-        middlewareData,
-        rects,
-        initialPlacement,
-        platform: platform2,
-        elements
-      } = state;
-      const {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = true,
-        fallbackPlacements: specifiedFallbackPlacements,
-        fallbackStrategy = "bestFit",
-        fallbackAxisSideDirection = "none",
-        flipAlignment = true,
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
-        return {};
-      }
-      const side = getSide(placement);
-      const initialSideAxis = getSideAxis(initialPlacement);
-      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
-      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
-      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
-      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
-      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
-        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
-      }
-      const placements = [initialPlacement, ...fallbackPlacements];
-      const overflow = await detectOverflow$1(state, detectOverflowOptions);
-      const overflows = [];
-      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
-      if (checkMainAxis) {
-        overflows.push(overflow[side]);
-      }
-      if (checkCrossAxis) {
-        const sides = getAlignmentSides(placement, rects, rtl);
-        overflows.push(overflow[sides[0]], overflow[sides[1]]);
-      }
-      overflowsData = [...overflowsData, {
-        placement,
-        overflows
-      }];
-      if (!overflows.every((side2) => side2 <= 0)) {
-        var _middlewareData$flip2, _overflowsData$filter;
-        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
-        const nextPlacement = placements[nextIndex];
-        if (nextPlacement) {
-          return {
-            data: {
-              index: nextIndex,
-              overflows: overflowsData
-            },
-            reset: {
-              placement: nextPlacement
-            }
-          };
-        }
-        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d2) => d2.overflows[0] <= 0).sort((a3, b) => a3.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
-        if (!resetPlacement) {
-          switch (fallbackStrategy) {
-            case "bestFit": {
-              var _overflowsData$filter2;
-              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d2) => {
-                if (hasFallbackAxisSideDirection) {
-                  const currentSideAxis = getSideAxis(d2.placement);
-                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  currentSideAxis === "y";
-                }
-                return true;
-              }).map((d2) => [d2.placement, d2.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a3, b) => a3[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
-              if (placement2) {
-                resetPlacement = placement2;
-              }
-              break;
-            }
-            case "initialPlacement":
-              resetPlacement = initialPlacement;
-              break;
-          }
-        }
-        if (placement !== resetPlacement) {
-          return {
-            reset: {
-              placement: resetPlacement
-            }
-          };
-        }
-      }
-      return {};
-    }
-  };
-};
-async function convertValueToCoords(state, options) {
-  const {
-    placement,
-    platform: platform2,
-    elements
-  } = state;
-  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
-  const side = getSide(placement);
-  const alignment = getAlignment(placement);
-  const isVertical = getSideAxis(placement) === "y";
-  const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
-  const crossAxisMulti = rtl && isVertical ? -1 : 1;
-  const rawValue = evaluate(options, state);
-  let {
-    mainAxis,
-    crossAxis,
-    alignmentAxis
-  } = typeof rawValue === "number" ? {
-    mainAxis: rawValue,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: 0,
-    crossAxis: 0,
-    alignmentAxis: null,
-    ...rawValue
-  };
-  if (alignment && typeof alignmentAxis === "number") {
-    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
-  }
-  return isVertical ? {
-    x: crossAxis * crossAxisMulti,
-    y: mainAxis * mainAxisMulti
-  } : {
-    x: mainAxis * mainAxisMulti,
-    y: crossAxis * crossAxisMulti
-  };
-}
-const offset$2 = function(options) {
-  if (options === void 0) {
-    options = 0;
-  }
-  return {
-    name: "offset",
-    options,
-    async fn(state) {
-      var _middlewareData$offse, _middlewareData$arrow;
-      const {
-        x: x2,
-        y: y2,
-        placement,
-        middlewareData
-      } = state;
-      const diffCoords = await convertValueToCoords(state, options);
-      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
-        return {};
-      }
-      return {
-        x: x2 + diffCoords.x,
-        y: y2 + diffCoords.y,
-        data: {
-          ...diffCoords,
-          placement
-        }
-      };
-    }
-  };
-};
-const shift$2 = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    name: "shift",
-    options,
-    async fn(state) {
-      const {
-        x: x2,
-        y: y2,
-        placement
-      } = state;
-      const {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = false,
-        limiter = {
-          fn: (_ref) => {
-            let {
-              x: x3,
-              y: y3
-            } = _ref;
-            return {
-              x: x3,
-              y: y3
-            };
-          }
-        },
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-      const coords = {
-        x: x2,
-        y: y2
-      };
-      const overflow = await detectOverflow$1(state, detectOverflowOptions);
-      const crossAxis = getSideAxis(getSide(placement));
-      const mainAxis = getOppositeAxis(crossAxis);
-      let mainAxisCoord = coords[mainAxis];
-      let crossAxisCoord = coords[crossAxis];
-      if (checkMainAxis) {
-        const minSide = mainAxis === "y" ? "top" : "left";
-        const maxSide = mainAxis === "y" ? "bottom" : "right";
-        const min2 = mainAxisCoord + overflow[minSide];
-        const max2 = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = clamp(min2, mainAxisCoord, max2);
-      }
-      if (checkCrossAxis) {
-        const minSide = crossAxis === "y" ? "top" : "left";
-        const maxSide = crossAxis === "y" ? "bottom" : "right";
-        const min2 = crossAxisCoord + overflow[minSide];
-        const max2 = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = clamp(min2, crossAxisCoord, max2);
-      }
-      const limitedCoords = limiter.fn({
-        ...state,
-        [mainAxis]: mainAxisCoord,
-        [crossAxis]: crossAxisCoord
-      });
-      return {
-        ...limitedCoords,
-        data: {
-          x: limitedCoords.x - x2,
-          y: limitedCoords.y - y2
-        }
-      };
-    }
-  };
-};
-const size$2 = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    name: "size",
-    options,
-    async fn(state) {
-      const {
-        placement,
-        rects,
-        platform: platform2,
-        elements
-      } = state;
-      const {
-        apply = () => {
-        },
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-      const overflow = await detectOverflow$1(state, detectOverflowOptions);
-      const side = getSide(placement);
-      const alignment = getAlignment(placement);
-      const isYAxis = getSideAxis(placement) === "y";
-      const {
-        width,
-        height
-      } = rects.floating;
-      let heightSide;
-      let widthSide;
-      if (side === "top" || side === "bottom") {
-        heightSide = side;
-        widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
-      } else {
-        widthSide = side;
-        heightSide = alignment === "end" ? "top" : "bottom";
-      }
-      const maximumClippingHeight = height - overflow.top - overflow.bottom;
-      const maximumClippingWidth = width - overflow.left - overflow.right;
-      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
-      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
-      const noShift = !state.middlewareData.shift;
-      let availableHeight = overflowAvailableHeight;
-      let availableWidth = overflowAvailableWidth;
-      if (isYAxis) {
-        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
-      } else {
-        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
-      }
-      if (noShift && !alignment) {
-        const xMin = max(overflow.left, 0);
-        const xMax = max(overflow.right, 0);
-        const yMin = max(overflow.top, 0);
-        const yMax = max(overflow.bottom, 0);
-        if (isYAxis) {
-          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
-        } else {
-          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
-        }
-      }
-      await apply({
-        ...state,
-        availableWidth,
-        availableHeight
-      });
-      const nextDimensions = await platform2.getDimensions(elements.floating);
-      if (width !== nextDimensions.width || height !== nextDimensions.height) {
-        return {
-          reset: {
-            rects: true
-          }
-        };
-      }
-      return {};
-    }
-  };
-};
-function getCssDimensions(element) {
-  const css = getComputedStyle$1(element);
-  let width = parseFloat(css.width) || 0;
-  let height = parseFloat(css.height) || 0;
-  const hasOffset = isHTMLElement(element);
-  const offsetWidth = hasOffset ? element.offsetWidth : width;
-  const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
-  if (shouldFallback) {
-    width = offsetWidth;
-    height = offsetHeight;
-  }
-  return {
-    width,
-    height,
-    $: shouldFallback
-  };
-}
-function unwrapElement(element) {
-  return !isElement(element) ? element.contextElement : element;
-}
-function getScale(element) {
-  const domElement = unwrapElement(element);
-  if (!isHTMLElement(domElement)) {
-    return createCoords(1);
-  }
-  const rect = domElement.getBoundingClientRect();
-  const {
-    width,
-    height,
-    $
-  } = getCssDimensions(domElement);
-  let x2 = ($ ? round(rect.width) : rect.width) / width;
-  let y2 = ($ ? round(rect.height) : rect.height) / height;
-  if (!x2 || !Number.isFinite(x2)) {
-    x2 = 1;
-  }
-  if (!y2 || !Number.isFinite(y2)) {
-    y2 = 1;
-  }
-  return {
-    x: x2,
-    y: y2
-  };
-}
-const noOffsets = /* @__PURE__ */ createCoords(0);
-function getVisualOffsets(element) {
-  const win = getWindow(element);
-  if (!isWebKit() || !win.visualViewport) {
-    return noOffsets;
-  }
-  return {
-    x: win.visualViewport.offsetLeft,
-    y: win.visualViewport.offsetTop
-  };
-}
-function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
-  if (isFixed === void 0) {
-    isFixed = false;
-  }
-  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
-    return false;
-  }
-  return isFixed;
-}
-function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
-  if (includeScale === void 0) {
-    includeScale = false;
-  }
-  if (isFixedStrategy === void 0) {
-    isFixedStrategy = false;
-  }
-  const clientRect = element.getBoundingClientRect();
-  const domElement = unwrapElement(element);
-  let scale = createCoords(1);
-  if (includeScale) {
-    if (offsetParent) {
-      if (isElement(offsetParent)) {
-        scale = getScale(offsetParent);
-      }
-    } else {
-      scale = getScale(element);
-    }
-  }
-  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
-  let x2 = (clientRect.left + visualOffsets.x) / scale.x;
-  let y2 = (clientRect.top + visualOffsets.y) / scale.y;
-  let width = clientRect.width / scale.x;
-  let height = clientRect.height / scale.y;
-  if (domElement) {
-    const win = getWindow(domElement);
-    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
-    let currentWin = win;
-    let currentIFrame = currentWin.frameElement;
-    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
-      const iframeScale = getScale(currentIFrame);
-      const iframeRect = currentIFrame.getBoundingClientRect();
-      const css = getComputedStyle$1(currentIFrame);
-      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
-      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
-      x2 *= iframeScale.x;
-      y2 *= iframeScale.y;
-      width *= iframeScale.x;
-      height *= iframeScale.y;
-      x2 += left;
-      y2 += top;
-      currentWin = getWindow(currentIFrame);
-      currentIFrame = currentWin.frameElement;
-    }
-  }
-  return rectToClientRect({
-    width,
-    height,
-    x: x2,
-    y: y2
-  });
-}
-function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
-  let {
-    elements,
-    rect,
-    offsetParent,
-    strategy
-  } = _ref;
-  const isFixed = strategy === "fixed";
-  const documentElement = getDocumentElement(offsetParent);
-  const topLayer = elements ? isTopLayer(elements.floating) : false;
-  if (offsetParent === documentElement || topLayer && isFixed) {
-    return rect;
-  }
-  let scroll = {
-    scrollLeft: 0,
-    scrollTop: 0
-  };
-  let scale = createCoords(1);
-  const offsets = createCoords(0);
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
-      scroll = getNodeScroll(offsetParent);
-    }
-    if (isHTMLElement(offsetParent)) {
-      const offsetRect = getBoundingClientRect(offsetParent);
-      scale = getScale(offsetParent);
-      offsets.x = offsetRect.x + offsetParent.clientLeft;
-      offsets.y = offsetRect.y + offsetParent.clientTop;
-    }
-  }
-  return {
-    width: rect.width * scale.x,
-    height: rect.height * scale.y,
-    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
-    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
-  };
-}
-function getClientRects(element) {
-  return Array.from(element.getClientRects());
-}
-function getWindowScrollBarX(element) {
-  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
-}
-function getDocumentRect(element) {
-  const html = getDocumentElement(element);
-  const scroll = getNodeScroll(element);
-  const body = element.ownerDocument.body;
-  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
-  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
-  let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
-  const y2 = -scroll.scrollTop;
-  if (getComputedStyle$1(body).direction === "rtl") {
-    x2 += max(html.clientWidth, body.clientWidth) - width;
-  }
-  return {
-    width,
-    height,
-    x: x2,
-    y: y2
-  };
-}
-function getViewportRect(element, strategy) {
-  const win = getWindow(element);
-  const html = getDocumentElement(element);
-  const visualViewport = win.visualViewport;
-  let width = html.clientWidth;
-  let height = html.clientHeight;
-  let x2 = 0;
-  let y2 = 0;
-  if (visualViewport) {
-    width = visualViewport.width;
-    height = visualViewport.height;
-    const visualViewportBased = isWebKit();
-    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
-      x2 = visualViewport.offsetLeft;
-      y2 = visualViewport.offsetTop;
-    }
-  }
-  return {
-    width,
-    height,
-    x: x2,
-    y: y2
-  };
-}
-function getInnerBoundingClientRect(element, strategy) {
-  const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
-  const top = clientRect.top + element.clientTop;
-  const left = clientRect.left + element.clientLeft;
-  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
-  const width = element.clientWidth * scale.x;
-  const height = element.clientHeight * scale.y;
-  const x2 = left * scale.x;
-  const y2 = top * scale.y;
-  return {
-    width,
-    height,
-    x: x2,
-    y: y2
-  };
-}
-function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
-  let rect;
-  if (clippingAncestor === "viewport") {
-    rect = getViewportRect(element, strategy);
-  } else if (clippingAncestor === "document") {
-    rect = getDocumentRect(getDocumentElement(element));
-  } else if (isElement(clippingAncestor)) {
-    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
-  } else {
-    const visualOffsets = getVisualOffsets(element);
-    rect = {
-      ...clippingAncestor,
-      x: clippingAncestor.x - visualOffsets.x,
-      y: clippingAncestor.y - visualOffsets.y
-    };
-  }
-  return rectToClientRect(rect);
-}
-function hasFixedPositionAncestor(element, stopNode) {
-  const parentNode = getParentNode(element);
-  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
-    return false;
-  }
-  return getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
-}
-function getClippingElementAncestors(element, cache) {
-  const cachedResult = cache.get(element);
-  if (cachedResult) {
-    return cachedResult;
-  }
-  let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
-  let currentContainingBlockComputedStyle = null;
-  const elementIsFixed = getComputedStyle$1(element).position === "fixed";
-  let currentNode = elementIsFixed ? getParentNode(element) : element;
-  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    const computedStyle = getComputedStyle$1(currentNode);
-    const currentNodeIsContaining = isContainingBlock(currentNode);
-    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
-      currentContainingBlockComputedStyle = null;
-    }
-    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
-    if (shouldDropCurrentNode) {
-      result = result.filter((ancestor) => ancestor !== currentNode);
-    } else {
-      currentContainingBlockComputedStyle = computedStyle;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  cache.set(element, result);
-  return result;
-}
-function getClippingRect(_ref) {
-  let {
-    element,
-    boundary,
-    rootBoundary,
-    strategy
-  } = _ref;
-  const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
-  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
-  const firstClippingAncestor = clippingAncestors[0];
-  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
-    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-    accRect.top = max(rect.top, accRect.top);
-    accRect.right = min(rect.right, accRect.right);
-    accRect.bottom = min(rect.bottom, accRect.bottom);
-    accRect.left = max(rect.left, accRect.left);
-    return accRect;
-  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
-  return {
-    width: clippingRect.right - clippingRect.left,
-    height: clippingRect.bottom - clippingRect.top,
-    x: clippingRect.left,
-    y: clippingRect.top
-  };
-}
-function getDimensions(element) {
-  const {
-    width,
-    height
-  } = getCssDimensions(element);
-  return {
-    width,
-    height
-  };
-}
-function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  const documentElement = getDocumentElement(offsetParent);
-  const isFixed = strategy === "fixed";
-  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
-  let scroll = {
-    scrollLeft: 0,
-    scrollTop: 0
-  };
-  const offsets = createCoords(0);
-  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
-      scroll = getNodeScroll(offsetParent);
-    }
-    if (isOffsetParentAnElement) {
-      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
-      offsets.x = offsetRect.x + offsetParent.clientLeft;
-      offsets.y = offsetRect.y + offsetParent.clientTop;
-    } else if (documentElement) {
-      offsets.x = getWindowScrollBarX(documentElement);
-    }
-  }
-  const x2 = rect.left + scroll.scrollLeft - offsets.x;
-  const y2 = rect.top + scroll.scrollTop - offsets.y;
-  return {
-    x: x2,
-    y: y2,
-    width: rect.width,
-    height: rect.height
-  };
-}
-function isStaticPositioned(element) {
-  return getComputedStyle$1(element).position === "static";
-}
-function getTrueOffsetParent(element, polyfill) {
-  if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed") {
-    return null;
-  }
-  if (polyfill) {
-    return polyfill(element);
-  }
-  return element.offsetParent;
-}
-function getOffsetParent(element, polyfill) {
-  const win = getWindow(element);
-  if (isTopLayer(element)) {
-    return win;
-  }
-  if (!isHTMLElement(element)) {
-    let svgOffsetParent = getParentNode(element);
-    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
-      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
-        return svgOffsetParent;
-      }
-      svgOffsetParent = getParentNode(svgOffsetParent);
-    }
-    return win;
-  }
-  let offsetParent = getTrueOffsetParent(element, polyfill);
-  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
-    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
-  }
-  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
-    return win;
-  }
-  return offsetParent || getContainingBlock(element) || win;
-}
-const getElementRects = async function(data) {
-  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
-  const getDimensionsFn = this.getDimensions;
-  const floatingDimensions = await getDimensionsFn(data.floating);
-  return {
-    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
-    floating: {
-      x: 0,
-      y: 0,
-      width: floatingDimensions.width,
-      height: floatingDimensions.height
-    }
-  };
-};
-function isRTL(element) {
-  return getComputedStyle$1(element).direction === "rtl";
-}
-const platform = {
-  convertOffsetParentRelativeRectToViewportRelativeRect,
-  getDocumentElement,
-  getClippingRect,
-  getOffsetParent,
-  getElementRects,
-  getClientRects,
-  getDimensions,
-  getScale,
-  isElement,
-  isRTL
-};
-function observeMove(element, onMove) {
-  let io = null;
-  let timeoutId;
-  const root = getDocumentElement(element);
-  function cleanup() {
-    var _io;
-    clearTimeout(timeoutId);
-    (_io = io) == null || _io.disconnect();
-    io = null;
-  }
-  function refresh(skip, threshold) {
-    if (skip === void 0) {
-      skip = false;
-    }
-    if (threshold === void 0) {
-      threshold = 1;
-    }
-    cleanup();
-    const {
-      left,
-      top,
-      width,
-      height
-    } = element.getBoundingClientRect();
-    if (!skip) {
-      onMove();
-    }
-    if (!width || !height) {
-      return;
-    }
-    const insetTop = floor(top);
-    const insetRight = floor(root.clientWidth - (left + width));
-    const insetBottom = floor(root.clientHeight - (top + height));
-    const insetLeft = floor(left);
-    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
-    const options = {
-      rootMargin,
-      threshold: max(0, min(1, threshold)) || 1
-    };
-    let isFirstUpdate = true;
-    function handleObserve(entries) {
-      const ratio = entries[0].intersectionRatio;
-      if (ratio !== threshold) {
-        if (!isFirstUpdate) {
-          return refresh();
-        }
-        if (!ratio) {
-          timeoutId = setTimeout(() => {
-            refresh(false, 1e-7);
-          }, 1e3);
-        } else {
-          refresh(false, ratio);
-        }
-      }
-      isFirstUpdate = false;
-    }
-    try {
-      io = new IntersectionObserver(handleObserve, {
-        ...options,
-        // Handle <iframe>s
-        root: root.ownerDocument
-      });
-    } catch (e2) {
-      io = new IntersectionObserver(handleObserve, options);
-    }
-    io.observe(element);
-  }
-  refresh(true);
-  return cleanup;
-}
-function autoUpdate(reference, floating, update, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    ancestorScroll = true,
-    ancestorResize = true,
-    elementResize = typeof ResizeObserver === "function",
-    layoutShift = typeof IntersectionObserver === "function",
-    animationFrame = false
-  } = options;
-  const referenceEl = unwrapElement(reference);
-  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
-  ancestors.forEach((ancestor) => {
-    ancestorScroll && ancestor.addEventListener("scroll", update, {
-      passive: true
-    });
-    ancestorResize && ancestor.addEventListener("resize", update);
-  });
-  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
-  let reobserveFrame = -1;
-  let resizeObserver = null;
-  if (elementResize) {
-    resizeObserver = new ResizeObserver((_ref) => {
-      let [firstEntry] = _ref;
-      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
-        resizeObserver.unobserve(floating);
-        cancelAnimationFrame(reobserveFrame);
-        reobserveFrame = requestAnimationFrame(() => {
-          var _resizeObserver;
-          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
-        });
-      }
-      update();
-    });
-    if (referenceEl && !animationFrame) {
-      resizeObserver.observe(referenceEl);
-    }
-    resizeObserver.observe(floating);
-  }
-  let frameId;
-  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
-  if (animationFrame) {
-    frameLoop();
-  }
-  function frameLoop() {
-    const nextRefRect = getBoundingClientRect(reference);
-    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
-      update();
-    }
-    prevRefRect = nextRefRect;
-    frameId = requestAnimationFrame(frameLoop);
-  }
-  update();
-  return () => {
-    var _resizeObserver2;
-    ancestors.forEach((ancestor) => {
-      ancestorScroll && ancestor.removeEventListener("scroll", update);
-      ancestorResize && ancestor.removeEventListener("resize", update);
-    });
-    cleanupIo == null || cleanupIo();
-    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
-    resizeObserver = null;
-    if (animationFrame) {
-      cancelAnimationFrame(frameId);
-    }
-  };
-}
-const detectOverflow = detectOverflow$1;
-const offset$1 = offset$2;
-const shift$1 = shift$2;
-const flip$1 = flip$2;
-const size$1 = size$2;
-const computePosition = (reference, floating, options) => {
-  const cache = /* @__PURE__ */ new Map();
-  const mergedOptions = {
-    platform,
-    ...options
-  };
-  const platformWithCache = {
-    ...mergedOptions.platform,
-    _c: cache
-  };
-  return computePosition$1(reference, floating, {
-    ...mergedOptions,
-    platform: platformWithCache
-  });
-};
-var index$1 = typeof document !== "undefined" ? useLayoutEffect : useEffect;
-function deepEqual(a3, b) {
-  if (a3 === b) {
-    return true;
-  }
-  if (typeof a3 !== typeof b) {
-    return false;
-  }
-  if (typeof a3 === "function" && a3.toString() === b.toString()) {
-    return true;
-  }
-  let length;
-  let i2;
-  let keys;
-  if (a3 && b && typeof a3 === "object") {
-    if (Array.isArray(a3)) {
-      length = a3.length;
-      if (length !== b.length) return false;
-      for (i2 = length; i2-- !== 0; ) {
-        if (!deepEqual(a3[i2], b[i2])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    keys = Object.keys(a3);
-    length = keys.length;
-    if (length !== Object.keys(b).length) {
-      return false;
-    }
-    for (i2 = length; i2-- !== 0; ) {
-      if (!{}.hasOwnProperty.call(b, keys[i2])) {
-        return false;
-      }
-    }
-    for (i2 = length; i2-- !== 0; ) {
-      const key = keys[i2];
-      if (key === "_owner" && a3.$$typeof) {
-        continue;
-      }
-      if (!deepEqual(a3[key], b[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return a3 !== a3 && b !== b;
-}
-function getDPR(element) {
-  if (typeof window === "undefined") {
-    return 1;
-  }
-  const win = element.ownerDocument.defaultView || window;
-  return win.devicePixelRatio || 1;
-}
-function roundByDPR(element, value) {
-  const dpr = getDPR(element);
-  return Math.round(value * dpr) / dpr;
-}
-function useLatestRef(value) {
-  const ref = React.useRef(value);
-  index$1(() => {
-    ref.current = value;
-  });
-  return ref;
-}
-function useFloating$1(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    placement = "bottom",
-    strategy = "absolute",
-    middleware = [],
-    platform: platform2,
-    elements: {
-      reference: externalReference,
-      floating: externalFloating
-    } = {},
-    transform = true,
-    whileElementsMounted,
-    open
-  } = options;
-  const [data, setData] = React.useState({
-    x: 0,
-    y: 0,
-    strategy,
-    placement,
-    middlewareData: {},
-    isPositioned: false
-  });
-  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);
-  if (!deepEqual(latestMiddleware, middleware)) {
-    setLatestMiddleware(middleware);
-  }
-  const [_reference, _setReference] = React.useState(null);
-  const [_floating, _setFloating] = React.useState(null);
-  const setReference = React.useCallback((node) => {
-    if (node !== referenceRef.current) {
-      referenceRef.current = node;
-      _setReference(node);
-    }
-  }, []);
-  const setFloating = React.useCallback((node) => {
-    if (node !== floatingRef.current) {
-      floatingRef.current = node;
-      _setFloating(node);
-    }
-  }, []);
-  const referenceEl = externalReference || _reference;
-  const floatingEl = externalFloating || _floating;
-  const referenceRef = React.useRef(null);
-  const floatingRef = React.useRef(null);
-  const dataRef = React.useRef(data);
-  const hasWhileElementsMounted = whileElementsMounted != null;
-  const whileElementsMountedRef = useLatestRef(whileElementsMounted);
-  const platformRef = useLatestRef(platform2);
-  const update = React.useCallback(() => {
-    if (!referenceRef.current || !floatingRef.current) {
-      return;
-    }
-    const config = {
-      placement,
-      strategy,
-      middleware: latestMiddleware
-    };
-    if (platformRef.current) {
-      config.platform = platformRef.current;
-    }
-    computePosition(referenceRef.current, floatingRef.current, config).then((data2) => {
-      const fullData = {
-        ...data2,
-        isPositioned: true
-      };
-      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
-        dataRef.current = fullData;
-        ReactDOM.flushSync(() => {
-          setData(fullData);
-        });
-      }
-    });
-  }, [latestMiddleware, placement, strategy, platformRef]);
-  index$1(() => {
-    if (open === false && dataRef.current.isPositioned) {
-      dataRef.current.isPositioned = false;
-      setData((data2) => ({
-        ...data2,
-        isPositioned: false
-      }));
-    }
-  }, [open]);
-  const isMountedRef = React.useRef(false);
-  index$1(() => {
-    isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-  index$1(() => {
-    if (referenceEl) referenceRef.current = referenceEl;
-    if (floatingEl) floatingRef.current = floatingEl;
-    if (referenceEl && floatingEl) {
-      if (whileElementsMountedRef.current) {
-        return whileElementsMountedRef.current(referenceEl, floatingEl, update);
-      }
-      update();
-    }
-  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
-  const refs = React.useMemo(() => ({
-    reference: referenceRef,
-    floating: floatingRef,
-    setReference,
-    setFloating
-  }), [setReference, setFloating]);
-  const elements = React.useMemo(() => ({
-    reference: referenceEl,
-    floating: floatingEl
-  }), [referenceEl, floatingEl]);
-  const floatingStyles = React.useMemo(() => {
-    const initialStyles = {
-      position: strategy,
-      left: 0,
-      top: 0
-    };
-    if (!elements.floating) {
-      return initialStyles;
-    }
-    const x2 = roundByDPR(elements.floating, data.x);
-    const y2 = roundByDPR(elements.floating, data.y);
-    if (transform) {
-      return {
-        ...initialStyles,
-        transform: "translate(" + x2 + "px, " + y2 + "px)",
-        ...getDPR(elements.floating) >= 1.5 && {
-          willChange: "transform"
-        }
-      };
-    }
-    return {
-      position: strategy,
-      left: x2,
-      top: y2
-    };
-  }, [strategy, transform, elements.floating, data.x, data.y]);
-  return React.useMemo(() => ({
-    ...data,
-    update,
-    refs,
-    elements,
-    floatingStyles
-  }), [data, update, refs, elements, floatingStyles]);
-}
-const offset = (options, deps) => ({
-  ...offset$1(options),
-  options: [options, deps]
-});
-const shift = (options, deps) => ({
-  ...shift$1(options),
-  options: [options, deps]
-});
-const flip = (options, deps) => ({
-  ...flip$1(options),
-  options: [options, deps]
-});
-const size = (options, deps) => ({
-  ...size$1(options),
-  options: [options, deps]
-});
-const SafeReact = {
-  ...React
-};
-const useInsertionEffect = SafeReact.useInsertionEffect;
-const useSafeInsertionEffect = useInsertionEffect || ((fn) => fn());
-function useEffectEvent(callback) {
-  const ref = React.useRef(() => {
-    if (process.env.NODE_ENV !== "production") {
-      throw new Error("Cannot call an event handler while rendering.");
-    }
-  });
-  useSafeInsertionEffect(() => {
-    ref.current = callback;
-  });
-  return React.useCallback(function() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return ref.current == null ? void 0 : ref.current(...args);
-  }, []);
-}
-var index = typeof document !== "undefined" ? useLayoutEffect : useEffect;
-let serverHandoffComplete = false;
-let count = 0;
-const genId = () => (
-  // Ensure the id is unique with multiple independent versions of Floating UI
-  // on <React 18
-  "floating-ui-" + Math.random().toString(36).slice(2, 6) + count++
-);
-function useFloatingId() {
-  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : void 0);
-  index(() => {
-    if (id == null) {
-      setId(genId());
-    }
-  }, []);
-  React.useEffect(() => {
-    serverHandoffComplete = true;
-  }, []);
-  return id;
-}
-const useReactId = SafeReact.useId;
-const useId = useReactId || useFloatingId;
-let devMessageSet;
-if (process.env.NODE_ENV !== "production") {
-  devMessageSet = /* @__PURE__ */ new Set();
-}
-function warn() {
-  var _devMessageSet;
-  for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) {
-    messages[_key] = arguments[_key];
-  }
-  const message = "Floating UI: " + messages.join(" ");
-  if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(message))) {
-    var _devMessageSet2;
-    (_devMessageSet2 = devMessageSet) == null || _devMessageSet2.add(message);
-    console.warn(message);
-  }
-}
-function error() {
-  var _devMessageSet3;
-  for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    messages[_key2] = arguments[_key2];
-  }
-  const message = "Floating UI: " + messages.join(" ");
-  if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {
-    var _devMessageSet4;
-    (_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);
-    console.error(message);
-  }
-}
-function createPubSub() {
-  const map = /* @__PURE__ */ new Map();
-  return {
-    emit(event, data) {
-      var _map$get;
-      (_map$get = map.get(event)) == null || _map$get.forEach((handler) => handler(data));
-    },
-    on(event, listener) {
-      map.set(event, [...map.get(event) || [], listener]);
-    },
-    off(event, listener) {
-      var _map$get2;
-      map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter((l2) => l2 !== listener)) || []);
-    }
-  };
-}
-const FloatingNodeContext = /* @__PURE__ */ React.createContext(null);
-const FloatingTreeContext = /* @__PURE__ */ React.createContext(null);
-const useFloatingParentNodeId = () => {
-  var _React$useContext;
-  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;
-};
-const useFloatingTree = () => React.useContext(FloatingTreeContext);
-function useFloatingRootContext(options) {
-  const {
-    open = false,
-    onOpenChange: onOpenChangeProp,
-    elements: elementsProp
-  } = options;
-  const floatingId = useId();
-  const dataRef = React.useRef({});
-  const [events] = React.useState(() => createPubSub());
-  const nested = useFloatingParentNodeId() != null;
-  if (process.env.NODE_ENV !== "production") {
-    const optionDomReference = elementsProp.reference;
-    if (optionDomReference && !isElement(optionDomReference)) {
-      error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
-    }
-  }
-  const [positionReference, setPositionReference] = React.useState(elementsProp.reference);
-  const onOpenChange = useEffectEvent((open2, event, reason) => {
-    dataRef.current.openEvent = open2 ? event : void 0;
-    events.emit("openchange", {
-      open: open2,
-      event,
-      reason,
-      nested
-    });
-    onOpenChangeProp == null || onOpenChangeProp(open2, event, reason);
-  });
-  const refs = React.useMemo(() => ({
-    setPositionReference
-  }), []);
-  const elements = React.useMemo(() => ({
-    reference: positionReference || elementsProp.reference || null,
-    floating: elementsProp.floating || null,
-    domReference: elementsProp.reference
-  }), [positionReference, elementsProp.reference, elementsProp.floating]);
-  return React.useMemo(() => ({
-    dataRef,
-    open,
-    onOpenChange,
-    elements,
-    events,
-    floatingId,
-    refs
-  }), [open, onOpenChange, elements, events, floatingId, refs]);
-}
-function useFloating(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    nodeId
-  } = options;
-  const internalRootContext = useFloatingRootContext({
-    ...options,
-    elements: {
-      reference: null,
-      floating: null,
-      ...options.elements
-    }
-  });
-  const rootContext = options.rootContext || internalRootContext;
-  const computedElements = rootContext.elements;
-  const [_domReference, setDomReference] = React.useState(null);
-  const [positionReference, _setPositionReference] = React.useState(null);
-  const optionDomReference = computedElements == null ? void 0 : computedElements.reference;
-  const domReference = optionDomReference || _domReference;
-  const domReferenceRef = React.useRef(null);
-  const tree = useFloatingTree();
-  index(() => {
-    if (domReference) {
-      domReferenceRef.current = domReference;
-    }
-  }, [domReference]);
-  const position = useFloating$1({
-    ...options,
-    elements: {
-      ...computedElements,
-      ...positionReference && {
-        reference: positionReference
-      }
-    }
-  });
-  const setPositionReference = React.useCallback((node) => {
-    const computedPositionReference = isElement(node) ? {
-      getBoundingClientRect: () => node.getBoundingClientRect(),
-      contextElement: node
-    } : node;
-    _setPositionReference(computedPositionReference);
-    position.refs.setReference(computedPositionReference);
-  }, [position.refs]);
-  const setReference = React.useCallback((node) => {
-    if (isElement(node) || node === null) {
-      domReferenceRef.current = node;
-      setDomReference(node);
-    }
-    if (isElement(position.refs.reference.current) || position.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
-    // `null` to support `positionReference` + an unstable `reference`
-    // callback ref.
-    node !== null && !isElement(node)) {
-      position.refs.setReference(node);
-    }
-  }, [position.refs]);
-  const refs = React.useMemo(() => ({
-    ...position.refs,
-    setReference,
-    setPositionReference,
-    domReference: domReferenceRef
-  }), [position.refs, setReference, setPositionReference]);
-  const elements = React.useMemo(() => ({
-    ...position.elements,
-    domReference
-  }), [position.elements, domReference]);
-  const context = React.useMemo(() => ({
-    ...position,
-    ...rootContext,
-    refs,
-    elements,
-    nodeId
-  }), [position, refs, elements, nodeId, rootContext]);
-  index(() => {
-    rootContext.dataRef.current.floatingContext = context;
-    const node = tree == null ? void 0 : tree.nodesRef.current.find((node2) => node2.id === nodeId);
-    if (node) {
-      node.context = context;
-    }
-  });
-  return React.useMemo(() => ({
-    ...position,
-    context,
-    refs,
-    elements
-  }), [position, refs, elements, context]);
-}
-const ACTIVE_KEY = "active";
-const SELECTED_KEY = "selected";
-function mergeProps(userProps, propsList, elementKey) {
-  const map = /* @__PURE__ */ new Map();
-  const isItem = elementKey === "item";
-  let domUserProps = userProps;
-  if (isItem && userProps) {
-    const {
-      [ACTIVE_KEY]: _2,
-      [SELECTED_KEY]: __,
-      ...validProps
-    } = userProps;
-    domUserProps = validProps;
-  }
-  return {
-    ...elementKey === "floating" && {
-      tabIndex: -1
-    },
-    ...domUserProps,
-    ...propsList.map((value) => {
-      const propsOrGetProps = value ? value[elementKey] : null;
-      if (typeof propsOrGetProps === "function") {
-        return userProps ? propsOrGetProps(userProps) : null;
-      }
-      return propsOrGetProps;
-    }).concat(userProps).reduce((acc, props) => {
-      if (!props) {
-        return acc;
-      }
-      Object.entries(props).forEach((_ref) => {
-        let [key, value] = _ref;
-        if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) {
-          return;
-        }
-        if (key.indexOf("on") === 0) {
-          if (!map.has(key)) {
-            map.set(key, []);
-          }
-          if (typeof value === "function") {
-            var _map$get;
-            (_map$get = map.get(key)) == null || _map$get.push(value);
-            acc[key] = function() {
-              var _map$get2;
-              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-                args[_key] = arguments[_key];
-              }
-              return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map((fn) => fn(...args)).find((val) => val !== void 0);
-            };
-          }
-        } else {
-          acc[key] = value;
-        }
-      });
-      return acc;
-    }, {})
-  };
-}
-function useInteractions(propsList) {
-  if (propsList === void 0) {
-    propsList = [];
-  }
-  const referenceDeps = propsList.map((key) => key == null ? void 0 : key.reference);
-  const floatingDeps = propsList.map((key) => key == null ? void 0 : key.floating);
-  const itemDeps = propsList.map((key) => key == null ? void 0 : key.item);
-  const getReferenceProps = React.useCallback(
-    (userProps) => mergeProps(userProps, propsList, "reference"),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    referenceDeps
-  );
-  const getFloatingProps = React.useCallback(
-    (userProps) => mergeProps(userProps, propsList, "floating"),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    floatingDeps
-  );
-  const getItemProps = React.useCallback(
-    (userProps) => mergeProps(userProps, propsList, "item"),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    itemDeps
-  );
-  return React.useMemo(() => ({
-    getReferenceProps,
-    getFloatingProps,
-    getItemProps
-  }), [getReferenceProps, getFloatingProps, getItemProps]);
-}
-function getArgsWithCustomFloatingHeight(state, height) {
-  return {
-    ...state,
-    rects: {
-      ...state.rects,
-      floating: {
-        ...state.rects.floating,
-        height
-      }
-    }
-  };
-}
-const inner = (props) => ({
-  name: "inner",
-  options: props,
-  async fn(state) {
-    const {
-      listRef,
-      overflowRef,
-      onFallbackChange,
-      offset: innerOffset = 0,
-      index: index2 = 0,
-      minItemsVisible = 4,
-      referenceOverflowThreshold = 0,
-      scrollRef,
-      ...detectOverflowOptions
-    } = evaluate(props, state);
-    const {
-      rects,
-      elements: {
-        floating
-      }
-    } = state;
-    const item = listRef.current[index2];
-    if (process.env.NODE_ENV !== "production") {
-      if (!state.placement.startsWith("bottom")) {
-        warn('`placement` side must be "bottom" when using the `inner`', "middleware.");
-      }
-    }
-    if (!item) {
-      return {};
-    }
-    const nextArgs = {
-      ...state,
-      ...await offset(-item.offsetTop - floating.clientTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state)
-    };
-    const el = (scrollRef == null ? void 0 : scrollRef.current) || floating;
-    const overflow = await detectOverflow(getArgsWithCustomFloatingHeight(nextArgs, el.scrollHeight), detectOverflowOptions);
-    const refOverflow = await detectOverflow(nextArgs, {
-      ...detectOverflowOptions,
-      elementContext: "reference"
-    });
-    const diffY = Math.max(0, overflow.top);
-    const nextY = nextArgs.y + diffY;
-    const maxHeight = Math.max(0, el.scrollHeight - diffY - Math.max(0, overflow.bottom));
-    el.style.maxHeight = maxHeight + "px";
-    el.scrollTop = diffY;
-    if (onFallbackChange) {
-      if (el.offsetHeight < item.offsetHeight * Math.min(minItemsVisible, listRef.current.length - 1) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold) {
-        ReactDOM.flushSync(() => onFallbackChange(true));
-      } else {
-        ReactDOM.flushSync(() => onFallbackChange(false));
-      }
-    }
-    if (overflowRef) {
-      overflowRef.current = await detectOverflow(getArgsWithCustomFloatingHeight({
-        ...nextArgs,
-        y: nextY
-      }, el.offsetHeight), detectOverflowOptions);
-    }
-    return {
-      y: nextY
-    };
-  }
-});
-function useInnerOffset(context, props) {
-  const {
-    open,
-    elements
-  } = context;
-  const {
-    enabled = true,
-    overflowRef,
-    scrollRef,
-    onChange: unstable_onChange
-  } = props;
-  const onChange = useEffectEvent(unstable_onChange);
-  const controlledScrollingRef = React.useRef(false);
-  const prevScrollTopRef = React.useRef(null);
-  const initialOverflowRef = React.useRef(null);
-  React.useEffect(() => {
-    if (!enabled) return;
-    function onWheel(e2) {
-      if (e2.ctrlKey || !el || overflowRef.current == null) {
-        return;
-      }
-      const dY = e2.deltaY;
-      const isAtTop = overflowRef.current.top >= -0.5;
-      const isAtBottom = overflowRef.current.bottom >= -0.5;
-      const remainingScroll = el.scrollHeight - el.clientHeight;
-      const sign = dY < 0 ? -1 : 1;
-      const method = dY < 0 ? "max" : "min";
-      if (el.scrollHeight <= el.clientHeight) {
-        return;
-      }
-      if (!isAtTop && dY > 0 || !isAtBottom && dY < 0) {
-        e2.preventDefault();
-        ReactDOM.flushSync(() => {
-          onChange((d2) => d2 + Math[method](dY, remainingScroll * sign));
-        });
-      } else if (/firefox/i.test(getUserAgent())) {
-        el.scrollTop += dY;
-      }
-    }
-    const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;
-    if (open && el) {
-      el.addEventListener("wheel", onWheel);
-      requestAnimationFrame(() => {
-        prevScrollTopRef.current = el.scrollTop;
-        if (overflowRef.current != null) {
-          initialOverflowRef.current = {
-            ...overflowRef.current
-          };
-        }
-      });
-      return () => {
-        prevScrollTopRef.current = null;
-        initialOverflowRef.current = null;
-        el.removeEventListener("wheel", onWheel);
-      };
-    }
-  }, [enabled, open, elements.floating, overflowRef, scrollRef, onChange]);
-  const floating = React.useMemo(() => ({
-    onKeyDown() {
-      controlledScrollingRef.current = true;
-    },
-    onWheel() {
-      controlledScrollingRef.current = false;
-    },
-    onPointerMove() {
-      controlledScrollingRef.current = false;
-    },
-    onScroll() {
-      const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;
-      if (!overflowRef.current || !el || !controlledScrollingRef.current) {
-        return;
-      }
-      if (prevScrollTopRef.current !== null) {
-        const scrollDiff = el.scrollTop - prevScrollTopRef.current;
-        if (overflowRef.current.bottom < -0.5 && scrollDiff < -1 || overflowRef.current.top < -0.5 && scrollDiff > 1) {
-          ReactDOM.flushSync(() => onChange((d2) => d2 + scrollDiff));
-        }
-      }
-      requestAnimationFrame(() => {
-        prevScrollTopRef.current = el.scrollTop;
-      });
-    }
-  }), [elements.floating, onChange, overflowRef, scrollRef]);
-  return React.useMemo(() => enabled ? {
-    floating
-  } : {}, [enabled, floating]);
-}
-let y$1 = createContext({ styles: void 0, setReference: () => {
-}, setFloating: () => {
-}, getReferenceProps: () => ({}), getFloatingProps: () => ({}), slot: {} });
-y$1.displayName = "FloatingContext";
-let S$1 = createContext(null);
-S$1.displayName = "PlacementContext";
-function xe$1(e2) {
-  return useMemo(() => e2 ? typeof e2 == "string" ? { to: e2 } : e2 : null, [e2]);
-}
-function ye() {
-  return useContext(y$1).setReference;
-}
-function be() {
-  let { getFloatingProps: e2, slot: t2 } = useContext(y$1);
-  return useCallback((...n2) => Object.assign({}, e2(...n2), { "data-anchor": t2.anchor }), [e2, t2]);
-}
-function Re(e2 = null) {
-  e2 === false && (e2 = null), typeof e2 == "string" && (e2 = { to: e2 });
-  let t2 = useContext(S$1), n2 = useMemo(() => e2, [JSON.stringify(e2, typeof HTMLElement != "undefined" ? (r2, o2) => o2 instanceof HTMLElement ? o2.outerHTML : o2 : void 0)]);
-  n$2(() => {
-    t2 == null || t2(n2 != null ? n2 : null);
-  }, [t2, n2]);
-  let l2 = useContext(y$1);
-  return useMemo(() => [l2.setFloating, e2 ? l2.styles : {}], [l2.setFloating, e2, l2.styles]);
-}
-let q = 4;
-function ve({ children: e2, enabled: t2 = true }) {
-  let [n2, l2] = useState(null), [r2, o2] = useState(0), c2 = useRef(null), [u2, s2] = useState(null);
-  pe(u2);
-  let i2 = t2 && n2 !== null && u2 !== null, { to: F2 = "bottom", gap: C = 0, offset: M2 = 0, padding: p2 = 0, inner: P } = ce(n2, u2), [a3, f2 = "center"] = F2.split(" ");
-  n$2(() => {
-    i2 && o2(0);
-  }, [i2]);
-  let { refs: b, floatingStyles: w2, context: g2 } = useFloating({ open: i2, placement: a3 === "selection" ? f2 === "center" ? "bottom" : `bottom-${f2}` : f2 === "center" ? `${a3}` : `${a3}-${f2}`, strategy: "absolute", transform: false, middleware: [offset({ mainAxis: a3 === "selection" ? 0 : C, crossAxis: M2 }), shift({ padding: p2 }), a3 !== "selection" && flip({ padding: p2 }), a3 === "selection" && P ? inner({ ...P, padding: p2, overflowRef: c2, offset: r2, minItemsVisible: q, referenceOverflowThreshold: p2, onFallbackChange(h2) {
-    var O, W2;
-    if (!h2) return;
-    let d2 = g2.elements.floating;
-    if (!d2) return;
-    let T2 = parseFloat(getComputedStyle(d2).scrollPaddingBottom) || 0, $ = Math.min(q, d2.childElementCount), B = 0, N2 = 0;
-    for (let m2 of (W2 = (O = g2.elements.floating) == null ? void 0 : O.childNodes) != null ? W2 : []) if (m2 instanceof HTMLElement) {
-      let x2 = m2.offsetTop, k = x2 + m2.clientHeight + T2, H2 = d2.scrollTop, U = H2 + d2.clientHeight;
-      if (x2 >= H2 && k <= U) $--;
-      else {
-        N2 = Math.max(0, Math.min(k, U) - Math.max(x2, H2)), B = m2.clientHeight;
-        break;
-      }
-    }
-    $ >= 1 && o2((m2) => {
-      let x2 = B * $ - N2 + T2;
-      return m2 >= x2 ? m2 : x2;
-    });
-  } }) : null, size({ padding: p2, apply({ availableWidth: h2, availableHeight: d2, elements: T2 }) {
-    Object.assign(T2.floating.style, { overflow: "auto", maxWidth: `${h2}px`, maxHeight: `min(var(--anchor-max-height, 100vh), ${d2}px)` });
-  } })].filter(Boolean), whileElementsMounted: autoUpdate }), [I2 = a3, V2 = f2] = g2.placement.split("-");
-  a3 === "selection" && (I2 = "selection");
-  let G2 = useMemo(() => ({ anchor: [I2, V2].filter(Boolean).join(" ") }), [I2, V2]), K2 = useInnerOffset(g2, { overflowRef: c2, onChange: o2 }), { getReferenceProps: Q, getFloatingProps: X } = useInteractions([K2]), Y = o$2((h2) => {
-    s2(h2), b.setFloating(h2);
-  });
-  return React.createElement(S$1.Provider, { value: l2 }, React.createElement(y$1.Provider, { value: { setFloating: Y, setReference: b.setReference, styles: w2, getReferenceProps: Q, getFloatingProps: X, slot: G2 } }, e2));
-}
-function pe(e2) {
-  n$2(() => {
-    if (!e2) return;
-    let t2 = new MutationObserver(() => {
-      let n2 = window.getComputedStyle(e2).maxHeight, l2 = parseFloat(n2);
-      if (isNaN(l2)) return;
-      let r2 = parseInt(n2);
-      isNaN(r2) || l2 !== r2 && (e2.style.maxHeight = `${Math.ceil(l2)}px`);
-    });
-    return t2.observe(e2, { attributes: true, attributeFilter: ["style"] }), () => {
-      t2.disconnect();
-    };
-  }, [e2]);
-}
-function ce(e2, t2) {
-  var o2, c2, u2;
-  let n2 = L((o2 = e2 == null ? void 0 : e2.gap) != null ? o2 : "var(--anchor-gap, 0)", t2), l2 = L((c2 = e2 == null ? void 0 : e2.offset) != null ? c2 : "var(--anchor-offset, 0)", t2), r2 = L((u2 = e2 == null ? void 0 : e2.padding) != null ? u2 : "var(--anchor-padding, 0)", t2);
-  return { ...e2, gap: n2, offset: l2, padding: r2 };
-}
-function L(e2, t2, n2 = void 0) {
-  let l2 = p$1(), r2 = o$2((s2, i2) => {
-    if (s2 == null) return [n2, null];
-    if (typeof s2 == "number") return [s2, null];
-    if (typeof s2 == "string") {
-      if (!i2) return [n2, null];
-      let F2 = J$1(s2, i2);
-      return [F2, (C) => {
-        let M2 = D$1(s2);
-        {
-          let p2 = M2.map((P) => window.getComputedStyle(i2).getPropertyValue(P));
-          l2.requestAnimationFrame(function P() {
-            l2.nextFrame(P);
-            let a3 = false;
-            for (let [b, w2] of M2.entries()) {
-              let g2 = window.getComputedStyle(i2).getPropertyValue(w2);
-              if (p2[b] !== g2) {
-                p2[b] = g2, a3 = true;
-                break;
-              }
-            }
-            if (!a3) return;
-            let f2 = J$1(s2, i2);
-            F2 !== f2 && (C(f2), F2 = f2);
-          });
-        }
-        return l2.dispose;
-      }];
-    }
-    return [n2, null];
-  }), o2 = useMemo(() => r2(e2, t2)[0], [e2, t2]), [c2 = o2, u2] = useState();
-  return n$2(() => {
-    let [s2, i2] = r2(e2, t2);
-    if (u2(s2), !!i2) return i2(u2);
-  }, [e2, t2]), c2;
-}
-function D$1(e2) {
-  let t2 = /var\((.*)\)/.exec(e2);
-  if (t2) {
-    let n2 = t2[1].indexOf(",");
-    if (n2 === -1) return [t2[1]];
-    let l2 = t2[1].slice(0, n2).trim(), r2 = t2[1].slice(n2 + 1).trim();
-    return r2 ? [l2, ...D$1(r2)] : [l2];
-  }
-  return [];
-}
-function J$1(e2, t2) {
-  let n2 = document.createElement("div");
-  t2.appendChild(n2), n2.style.setProperty("margin-top", "0px", "important"), n2.style.setProperty("margin-top", e2, "important");
-  let l2 = parseFloat(window.getComputedStyle(n2).marginTop) || 0;
-  return t2.removeChild(n2), l2;
-}
-function f$1({ children: o2, freeze: e2 }) {
-  let n2 = l$2(e2, o2);
-  return React__default.createElement(React__default.Fragment, null, n2);
-}
-function l$2(o2, e2) {
-  let [n2, t2] = useState(e2);
-  return !o2 && n2 !== e2 && t2(e2), o2 ? n2 : e2;
-}
-function t(n2) {
-  function e2() {
-    document.readyState !== "loading" && (n2(), document.removeEventListener("DOMContentLoaded", e2));
-  }
-  typeof window != "undefined" && typeof document != "undefined" && (document.addEventListener("DOMContentLoaded", e2), e2());
-}
-let r = [];
-t(() => {
-  function e2(t2) {
-    if (!(t2.target instanceof HTMLElement) || t2.target === document.body || r[0] === t2.target) return;
-    let n2 = t2.target;
-    n2 = n2.closest(f$6), r.unshift(n2 != null ? n2 : t2.target), r = r.filter((o2) => o2 != null && o2.isConnected), r.splice(10);
-  }
-  window.addEventListener("click", e2, { capture: true }), window.addEventListener("mousedown", e2, { capture: true }), window.addEventListener("focus", e2, { capture: true }), document.body.addEventListener("click", e2, { capture: true }), document.body.addEventListener("mousedown", e2, { capture: true }), document.body.addEventListener("focus", e2, { capture: true });
-});
-function u(l2) {
-  throw new Error("Unexpected object: " + l2);
-}
-var c$1 = ((i2) => (i2[i2.First = 0] = "First", i2[i2.Previous = 1] = "Previous", i2[i2.Next = 2] = "Next", i2[i2.Last = 3] = "Last", i2[i2.Specific = 4] = "Specific", i2[i2.Nothing = 5] = "Nothing", i2))(c$1 || {});
-function f(l2, n2) {
-  let t2 = n2.resolveItems();
-  if (t2.length <= 0) return null;
-  let r2 = n2.resolveActiveIndex(), s2 = r2 != null ? r2 : -1;
-  switch (l2.focus) {
-    case 0: {
-      for (let e2 = 0; e2 < t2.length; ++e2) if (!n2.resolveDisabled(t2[e2], e2, t2)) return e2;
-      return r2;
-    }
-    case 1: {
-      s2 === -1 && (s2 = t2.length);
-      for (let e2 = s2 - 1; e2 >= 0; --e2) if (!n2.resolveDisabled(t2[e2], e2, t2)) return e2;
-      return r2;
-    }
-    case 2: {
-      for (let e2 = s2 + 1; e2 < t2.length; ++e2) if (!n2.resolveDisabled(t2[e2], e2, t2)) return e2;
-      return r2;
-    }
-    case 3: {
-      for (let e2 = t2.length - 1; e2 >= 0; --e2) if (!n2.resolveDisabled(t2[e2], e2, t2)) return e2;
-      return r2;
-    }
-    case 4: {
-      for (let e2 = 0; e2 < t2.length; ++e2) if (n2.resolveId(t2[e2], e2, t2) === l2.id) return e2;
-      return r2;
-    }
-    case 5:
-      return null;
-    default:
-      u(l2);
-  }
-}
-var g = ((f2) => (f2[f2.Left = 0] = "Left", f2[f2.Right = 2] = "Right", f2))(g || {});
-function c(t2) {
-  let r2 = o$2(t2), e2 = useRef(false);
-  useEffect(() => (e2.current = false, () => {
-    e2.current = true, t$3(() => {
-      e2.current && r2();
-    });
-  }), [r2]);
-}
-function s() {
-  let r2 = typeof document == "undefined";
-  return "useSyncExternalStore" in React ? ((o2) => o2.useSyncExternalStore)(React)(() => () => {
-  }, () => false, () => !r2) : false;
-}
-function l$1() {
-  let r2 = s(), [e2, n2] = React.useState(s$4.isHandoffComplete);
-  return e2 && s$4.isHandoffComplete === false && n2(false), React.useEffect(() => {
-    e2 !== true && n2(true);
-  }, [e2]), React.useEffect(() => s$4.handoff(), []), r2 ? false : e2;
-}
-let e = createContext(false);
-function a2() {
-  return useContext(e);
-}
-function D(p2) {
-  let r2 = a2(), l2 = useContext(v), e2 = n(p2), [o2, n$12] = useState(() => {
-    var t2;
-    if (!r2 && l2 !== null) return (t2 = l2.current) != null ? t2 : null;
-    if (s$4.isServer) return null;
-    let u2 = e2 == null ? void 0 : e2.getElementById("headlessui-portal-root");
-    if (u2) return u2;
-    if (e2 === null) return null;
-    let a3 = e2.createElement("div");
-    return a3.setAttribute("id", "headlessui-portal-root"), e2.body.appendChild(a3);
-  });
-  return useEffect(() => {
-    o2 !== null && (e2 != null && e2.body.contains(o2) || e2 == null || e2.body.appendChild(o2));
-  }, [o2, e2]), useEffect(() => {
-    r2 || l2 !== null && n$12(l2.current);
-  }, [l2, n$12, r2]), o2;
-}
-let M = Fragment, N = W$1(function(r2, l2) {
-  let e2 = r2, o2 = useRef(null), n$12 = y$3(T((i2) => {
-    o2.current = i2;
-  }), l2), u2 = n(o2), a3 = D(o2), [t2] = useState(() => {
-    var i2;
-    return s$4.isServer ? null : (i2 = u2 == null ? void 0 : u2.createElement("div")) != null ? i2 : null;
-  }), s2 = useContext(y), b = l$1();
-  return n$2(() => {
-    !a3 || !t2 || a3.contains(t2) || (t2.setAttribute("data-headlessui-portal", ""), a3.appendChild(t2));
-  }, [a3, t2]), n$2(() => {
-    if (t2 && s2) return s2.register(t2);
-  }, [s2, t2]), c(() => {
-    var i2;
-    !a3 || !t2 || (t2 instanceof Node && a3.contains(t2) && a3.removeChild(t2), a3.childNodes.length <= 0 && ((i2 = a3.parentElement) == null || i2.removeChild(a3)));
-  }), b ? !a3 || !t2 ? null : createPortal(H({ ourProps: { ref: n$12 }, theirProps: e2, slot: {}, defaultTag: M, name: "Portal" }), t2) : null;
-});
-function S(p2, r2) {
-  let l2 = y$3(r2), { enabled: e2 = true, ...o2 } = p2;
-  return e2 ? React__default.createElement(N, { ...o2, ref: l2 }) : H({ ourProps: { ref: l2 }, theirProps: o2, slot: {}, defaultTag: M, name: "Portal" });
-}
-let j = Fragment, v = createContext(null);
-function W(p2, r2) {
-  let { target: l2, ...e2 } = p2, n2 = { ref: y$3(r2) };
-  return React__default.createElement(v.Provider, { value: l2 }, H({ ourProps: n2, theirProps: e2, defaultTag: j, name: "Popover.Group" }));
-}
-let y = createContext(null);
-let I = W$1(S), J = W$1(W), te = Object.assign(I, { Group: J });
-var Co = ((e2) => (e2[e2.Open = 0] = "Open", e2[e2.Closed = 1] = "Closed", e2))(Co || {}), Ro = ((e2) => (e2[e2.Single = 0] = "Single", e2[e2.Multi = 1] = "Multi", e2))(Ro || {}), So = ((t2) => (t2[t2.Pointer = 0] = "Pointer", t2[t2.Focus = 1] = "Focus", t2[t2.Other = 2] = "Other", t2))(So || {}), Po = ((u2) => (u2[u2.OpenCombobox = 0] = "OpenCombobox", u2[u2.CloseCombobox = 1] = "CloseCombobox", u2[u2.GoToOption = 2] = "GoToOption", u2[u2.SetTyping = 3] = "SetTyping", u2[u2.RegisterOption = 4] = "RegisterOption", u2[u2.UnregisterOption = 5] = "UnregisterOption", u2[u2.SetActivationTrigger = 6] = "SetActivationTrigger", u2[u2.UpdateVirtualConfiguration = 7] = "UpdateVirtualConfiguration", u2))(Po || {});
-function Te(o2, r2 = (e2) => e2) {
-  let e2 = o2.activeOptionIndex !== null ? o2.options[o2.activeOptionIndex] : null, t2 = r2(o2.options.slice()), c2 = t2.length > 0 && t2[0].dataRef.current.order !== null ? t2.sort((f2, s2) => f2.dataRef.current.order - s2.dataRef.current.order) : _(t2, (f2) => f2.dataRef.current.domRef.current), d2 = e2 ? c2.indexOf(e2) : null;
-  return d2 === -1 && (d2 = null), { options: c2, activeOptionIndex: d2 };
-}
-let Ao = { [1](o2) {
-  var r2;
-  return (r2 = o2.dataRef.current) != null && r2.disabled || o2.comboboxState === 1 ? o2 : { ...o2, activeOptionIndex: null, comboboxState: 1, isTyping: false, activationTrigger: 2, __demoMode: false };
-}, [0](o2) {
-  var r2, e2;
-  if ((r2 = o2.dataRef.current) != null && r2.disabled || o2.comboboxState === 0) return o2;
-  if ((e2 = o2.dataRef.current) != null && e2.value) {
-    let t2 = o2.dataRef.current.calculateIndex(o2.dataRef.current.value);
-    if (t2 !== -1) return { ...o2, activeOptionIndex: t2, comboboxState: 0, __demoMode: false };
-  }
-  return { ...o2, comboboxState: 0, __demoMode: false };
-}, [3](o2, r2) {
-  return o2.isTyping === r2.isTyping ? o2 : { ...o2, isTyping: r2.isTyping };
-}, [2](o2, r2) {
-  var d2, f$12, s2, u2, a3;
-  if ((d2 = o2.dataRef.current) != null && d2.disabled || (f$12 = o2.dataRef.current) != null && f$12.optionsRef.current && !((s2 = o2.dataRef.current) != null && s2.optionsPropsRef.current.static) && o2.comboboxState === 1) return o2;
-  if (o2.virtual) {
-    let { options: n2, disabled: T2 } = o2.virtual, C = r2.focus === c$1.Specific ? r2.idx : f(r2, { resolveItems: () => n2, resolveActiveIndex: () => {
-      var p2, L2;
-      return (L2 = (p2 = o2.activeOptionIndex) != null ? p2 : n2.findIndex((M2) => !T2(M2))) != null ? L2 : null;
-    }, resolveDisabled: T2, resolveId() {
-      throw new Error("Function not implemented.");
-    } }), _2 = (u2 = r2.trigger) != null ? u2 : 2;
-    return o2.activeOptionIndex === C && o2.activationTrigger === _2 ? o2 : { ...o2, activeOptionIndex: C, activationTrigger: _2, isTyping: false, __demoMode: false };
-  }
-  let e2 = Te(o2);
-  if (e2.activeOptionIndex === null) {
-    let n2 = e2.options.findIndex((T2) => !T2.dataRef.current.disabled);
-    n2 !== -1 && (e2.activeOptionIndex = n2);
-  }
-  let t2 = r2.focus === c$1.Specific ? r2.idx : f(r2, { resolveItems: () => e2.options, resolveActiveIndex: () => e2.activeOptionIndex, resolveId: (n2) => n2.id, resolveDisabled: (n2) => n2.dataRef.current.disabled }), c2 = (a3 = r2.trigger) != null ? a3 : 2;
-  return o2.activeOptionIndex === t2 && o2.activationTrigger === c2 ? o2 : { ...o2, ...e2, isTyping: false, activeOptionIndex: t2, activationTrigger: c2, __demoMode: false };
-}, [4]: (o2, r2) => {
-  var d2, f2, s2;
-  if ((d2 = o2.dataRef.current) != null && d2.virtual) return { ...o2, options: [...o2.options, r2.payload] };
-  let e2 = r2.payload, t2 = Te(o2, (u2) => (u2.push(e2), u2));
-  o2.activeOptionIndex === null && (f2 = o2.dataRef.current) != null && f2.isSelected(r2.payload.dataRef.current.value) && (t2.activeOptionIndex = t2.options.indexOf(e2));
-  let c2 = { ...o2, ...t2, activationTrigger: 2 };
-  return (s2 = o2.dataRef.current) != null && s2.__demoMode && o2.dataRef.current.value === void 0 && (c2.activeOptionIndex = 0), c2;
-}, [5]: (o2, r2) => {
-  var t2;
-  if ((t2 = o2.dataRef.current) != null && t2.virtual) return { ...o2, options: o2.options.filter((c2) => c2.id !== r2.id) };
-  let e2 = Te(o2, (c2) => {
-    let d2 = c2.findIndex((f2) => f2.id === r2.id);
-    return d2 !== -1 && c2.splice(d2, 1), c2;
-  });
-  return { ...o2, ...e2, activationTrigger: 2 };
-}, [6]: (o2, r2) => o2.activationTrigger === r2.trigger ? o2 : { ...o2, activationTrigger: r2.trigger }, [7]: (o2, r2) => {
-  var t2, c2;
-  if (o2.virtual === null) return { ...o2, virtual: { options: r2.options, disabled: (t2 = r2.disabled) != null ? t2 : () => false } };
-  if (o2.virtual.options === r2.options && o2.virtual.disabled === r2.disabled) return o2;
-  let e2 = o2.activeOptionIndex;
-  if (o2.activeOptionIndex !== null) {
-    let d2 = r2.options.indexOf(o2.virtual.options[o2.activeOptionIndex]);
-    d2 !== -1 ? e2 = d2 : e2 = null;
-  }
-  return { ...o2, activeOptionIndex: e2, virtual: { options: r2.options, disabled: (c2 = r2.disabled) != null ? c2 : () => false } };
-} }, xe = createContext(null);
-xe.displayName = "ComboboxActionsContext";
-function re(o2) {
-  let r2 = useContext(xe);
-  if (r2 === null) {
-    let e2 = new Error(`<${o2} /> is missing a parent <Combobox /> component.`);
-    throw Error.captureStackTrace && Error.captureStackTrace(e2, re), e2;
-  }
-  return r2;
-}
-let Le = createContext(null);
-function Io(o2) {
-  let r2 = oe("VirtualProvider"), { options: e2 } = r2.virtual, [t2, c2] = useMemo(() => {
-    let a3 = r2.optionsRef.current;
-    if (!a3) return [0, 0];
-    let n2 = window.getComputedStyle(a3);
-    return [parseFloat(n2.paddingBlockStart || n2.paddingTop), parseFloat(n2.paddingBlockEnd || n2.paddingBottom)];
-  }, [r2.optionsRef.current]), d2 = useVirtualizer({ enabled: e2.length !== 0, scrollPaddingStart: t2, scrollPaddingEnd: c2, count: e2.length, estimateSize() {
-    return 40;
-  }, getScrollElement() {
-    var a3;
-    return (a3 = r2.optionsRef.current) != null ? a3 : null;
-  }, overscan: 12 }), [f2, s2] = useState(0);
-  n$2(() => {
-    s2((a3) => a3 + 1);
-  }, [e2]);
-  let u2 = d2.getVirtualItems();
-  return u2.length === 0 ? null : React__default.createElement(Le.Provider, { value: d2 }, React__default.createElement("div", { style: { position: "relative", width: "100%", height: `${d2.getTotalSize()}px` }, ref: (a3) => {
-    if (a3) {
-      if (typeof process != "undefined" && process.env.JEST_WORKER_ID !== void 0 || r2.activationTrigger === 0) return;
-      r2.activeOptionIndex !== null && e2.length > r2.activeOptionIndex && d2.scrollToIndex(r2.activeOptionIndex);
-    }
-  } }, u2.map((a3) => {
-    var n2;
-    return React__default.createElement(Fragment, { key: a3.key }, React__default.cloneElement((n2 = o2.children) == null ? void 0 : n2.call(o2, { ...o2.slot, option: e2[a3.index] }), { key: `${f2}-${a3.key}`, "data-index": a3.index, "aria-setsize": e2.length, "aria-posinset": a3.index + 1, style: { position: "absolute", top: 0, left: 0, transform: `translateY(${a3.start}px)`, overflowAnchor: "none" } }));
-  })));
-}
-let ie = createContext(null);
-ie.displayName = "ComboboxDataContext";
-function oe(o2) {
-  let r2 = useContext(ie);
-  if (r2 === null) {
-    let e2 = new Error(`<${o2} /> is missing a parent <Combobox /> component.`);
-    throw Error.captureStackTrace && Error.captureStackTrace(e2, oe), e2;
-  }
-  return r2;
-}
-function Eo(o2, r2) {
-  return u$5(r2.type, Ao, o2, r2);
-}
-let _o = Fragment;
-function ho(o2, r2) {
-  var ge, ve$1;
-  let e2 = a$5(), { value: t2, defaultValue: c2, onChange: d2, form: f2, name: s2, by: u2, disabled: a3 = e2 || false, onClose: n2, __demoMode: T2 = false, multiple: C = false, immediate: _2 = false, virtual: p2 = null, nullable: L2, ...M2 } = o2, F2 = l$3(c2), [v2 = C ? [] : void 0, y2] = T$1(t2, d2, F2), [A2, R] = useReducer(Eo, { dataRef: createRef(), comboboxState: T2 ? 0 : 1, isTyping: false, options: [], virtual: p2 ? { options: p2.options, disabled: (ge = p2.disabled) != null ? ge : () => false } : null, activeOptionIndex: null, activationTrigger: 2, __demoMode: T2 }), h2 = useRef(false), O = useRef({ static: false, hold: false }), G2 = useRef(null), J2 = useRef(null), Q = useRef(null), I2 = u$4(u2), B = o$2((b) => p2 ? u2 === null ? p2.options.indexOf(b) : p2.options.findIndex((g2) => I2(g2, b)) : A2.options.findIndex((g2) => I2(g2.dataRef.current.value, b))), k = useCallback((b) => u$5(i2.mode, { [1]: () => v2.some((g2) => I2(g2, b)), [0]: () => I2(v2, b) }), [v2]), K2 = o$2((b) => A2.activeOptionIndex === B(b)), i2 = useMemo(() => ({ ...A2, immediate: _2, optionsPropsRef: O, inputRef: G2, buttonRef: J2, optionsRef: Q, value: v2, defaultValue: F2, disabled: a3, mode: C ? 1 : 0, virtual: p2 ? A2.virtual : null, get activeOptionIndex() {
-    if (h2.current && A2.activeOptionIndex === null && (p2 ? p2.options.length > 0 : A2.options.length > 0)) {
-      if (p2) {
-        let g2 = p2.options.findIndex((j2) => {
-          var ue, Oe;
-          return !((Oe = (ue = p2.disabled) == null ? void 0 : ue.call(p2, j2)) != null && Oe);
-        });
-        if (g2 !== -1) return g2;
-      }
-      let b = A2.options.findIndex((g2) => !g2.dataRef.current.disabled);
-      if (b !== -1) return b;
-    }
-    return A2.activeOptionIndex;
-  }, calculateIndex: B, compare: I2, isSelected: k, isActive: K2 }), [v2, F2, a3, C, T2, A2, p2]);
-  n$2(() => {
-    var b;
-    p2 && R({ type: 7, options: p2.options, disabled: (b = p2.disabled) != null ? b : null });
-  }, [p2, p2 == null ? void 0 : p2.options, p2 == null ? void 0 : p2.disabled]), n$2(() => {
-    A2.dataRef.current = i2;
-  }, [i2]);
-  let N2 = i2.comboboxState === 0;
-  F$1(N2, [i2.buttonRef, i2.inputRef, i2.optionsRef], () => x2.closeCombobox());
-  let q2 = useMemo(() => {
-    var b, g2, j2;
-    return { open: i2.comboboxState === 0, disabled: a3, activeIndex: i2.activeOptionIndex, activeOption: i2.activeOptionIndex === null ? null : i2.virtual ? i2.virtual.options[(b = i2.activeOptionIndex) != null ? b : 0] : (j2 = (g2 = i2.options[i2.activeOptionIndex]) == null ? void 0 : g2.dataRef.current.value) != null ? j2 : null, value: v2 };
-  }, [i2, a3, v2]), Y = o$2(() => {
-    if (i2.activeOptionIndex !== null) {
-      if (x2.setIsTyping(false), i2.virtual) S2(i2.virtual.options[i2.activeOptionIndex]);
-      else {
-        let { dataRef: b } = i2.options[i2.activeOptionIndex];
-        S2(b.current.value);
-      }
-      x2.goToOption(c$1.Specific, i2.activeOptionIndex);
-    }
-  }), E2 = o$2(() => {
-    R({ type: 0 }), h2.current = true;
-  }), ae = o$2(() => {
-    R({ type: 1 }), h2.current = false, n2 == null || n2();
-  }), le = o$2((b) => {
-    R({ type: 3, isTyping: b });
-  }), l2 = o$2((b, g2, j2) => (h2.current = false, b === c$1.Specific ? R({ type: 2, focus: c$1.Specific, idx: g2, trigger: j2 }) : R({ type: 2, focus: b, trigger: j2 }))), U = o$2((b, g2) => (R({ type: 4, payload: { id: b, dataRef: g2 } }), () => {
-    i2.isActive(g2.current.value) && (h2.current = true), R({ type: 5, id: b });
-  })), S2 = o$2((b) => u$5(i2.mode, { [0]() {
-    return y2 == null ? void 0 : y2(b);
-  }, [1]() {
-    let g2 = i2.value.slice(), j2 = g2.findIndex((ue) => I2(ue, b));
-    return j2 === -1 ? g2.push(b) : g2.splice(j2, 1), y2 == null ? void 0 : y2(g2);
-  } })), H$1 = o$2((b) => {
-    R({ type: 6, trigger: b });
-  }), x2 = useMemo(() => ({ onChange: S2, registerOption: U, goToOption: l2, setIsTyping: le, closeCombobox: ae, openCombobox: E2, setActivationTrigger: H$1, selectActiveOption: Y }), []), [w2, W2] = z(), we = r2 === null ? {} : { ref: r2 }, Be = useCallback(() => {
-    if (F2 !== void 0) return y2 == null ? void 0 : y2(F2);
-  }, [y2, F2]);
-  return React__default.createElement(W2, { value: w2, props: { htmlFor: (ve$1 = i2.inputRef.current) == null ? void 0 : ve$1.id }, slot: { open: i2.comboboxState === 0, disabled: a3 } }, React__default.createElement(ve, null, React__default.createElement(xe.Provider, { value: x2 }, React__default.createElement(ie.Provider, { value: i2 }, React__default.createElement(c$2, { value: u$5(i2.comboboxState, { [0]: i$2.Open, [1]: i$2.Closed }) }, s2 != null && React__default.createElement(j$1, { disabled: a3, data: v2 != null ? { [s2]: v2 } : {}, form: f2, onReset: Be }), H({ ourProps: we, theirProps: M2, slot: q2, defaultTag: _o, name: "Combobox" }))))));
-}
-let Do = "input";
-function Mo(o2, r$12) {
-  var q2, Y, E2, ae, le;
-  let e2 = oe("Combobox.Input"), t2 = re("Combobox.Input"), c2 = useId$1(), d2 = u$6(), { id: f2 = d2 || `headlessui-combobox-input-${c2}`, onChange: s2, displayValue: u2, disabled: a3 = e2.disabled || false, autoFocus: n$12 = false, type: T2 = "text", ...C } = o2, _2 = y$3(e2.inputRef, r$12, ye()), p2 = n(e2.inputRef), L2 = p$1(), M2 = o$2(() => {
-    t2.onChange(null), e2.optionsRef.current && (e2.optionsRef.current.scrollTop = 0), t2.goToOption(c$1.Nothing);
-  }), F2 = useMemo(() => {
-    var l2;
-    return typeof u2 == "function" && e2.value !== void 0 ? (l2 = u2(e2.value)) != null ? l2 : "" : typeof e2.value == "string" ? e2.value : "";
-  }, [e2.value, u2]);
-  m$1(([l2, U], [S2, H2]) => {
-    if (e2.isTyping) return;
-    let x2 = e2.inputRef.current;
-    x2 && ((H2 === 0 && U === 1 || l2 !== S2) && (x2.value = l2), requestAnimationFrame(() => {
-      if (e2.isTyping || !x2 || (p2 == null ? void 0 : p2.activeElement) !== x2) return;
-      let { selectionStart: w2, selectionEnd: W2 } = x2;
-      Math.abs((W2 != null ? W2 : 0) - (w2 != null ? w2 : 0)) === 0 && w2 === 0 && x2.setSelectionRange(x2.value.length, x2.value.length);
-    }));
-  }, [F2, e2.comboboxState, p2, e2.isTyping]), m$1(([l2], [U]) => {
-    if (l2 === 0 && U === 1) {
-      if (e2.isTyping) return;
-      let S2 = e2.inputRef.current;
-      if (!S2) return;
-      let H2 = S2.value, { selectionStart: x2, selectionEnd: w2, selectionDirection: W2 } = S2;
-      S2.value = "", S2.value = H2, W2 !== null ? S2.setSelectionRange(x2, w2, W2) : S2.setSelectionRange(x2, w2);
-    }
-  }, [e2.comboboxState]);
-  let v2 = useRef(false), y2 = o$2(() => {
-    v2.current = true;
-  }), A2 = o$2(() => {
-    L2.nextFrame(() => {
-      v2.current = false;
-    });
-  }), R = o$2((l2) => {
-    switch (t2.setIsTyping(true), l2.key) {
-      case o$3.Enter:
-        if (e2.comboboxState !== 0 || v2.current) return;
-        if (l2.preventDefault(), l2.stopPropagation(), e2.activeOptionIndex === null) {
-          t2.closeCombobox();
-          return;
-        }
-        t2.selectActiveOption(), e2.mode === 0 && t2.closeCombobox();
-        break;
-      case o$3.ArrowDown:
-        return l2.preventDefault(), l2.stopPropagation(), u$5(e2.comboboxState, { [0]: () => t2.goToOption(c$1.Next), [1]: () => t2.openCombobox() });
-      case o$3.ArrowUp:
-        return l2.preventDefault(), l2.stopPropagation(), u$5(e2.comboboxState, { [0]: () => t2.goToOption(c$1.Previous), [1]: () => {
-          flushSync(() => t2.openCombobox()), e2.value || t2.goToOption(c$1.Last);
-        } });
-      case o$3.Home:
-        if (l2.shiftKey) break;
-        return l2.preventDefault(), l2.stopPropagation(), t2.goToOption(c$1.First);
-      case o$3.PageUp:
-        return l2.preventDefault(), l2.stopPropagation(), t2.goToOption(c$1.First);
-      case o$3.End:
-        if (l2.shiftKey) break;
-        return l2.preventDefault(), l2.stopPropagation(), t2.goToOption(c$1.Last);
-      case o$3.PageDown:
-        return l2.preventDefault(), l2.stopPropagation(), t2.goToOption(c$1.Last);
-      case o$3.Escape:
-        return e2.comboboxState !== 0 ? void 0 : (l2.preventDefault(), e2.optionsRef.current && !e2.optionsPropsRef.current.static && l2.stopPropagation(), e2.mode === 0 && e2.value === null && M2(), t2.closeCombobox());
-      case o$3.Tab:
-        if (e2.comboboxState !== 0) return;
-        e2.mode === 0 && e2.activationTrigger !== 1 && t2.selectActiveOption(), t2.closeCombobox();
-        break;
-    }
-  }), h2 = o$2((l2) => {
-    s2 == null || s2(l2), e2.mode === 0 && l2.target.value === "" && M2(), t2.openCombobox();
-  }), O = o$2((l2) => {
-    var S2, H2, x2;
-    let U = (S2 = l2.relatedTarget) != null ? S2 : r.find((w2) => w2 !== l2.currentTarget);
-    if (!((H2 = e2.optionsRef.current) != null && H2.contains(U)) && !((x2 = e2.buttonRef.current) != null && x2.contains(U)) && e2.comboboxState === 0) return l2.preventDefault(), e2.mode === 0 && e2.value === null && M2(), t2.closeCombobox();
-  }), G$1 = o$2((l2) => {
-    var S2, H2, x2;
-    let U = (S2 = l2.relatedTarget) != null ? S2 : r.find((w2) => w2 !== l2.currentTarget);
-    (H2 = e2.buttonRef.current) != null && H2.contains(U) || (x2 = e2.optionsRef.current) != null && x2.contains(U) || e2.disabled || e2.immediate && e2.comboboxState !== 0 && L2.microTask(() => {
-      flushSync(() => t2.openCombobox()), t2.setActivationTrigger(1);
-    });
-  }), J2 = I$1(), Q = G(), { isFocused: I2, focusProps: B } = $f7dceffc5ad7768b$export$4e328f61c538687f({ autoFocus: n$12 }), { isHovered: k, hoverProps: K2 } = $6179b936705e76d3$export$ae780daf29e6d456({ isDisabled: a3 }), i2 = useMemo(() => ({ open: e2.comboboxState === 0, disabled: a3, hover: k, focus: I2, autofocus: n$12 }), [e2, k, I2, n$12, a3]), N2 = D$2({ ref: _2, id: f2, role: "combobox", type: T2, "aria-controls": (q2 = e2.optionsRef.current) == null ? void 0 : q2.id, "aria-expanded": e2.comboboxState === 0, "aria-activedescendant": e2.activeOptionIndex === null ? void 0 : e2.virtual ? (Y = e2.options.find((l2) => !l2.dataRef.current.disabled && e2.compare(l2.dataRef.current.value, e2.virtual.options[e2.activeOptionIndex]))) == null ? void 0 : Y.id : (E2 = e2.options[e2.activeOptionIndex]) == null ? void 0 : E2.id, "aria-labelledby": J2, "aria-describedby": Q, "aria-autocomplete": "list", defaultValue: (le = (ae = o2.defaultValue) != null ? ae : e2.defaultValue !== void 0 ? u2 == null ? void 0 : u2(e2.defaultValue) : null) != null ? le : e2.defaultValue, disabled: a3 || void 0, autoFocus: n$12, onCompositionStart: y2, onCompositionEnd: A2, onKeyDown: R, onChange: h2, onFocus: G$1, onBlur: O }, B, K2);
-  return H({ ourProps: N2, theirProps: C, slot: i2, defaultTag: Do, name: "Combobox.Input" });
-}
-let Fo = "button";
-function Vo(o2, r2) {
-  var h2;
-  let e2 = oe("Combobox.Button"), t2 = re("Combobox.Button"), c2 = y$3(e2.buttonRef, r2), d2 = useId$1(), { id: f2 = `headlessui-combobox-button-${d2}`, disabled: s2 = e2.disabled || false, autoFocus: u2 = false, ...a3 } = o2, n2 = f$3(e2.inputRef), T2 = o$2((O) => {
-    switch (O.key) {
-      case o$3.Space:
-      case o$3.Enter:
-        O.preventDefault(), O.stopPropagation(), e2.comboboxState === 1 && flushSync(() => t2.openCombobox()), n2();
-        return;
-      case o$3.ArrowDown:
-        O.preventDefault(), O.stopPropagation(), e2.comboboxState === 1 && (flushSync(() => t2.openCombobox()), e2.value || t2.goToOption(c$1.First)), n2();
-        return;
-      case o$3.ArrowUp:
-        O.preventDefault(), O.stopPropagation(), e2.comboboxState === 1 && (flushSync(() => t2.openCombobox()), e2.value || t2.goToOption(c$1.Last)), n2();
-        return;
-      case o$3.Escape:
-        if (e2.comboboxState !== 0) return;
-        O.preventDefault(), e2.optionsRef.current && !e2.optionsPropsRef.current.static && O.stopPropagation(), flushSync(() => t2.closeCombobox()), n2();
-        return;
-      default:
-        return;
-    }
-  }), C = o$2((O) => {
-    O.preventDefault(), !r$2(O.currentTarget) && (O.button === g.Left && (e2.comboboxState === 0 ? t2.closeCombobox() : t2.openCombobox()), n2());
-  }), _2 = I$1([f2]), { isFocusVisible: p2, focusProps: L2 } = $f7dceffc5ad7768b$export$4e328f61c538687f({ autoFocus: u2 }), { isHovered: M2, hoverProps: F2 } = $6179b936705e76d3$export$ae780daf29e6d456({ isDisabled: s2 }), { pressed: v2, pressProps: y2 } = w({ disabled: s2 }), A2 = useMemo(() => ({ open: e2.comboboxState === 0, active: v2 || e2.comboboxState === 0, disabled: s2, value: e2.value, hover: M2, focus: p2 }), [e2, M2, p2, v2, s2]), R = D$2({ ref: c2, id: f2, type: T$2(o2, e2.buttonRef), tabIndex: -1, "aria-haspopup": "listbox", "aria-controls": (h2 = e2.optionsRef.current) == null ? void 0 : h2.id, "aria-expanded": e2.comboboxState === 0, "aria-labelledby": _2, disabled: s2 || void 0, autoFocus: u2, onMouseDown: C, onKeyDown: T2 }, L2, F2, y2);
-  return H({ ourProps: R, theirProps: a3, slot: A2, defaultTag: Fo, name: "Combobox.Button" });
-}
-let Lo = "div", wo = M$1.RenderStrategy | M$1.Static;
-function Bo(o2, r2) {
-  var N2, q2, Y;
-  let e2 = useId$1(), { id: t2 = `headlessui-combobox-options-${e2}`, hold: c2 = false, anchor: d2, portal: f2 = false, modal: s2 = true, transition: u2 = false, ...a3 } = o2, n$12 = oe("Combobox.Options"), T2 = re("Combobox.Options"), C = xe$1(d2);
-  C && (f2 = true);
-  let [_2, p2] = Re(C), L2 = be(), M2 = y$3(n$12.optionsRef, r2, C ? _2 : null), F$12 = n(n$12.optionsRef), v2 = u$7(), [y2, A2] = V(u2, n$12.optionsRef, v2 !== null ? (v2 & i$2.Open) === i$2.Open : n$12.comboboxState === 0);
-  m$3(y2, n$12.inputRef, T2.closeCombobox);
-  let R = n$12.__demoMode ? false : s2 && n$12.comboboxState === 0;
-  f$2(R, F$12);
-  let h2 = n$12.__demoMode ? false : s2 && n$12.comboboxState === 0;
-  y$2(h2, { allowed: o$2(() => [n$12.inputRef.current, n$12.buttonRef.current, n$12.optionsRef.current]) }), n$2(() => {
-    var E2;
-    n$12.optionsPropsRef.current.static = (E2 = o2.static) != null ? E2 : false;
-  }, [n$12.optionsPropsRef, o2.static]), n$2(() => {
-    n$12.optionsPropsRef.current.hold = c2;
-  }, [n$12.optionsPropsRef, c2]), F(n$12.comboboxState === 0, { container: n$12.optionsRef.current, accept(E2) {
-    return E2.getAttribute("role") === "option" ? NodeFilter.FILTER_REJECT : E2.hasAttribute("role") ? NodeFilter.FILTER_SKIP : NodeFilter.FILTER_ACCEPT;
-  }, walk(E2) {
-    E2.setAttribute("role", "none");
-  } });
-  let O = I$1([(N2 = n$12.buttonRef.current) == null ? void 0 : N2.id]), G2 = useMemo(() => ({ open: n$12.comboboxState === 0, option: void 0 }), [n$12.comboboxState]), J2 = o$2(() => {
-    T2.setActivationTrigger(0);
-  }), Q = o$2((E2) => {
-    E2.preventDefault(), T2.setActivationTrigger(0);
-  }), I2 = D$2(C ? L2() : {}, { "aria-labelledby": O, role: "listbox", "aria-multiselectable": n$12.mode === 1 ? true : void 0, id: t2, ref: M2, style: { ...a3.style, ...p2, "--input-width": f$5(n$12.inputRef, true).width, "--button-width": f$5(n$12.buttonRef, true).width }, onWheel: n$12.activationTrigger === 0 ? void 0 : J2, onMouseDown: Q, ...A$1(A2) }), B = y2 && n$12.comboboxState === 1, k = l$2(B, (q2 = n$12.virtual) == null ? void 0 : q2.options), K2 = l$2(B, n$12.value), i2 = o$2((E2) => n$12.compare(K2, E2));
-  if (n$12.virtual) {
-    if (k === void 0) throw new Error("Missing `options` in virtual mode");
-    Object.assign(a3, { children: React__default.createElement(ie.Provider, { value: k !== n$12.virtual.options ? { ...n$12, virtual: { ...n$12.virtual, options: k } } : n$12 }, React__default.createElement(Io, { slot: G2 }, a3.children)) });
-  }
-  return React__default.createElement(te, { enabled: f2 ? o2.static || y2 : false }, React__default.createElement(ie.Provider, { value: n$12.mode === 1 ? n$12 : { ...n$12, isSelected: i2 } }, H({ ourProps: I2, theirProps: { ...a3, children: React__default.createElement(f$1, { freeze: B }, typeof a3.children == "function" ? (Y = a3.children) == null ? void 0 : Y.call(a3, G2) : a3.children) }, slot: G2, defaultTag: Lo, features: wo, visible: y2, name: "Combobox.Options" })));
-}
-let ko = "div";
-function No(o2, r2) {
-  var I2, B, k, K2;
-  let e2 = oe("Combobox.Option"), t2 = re("Combobox.Option"), c2 = useId$1(), { id: d2 = `headlessui-combobox-option-${c2}`, value: f2, disabled: s2 = (k = (B = (I2 = e2.virtual) == null ? void 0 : I2.disabled) == null ? void 0 : B.call(I2, f2)) != null ? k : false, order: u2 = null, ...a3 } = o2, n2 = f$3(e2.inputRef), T2 = e2.virtual ? e2.activeOptionIndex === e2.calculateIndex(f2) : e2.activeOptionIndex === null ? false : ((K2 = e2.options[e2.activeOptionIndex]) == null ? void 0 : K2.id) === d2, C = e2.isSelected(f2), _2 = useRef(null), p2 = s$3({ disabled: s2, value: f2, domRef: _2, order: u2 }), L2 = useContext(Le), M2 = y$3(r2, _2, L2 ? L2.measureElement : null), F2 = o$2(() => {
-    t2.setIsTyping(false), t2.onChange(f2);
-  });
-  n$2(() => t2.registerOption(d2, p2), [p2, d2]);
-  let v2 = useRef(!(e2.virtual || e2.__demoMode));
-  n$2(() => {
-    if (!e2.virtual && !e2.__demoMode) return o$1().requestAnimationFrame(() => {
-      v2.current = true;
-    });
-  }, [e2.virtual, e2.__demoMode]), n$2(() => {
-    if (v2.current && e2.comboboxState === 0 && T2 && e2.activationTrigger !== 0) return o$1().requestAnimationFrame(() => {
-      var i2, N2;
-      (N2 = (i2 = _2.current) == null ? void 0 : i2.scrollIntoView) == null || N2.call(i2, { block: "nearest" });
-    });
-  }, [_2, T2, e2.comboboxState, e2.activationTrigger, e2.activeOptionIndex]);
-  let y2 = o$2((i2) => {
-    i2.preventDefault(), i2.button === g.Left && (s2 || (F2(), n$1() || requestAnimationFrame(() => n2()), e2.mode === 0 && t2.closeCombobox()));
-  }), A2 = o$2(() => {
-    if (s2) return t2.goToOption(c$1.Nothing);
-    let i2 = e2.calculateIndex(f2);
-    t2.goToOption(c$1.Specific, i2);
-  }), R = u$1(), h2 = o$2((i2) => R.update(i2)), O = o$2((i2) => {
-    if (!R.wasMoved(i2) || s2 || T2) return;
-    let N2 = e2.calculateIndex(f2);
-    t2.goToOption(c$1.Specific, N2, 0);
-  }), G2 = o$2((i2) => {
-    R.wasMoved(i2) && (s2 || T2 && (e2.optionsPropsRef.current.hold || t2.goToOption(c$1.Nothing)));
-  }), J2 = useMemo(() => ({ active: T2, focus: T2, selected: C, disabled: s2 }), [T2, C, s2]);
-  return H({ ourProps: { id: d2, ref: M2, role: "option", tabIndex: s2 === true ? void 0 : -1, "aria-disabled": s2 === true ? true : void 0, "aria-selected": C, disabled: void 0, onMouseDown: y2, onFocus: A2, onPointerEnter: h2, onMouseEnter: h2, onPointerMove: O, onMouseMove: O, onPointerLeave: G2, onMouseLeave: G2 }, theirProps: a3, slot: J2, defaultTag: ko, name: "Combobox.Option" });
-}
-let Uo = W$1(ho), Ho = W$1(Vo), Go = W$1(Mo), jo = K, zo = W$1(Bo), Ko = W$1(No), Nt = Object.assign(Uo, { Input: Go, Button: Ho, Label: jo, Options: zo, Option: Ko });
-const option = "_option_5wfzg_2";
-const m = "_m_5wfzg_25";
-const l = "_l_5wfzg_30";
-const cls = {
-  option,
-  "option-active": "_option-active_5wfzg_9",
-  "option-inner": "_option-inner_5wfzg_12",
-  "selected-icon": "_selected-icon_5wfzg_21",
-  m,
-  l
-};
-function SelectSearchOption({
-  record,
-  size: size2,
-  children,
-  className
-}) {
-  return /* @__PURE__ */ jsx(
-    Ko,
-    {
-      value: record,
-      className: ({ focus }) => classNames(cls.option, className, size2 && cls[size2], {
-        [cls["option-active"]]: focus
-      }),
-      children: ({ selected }) => /* @__PURE__ */ jsxs("div", { className: classNames(cls["option-inner"]), children: [
-        /* @__PURE__ */ jsx("div", { children }),
-        selected && /* @__PURE__ */ jsx(
-          Icon,
-          {
-            iconName: size2 === ESelectSearchSize.M ? "Done16px" : "Done24px",
-            className: cls["selected-icon"]
-          }
-        )
-      ] })
-    }
-  );
-}
-export {
-  Go as G,
-  Ho as H,
-  Nt as N,
-  SelectSearchOption as S,
-  zo as z
-};