@selvajs/selva 4.7.0-beta.2 → 4.7.0-beta.3

package/build/server/chunks/chunks/index5.js-DtflJpxD.js

@@ -1,4246 +0,0 @@
-import { ai as bind_props, aa as ensure_array_like, R as derived, a7 as spread_props, ab as attributes, an as props_id, ag as escape_html } from './index3.js-1TgPl-ig.js';
-import { c as cn } from './utils3.js-DyHrfoD2.js';
-import { r as styleToString, f as createBitsAttrs, a as boxWith, s as simpleBox, u as boolToTrueOrUndef, p as mergeProps, q as createId, k as attachRef, m as boolToEmptyStrOrUndef, l as getDataOpenClosed, n as boolToStr, o as getDataTransitionAttrs, b as boxFrom, v as boolToStrTrueOrUndef, w as cssToStyleObj } from './create-id.js-DLd1XgVR.js';
-import { n as noop, w as watch, C as Context, f as ARROW_UP, A as ARROW_DOWN, d as ENTER, S as SPACE, T as TAB, P as PAGE_UP, H as HOME, g as PAGE_DOWN, h as END, m as isNotNull, o as defaultWindow, b as isIOS } from './noop.js-DGDhGEa2.js';
-import { C as Check } from './check.js-CUHxj7Ck.js';
-import { C as Chevron_up } from './chevron-up.js-DcJJc7lc.js';
-import { C as Chevron_down } from './chevron-down.js-Cp3m51Ig.js';
-import { b as afterTick, c as DOMContext, P as PresenceManager, a as Portal, d as DOMTypeahead, n as next, p as prev, f as forward, e as backward, g as boxAutoReset, h as getNextMatch, i as afterSleep, u as useId, j as getWindow$1, S as Scroll_lock, F as Focus_scope, E as Escape_layer, D as Dismissible_layer, T as Text_selection_layer } from './scroll-lock.js-DlnpOFhy.js';
-import 'clsx';
-import { c as createSubscriber } from './index-server.js-DMc-UvjC.js';
-import { o as on } from './events.js-C_8t8jPk.js';
-
-const srOnlyStyles = {
-  position: "absolute",
-  width: "1px",
-  height: "1px",
-  padding: "0",
-  margin: "-1px",
-  overflow: "hidden",
-  clip: "rect(0, 0, 0, 0)",
-  whiteSpace: "nowrap",
-  borderWidth: "0",
-  transform: "translateX(-100%)"
-};
-styleToString(srOnlyStyles);
-function isFunction(value) {
-  return typeof value === "function";
-}
-function get$1(value) {
-  if (isFunction(value)) {
-    return value();
-  }
-  return value;
-}
-class ElementSize {
-  // no need to use `$state` here since we are using createSubscriber
-  #size = { width: 0, height: 0 };
-  #observed = false;
-  #options;
-  #node;
-  #window;
-  // we use a derived here to extract the width so that if the width doesn't change we don't get a state update
-  // which we would get if we would just use a getter since the version of the subscriber will be changing
-  #width = derived(() => {
-    this.#subscribe()?.();
-    return this.getSize().width;
-  });
-  // we use a derived here to extract the height so that if the height doesn't change we don't get a state update
-  // which we would get if we would just use a getter since the version of the subscriber will be changing
-  #height = derived(() => {
-    this.#subscribe()?.();
-    return this.getSize().height;
-  });
-  // we need to use a derived here because the class will be created before the node is bound to the ref
-  #subscribe = derived(() => {
-    const node$ = get$1(this.#node);
-    if (!node$) return;
-    return createSubscriber();
-  });
-  constructor(node, options = { box: "border-box" }) {
-    this.#window = options.window ?? defaultWindow;
-    this.#options = options;
-    this.#node = node;
-    this.#size = { width: 0, height: 0 };
-  }
-  calculateSize() {
-    const element = get$1(this.#node);
-    if (!element || !this.#window) {
-      return;
-    }
-    const offsetWidth = element.offsetWidth;
-    const offsetHeight = element.offsetHeight;
-    if (this.#options.box === "border-box") {
-      return { width: offsetWidth, height: offsetHeight };
-    }
-    const style = this.#window.getComputedStyle(element);
-    const paddingWidth = parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
-    const paddingHeight = parseFloat(style.paddingTop) + parseFloat(style.paddingBottom);
-    const borderWidth = parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
-    const borderHeight = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
-    const contentWidth = offsetWidth - paddingWidth - borderWidth;
-    const contentHeight = offsetHeight - paddingHeight - borderHeight;
-    return { width: contentWidth, height: contentHeight };
-  }
-  getSize() {
-    return this.#observed ? this.#size : this.calculateSize() ?? this.#size;
-  }
-  get current() {
-    this.#subscribe()?.();
-    return this.getSize();
-  }
-  get width() {
-    return this.#width();
-  }
-  get height() {
-    return this.#height();
-  }
-}
-class Previous {
-  #previousCallback = () => void 0;
-  #previous = derived(() => this.#previousCallback());
-  constructor(getter, initialValue) {
-    let actualPrevious = void 0;
-    if (initialValue !== void 0) actualPrevious = initialValue;
-    this.#previousCallback = () => {
-      try {
-        return actualPrevious;
-      } finally {
-        actualPrevious = getter();
-      }
-    };
-  }
-  get current() {
-    return this.#previous();
-  }
-}
-function Hidden_input($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let { value = void 0, $$slots, $$events, ...restProps } = $$props;
-    const mergedProps = derived(() => mergeProps(restProps, {
-      "aria-hidden": "true",
-      tabindex: -1,
-      style: { ...srOnlyStyles, position: "absolute", top: "0", left: "0" }
-    }));
-    if (mergedProps().type === "checkbox") {
-      $$renderer2.push("<!--[0-->");
-      $$renderer2.push(`<input${attributes({ ...mergedProps(), value }, void 0, void 0, void 0, 4)}/>`);
-    } else {
-      $$renderer2.push("<!--[-1-->");
-      $$renderer2.push(`<input${attributes({ value, ...mergedProps() }, void 0, void 0, void 0, 4)}/>`);
-    }
-    $$renderer2.push(`<!--]-->`);
-    bind_props($$props, { value });
-  });
-}
-const sides = ["top", "right", "bottom", "left"];
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const createCoords = (v) => ({
-  x: v,
-  y: v
-});
-const oppositeSideMap = {
-  left: "right",
-  right: "left",
-  bottom: "top",
-  top: "bottom"
-};
-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) {
-  const firstChar = placement[0];
-  return firstChar === "t" || firstChar === "b" ? "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.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
-}
-const lrPlacement = ["left", "right"];
-const rlPlacement = ["right", "left"];
-const tbPlacement = ["top", "bottom"];
-const btPlacement = ["bottom", "top"];
-function getSideList(side, isStart, rtl) {
-  switch (side) {
-    case "top":
-    case "bottom":
-      if (rtl) return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
-    case "left":
-    case "right":
-      return isStart ? tbPlacement : btPlacement;
-    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) {
-  const side = getSide(placement);
-  return oppositeSideMap[side] + placement.slice(side.length);
-}
-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,
-    y,
-    width,
-    height
-  } = rect;
-  return {
-    width,
-    height,
-    top: y,
-    left: x,
-    right: x + width,
-    bottom: y + height,
-    x,
-    y
-  };
-}
-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;
-}
-async function detectOverflow(state, options) {
-  var _await$platform$isEle;
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    x,
-    y,
-    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,
-    y,
-    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 MAX_RESET_COUNT = 50;
-const computePosition$1 = async (reference, floating, config) => {
-  const {
-    placement = "bottom",
-    strategy = "absolute",
-    middleware = [],
-    platform: platform2
-  } = config;
-  const platformWithDetectOverflow = platform2.detectOverflow ? platform2 : {
-    ...platform2,
-    detectOverflow
-  };
-  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
-  let rects = await platform2.getElementRects({
-    reference,
-    floating,
-    strategy
-  });
-  let {
-    x,
-    y
-  } = computeCoordsFromPlacement(rects, placement, rtl);
-  let statefulPlacement = placement;
-  let resetCount = 0;
-  const middlewareData = {};
-  for (let i = 0; i < middleware.length; i++) {
-    const currentMiddleware = middleware[i];
-    if (!currentMiddleware) {
-      continue;
-    }
-    const {
-      name,
-      fn
-    } = currentMiddleware;
-    const {
-      x: nextX,
-      y: nextY,
-      data,
-      reset
-    } = await fn({
-      x,
-      y,
-      initialPlacement: placement,
-      placement: statefulPlacement,
-      strategy,
-      middlewareData,
-      rects,
-      platform: platformWithDetectOverflow,
-      elements: {
-        reference,
-        floating
-      }
-    });
-    x = nextX != null ? nextX : x;
-    y = nextY != null ? nextY : y;
-    middlewareData[name] = {
-      ...middlewareData[name],
-      ...data
-    };
-    if (reset && resetCount < MAX_RESET_COUNT) {
-      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,
-          y
-        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
-      }
-      i = -1;
-    }
-  }
-  return {
-    x,
-    y,
-    placement: statefulPlacement,
-    strategy,
-    middlewareData
-  };
-};
-const arrow$1 = (options) => ({
-  name: "arrow",
-  options,
-  async fn(state) {
-    const {
-      x,
-      y,
-      placement,
-      rects,
-      platform: platform2,
-      elements,
-      middlewareData
-    } = state;
-    const {
-      element,
-      padding = 0
-    } = evaluate(options, state) || {};
-    if (element == null) {
-      return {};
-    }
-    const paddingObject = getPaddingObject(padding);
-    const coords = {
-      x,
-      y
-    };
-    const axis = getAlignmentAxis(placement);
-    const length = getAxisLength(axis);
-    const arrowDimensions = await platform2.getDimensions(element);
-    const isYAxis = axis === "y";
-    const minProp = isYAxis ? "top" : "left";
-    const maxProp = isYAxis ? "bottom" : "right";
-    const clientProp = isYAxis ? "clientHeight" : "clientWidth";
-    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
-    const startDiff = coords[axis] - rects.reference[axis];
-    const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
-    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
-    if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
-      clientSize = elements.floating[clientProp] || rects.floating[length];
-    }
-    const centerToReference = endDiff / 2 - startDiff / 2;
-    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
-    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
-    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
-    const min$1 = minPadding;
-    const max2 = clientSize - arrowDimensions[length] - maxPadding;
-    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-    const offset2 = clamp(min$1, center, max2);
-    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
-    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
-    return {
-      [axis]: coords[axis] + alignmentOffset,
-      data: {
-        [axis]: offset2,
-        centerOffset: center - offset2 - alignmentOffset,
-        ...shouldAddOffset && {
-          alignmentOffset
-        }
-      },
-      reset: shouldAddOffset
-    };
-  }
-});
-const flip$1 = 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 platform2.detectOverflow(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 sides2 = getAlignmentSides(placement, rects, rtl);
-        overflows.push(overflow[sides2[0]], overflow[sides2[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) {
-          const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
-          if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
-          // overflows the main axis.
-          overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
-            return {
-              data: {
-                index: nextIndex,
-                overflows: overflowsData
-              },
-              reset: {
-                placement: nextPlacement
-              }
-            };
-          }
-        }
-        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.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((d) => {
-                if (hasFallbackAxisSideDirection) {
-                  const currentSideAxis = getSideAxis(d.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((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[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 {};
-    }
-  };
-};
-function getSideOffsets(overflow, rect) {
-  return {
-    top: overflow.top - rect.height,
-    right: overflow.right - rect.width,
-    bottom: overflow.bottom - rect.height,
-    left: overflow.left - rect.width
-  };
-}
-function isAnySideFullyClipped(overflow) {
-  return sides.some((side) => overflow[side] >= 0);
-}
-const hide$1 = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    name: "hide",
-    options,
-    async fn(state) {
-      const {
-        rects,
-        platform: platform2
-      } = state;
-      const {
-        strategy = "referenceHidden",
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-      switch (strategy) {
-        case "referenceHidden": {
-          const overflow = await platform2.detectOverflow(state, {
-            ...detectOverflowOptions,
-            elementContext: "reference"
-          });
-          const offsets = getSideOffsets(overflow, rects.reference);
-          return {
-            data: {
-              referenceHiddenOffsets: offsets,
-              referenceHidden: isAnySideFullyClipped(offsets)
-            }
-          };
-        }
-        case "escaped": {
-          const overflow = await platform2.detectOverflow(state, {
-            ...detectOverflowOptions,
-            altBoundary: true
-          });
-          const offsets = getSideOffsets(overflow, rects.floating);
-          return {
-            data: {
-              escapedOffsets: offsets,
-              escaped: isAnySideFullyClipped(offsets)
-            }
-          };
-        }
-        default: {
-          return {};
-        }
-      }
-    }
-  };
-};
-const originSides = /* @__PURE__ */ new Set(["left", "top"]);
-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 = originSides.has(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: rawValue.mainAxis || 0,
-    crossAxis: rawValue.crossAxis || 0,
-    alignmentAxis: rawValue.alignmentAxis
-  };
-  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$1 = function(options) {
-  if (options === void 0) {
-    options = 0;
-  }
-  return {
-    name: "offset",
-    options,
-    async fn(state) {
-      var _middlewareData$offse, _middlewareData$arrow;
-      const {
-        x,
-        y,
-        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: x + diffCoords.x,
-        y: y + diffCoords.y,
-        data: {
-          ...diffCoords,
-          placement
-        }
-      };
-    }
-  };
-};
-const shift$1 = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    name: "shift",
-    options,
-    async fn(state) {
-      const {
-        x,
-        y,
-        placement,
-        platform: platform2
-      } = state;
-      const {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = false,
-        limiter = {
-          fn: (_ref) => {
-            let {
-              x: x2,
-              y: y2
-            } = _ref;
-            return {
-              x: x2,
-              y: y2
-            };
-          }
-        },
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-      const coords = {
-        x,
-        y
-      };
-      const overflow = await platform2.detectOverflow(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 - x,
-          y: limitedCoords.y - y,
-          enabled: {
-            [mainAxis]: checkMainAxis,
-            [crossAxis]: checkCrossAxis
-          }
-        }
-      };
-    }
-  };
-};
-const limitShift$1 = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    options,
-    fn(state) {
-      const {
-        x,
-        y,
-        placement,
-        rects,
-        middlewareData
-      } = state;
-      const {
-        offset: offset2 = 0,
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = true
-      } = evaluate(options, state);
-      const coords = {
-        x,
-        y
-      };
-      const crossAxis = getSideAxis(placement);
-      const mainAxis = getOppositeAxis(crossAxis);
-      let mainAxisCoord = coords[mainAxis];
-      let crossAxisCoord = coords[crossAxis];
-      const rawOffset = evaluate(offset2, state);
-      const computedOffset = typeof rawOffset === "number" ? {
-        mainAxis: rawOffset,
-        crossAxis: 0
-      } : {
-        mainAxis: 0,
-        crossAxis: 0,
-        ...rawOffset
-      };
-      if (checkMainAxis) {
-        const len = mainAxis === "y" ? "height" : "width";
-        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
-        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
-        if (mainAxisCoord < limitMin) {
-          mainAxisCoord = limitMin;
-        } else if (mainAxisCoord > limitMax) {
-          mainAxisCoord = limitMax;
-        }
-      }
-      if (checkCrossAxis) {
-        var _middlewareData$offse, _middlewareData$offse2;
-        const len = mainAxis === "y" ? "width" : "height";
-        const isOriginSide = originSides.has(getSide(placement));
-        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
-        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
-        if (crossAxisCoord < limitMin) {
-          crossAxisCoord = limitMin;
-        } else if (crossAxisCoord > limitMax) {
-          crossAxisCoord = limitMax;
-        }
-      }
-      return {
-        [mainAxis]: mainAxisCoord,
-        [crossAxis]: crossAxisCoord
-      };
-    }
-  };
-};
-const size$1 = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    name: "size",
-    options,
-    async fn(state) {
-      var _state$middlewareData, _state$middlewareData2;
-      const {
-        placement,
-        rects,
-        platform: platform2,
-        elements
-      } = state;
-      const {
-        apply = () => {
-        },
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-      const overflow = await platform2.detectOverflow(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 ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {
-        availableWidth = maximumClippingWidth;
-      }
-      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {
-        availableHeight = 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 hasWindow() {
-  return typeof window !== "undefined";
-}
-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) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Node || value instanceof getWindow(value).Node;
-}
-function isElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Element || value instanceof getWindow(value).Element;
-}
-function isHTMLElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
-}
-function isShadowRoot(value) {
-  if (!hasWindow() || 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) && display !== "inline" && display !== "contents";
-}
-function isTableElement(element) {
-  return /^(table|td|th)$/.test(getNodeName(element));
-}
-function isTopLayer(element) {
-  try {
-    if (element.matches(":popover-open")) {
-      return true;
-    }
-  } catch (_e) {
-  }
-  try {
-    return element.matches(":modal");
-  } catch (_e) {
-    return false;
-  }
-}
-const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
-const containRe = /paint|layout|strict|content/;
-const isNotNone = (value) => !!value && value !== "none";
-let isWebKitValue;
-function isContainingBlock(elementOrCss) {
-  const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
-  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
-}
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    if (isContainingBlock(currentNode)) {
-      return currentNode;
-    } else if (isTopLayer(currentNode)) {
-      return null;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  return null;
-}
-function isWebKit() {
-  if (isWebKitValue == null) {
-    isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
-  }
-  return isWebKitValue;
-}
-function isLastTraversableNode(node) {
-  return /^(html|body|#document)$/.test(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 = [];
-  }
-  const scrollableAncestor = getNearestOverflowAncestor(node);
-  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
-  const win = getWindow(scrollableAncestor);
-  if (isBody) {
-    getFrameElement(win);
-    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], []);
-  } else {
-    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, []));
-  }
-}
-function getFrameElement(win) {
-  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
-}
-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 x = ($ ? round(rect.width) : rect.width) / width;
-  let y = ($ ? round(rect.height) : rect.height) / height;
-  if (!x || !Number.isFinite(x)) {
-    x = 1;
-  }
-  if (!y || !Number.isFinite(y)) {
-    y = 1;
-  }
-  return {
-    x,
-    y
-  };
-}
-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 x = (clientRect.left + visualOffsets.x) / scale.x;
-  let y = (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 = getFrameElement(currentWin);
-    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;
-      x *= iframeScale.x;
-      y *= iframeScale.y;
-      width *= iframeScale.x;
-      height *= iframeScale.y;
-      x += left;
-      y += top;
-      currentWin = getWindow(currentIFrame);
-      currentIFrame = getFrameElement(currentWin);
-    }
-  }
-  return rectToClientRect({
-    width,
-    height,
-    x,
-    y
-  });
-}
-function getWindowScrollBarX(element, rect) {
-  const leftScroll = getNodeScroll(element).scrollLeft;
-  if (!rect) {
-    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
-  }
-  return rect.left + leftScroll;
-}
-function getHTMLOffset(documentElement, scroll) {
-  const htmlRect = documentElement.getBoundingClientRect();
-  const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
-  const y = htmlRect.top + scroll.scrollTop;
-  return {
-    x,
-    y
-  };
-}
-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 (isOffsetParentAnElement) {
-      const offsetRect = getBoundingClientRect(offsetParent);
-      scale = getScale(offsetParent);
-      offsets.x = offsetRect.x + offsetParent.clientLeft;
-      offsets.y = offsetRect.y + offsetParent.clientTop;
-    }
-  }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
-  return {
-    width: rect.width * scale.x,
-    height: rect.height * scale.y,
-    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
-    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
-  };
-}
-function getClientRects(element) {
-  return Array.from(element.getClientRects());
-}
-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 x = -scroll.scrollLeft + getWindowScrollBarX(element);
-  const y = -scroll.scrollTop;
-  if (getComputedStyle$1(body).direction === "rtl") {
-    x += max(html.clientWidth, body.clientWidth) - width;
-  }
-  return {
-    width,
-    height,
-    x,
-    y
-  };
-}
-const SCROLLBAR_MAX = 25;
-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 x = 0;
-  let y = 0;
-  if (visualViewport) {
-    width = visualViewport.width;
-    height = visualViewport.height;
-    const visualViewportBased = isWebKit();
-    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
-      x = visualViewport.offsetLeft;
-      y = visualViewport.offsetTop;
-    }
-  }
-  const windowScrollbarX = getWindowScrollBarX(html);
-  if (windowScrollbarX <= 0) {
-    const doc = html.ownerDocument;
-    const body = doc.body;
-    const bodyStyles = getComputedStyle(body);
-    const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
-    const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
-    if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
-      width -= clippingStableScrollbarWidth;
-    }
-  } else if (windowScrollbarX <= SCROLLBAR_MAX) {
-    width += windowScrollbarX;
-  }
-  return {
-    width,
-    height,
-    x,
-    y
-  };
-}
-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 x = left * scale.x;
-  const y = top * scale.y;
-  return {
-    width,
-    height,
-    x,
-    y
-  };
-}
-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 = {
-      x: clippingAncestor.x - visualOffsets.x,
-      y: clippingAncestor.y - visualOffsets.y,
-      width: clippingAncestor.width,
-      height: clippingAncestor.height
-    };
-  }
-  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, []).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 && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || 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 firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
-  let top = firstRect.top;
-  let right = firstRect.right;
-  let bottom = firstRect.bottom;
-  let left = firstRect.left;
-  for (let i = 1; i < clippingAncestors.length; i++) {
-    const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
-    top = max(rect.top, top);
-    right = min(rect.right, right);
-    bottom = min(rect.bottom, bottom);
-    left = max(rect.left, left);
-  }
-  return {
-    width: right - left,
-    height: bottom - top,
-    x: left,
-    y: 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);
-  function setLeftRTLScrollbarOffset() {
-    offsets.x = getWindowScrollBarX(documentElement);
-  }
-  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) {
-      setLeftRTLScrollbarOffset();
-    }
-  }
-  if (isFixed && !isOffsetParentAnElement && documentElement) {
-    setLeftRTLScrollbarOffset();
-  }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
-  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
-  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
-  return {
-    x,
-    y,
-    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);
-  }
-  let rawOffsetParent = element.offsetParent;
-  if (getDocumentElement(element) === rawOffsetParent) {
-    rawOffsetParent = rawOffsetParent.ownerDocument.body;
-  }
-  return rawOffsetParent;
-}
-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
-};
-const offset = offset$1;
-const shift = shift$1;
-const flip = flip$1;
-const size = size$1;
-const hide = hide$1;
-const arrow = arrow$1;
-const limitShift = limitShift$1;
-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
-  });
-};
-function get(valueOrGetValue) {
-  return typeof valueOrGetValue === "function" ? valueOrGetValue() : valueOrGetValue;
-}
-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 getFloatingContentCSSVars(name) {
-  return {
-    [`--bits-${name}-content-transform-origin`]: `var(--bits-floating-transform-origin)`,
-    [`--bits-${name}-content-available-width`]: `var(--bits-floating-available-width)`,
-    [`--bits-${name}-content-available-height`]: `var(--bits-floating-available-height)`,
-    [`--bits-${name}-anchor-width`]: `var(--bits-floating-anchor-width)`,
-    [`--bits-${name}-anchor-height`]: `var(--bits-floating-anchor-height)`
-  };
-}
-function useFloating(options) {
-  const openOption = derived(() => get(options.open) ?? true);
-  const middlewareOption = derived(() => get(options.middleware));
-  const transformOption = derived(() => get(options.transform) ?? true);
-  const placementOption = derived(() => get(options.placement) ?? "bottom");
-  const strategyOption = derived(() => get(options.strategy) ?? "absolute");
-  const sideOffsetOption = derived(() => get(options.sideOffset) ?? 0);
-  const alignOffsetOption = derived(() => get(options.alignOffset) ?? 0);
-  const reference = options.reference;
-  let x = 0;
-  let y = 0;
-  const floating = simpleBox(null);
-  let strategy = strategyOption();
-  let placement = placementOption();
-  let middlewareData = {};
-  let isPositioned = false;
-  let updateRequestId = 0;
-  const floatingStyles = derived(() => {
-    const xVal = floating.current ? roundByDPR(floating.current, x) : x;
-    const yVal = floating.current ? roundByDPR(floating.current, y) : y;
-    if (transformOption()) {
-      return {
-        position: strategy,
-        left: "0",
-        top: "0",
-        transform: `translate(${xVal}px, ${yVal}px)`,
-        ...floating.current && getDPR(floating.current) >= 1.5 && { willChange: "transform" }
-      };
-    }
-    return { position: strategy, left: `${xVal}px`, top: `${yVal}px` };
-  });
-  function update() {
-    if (reference.current === null || floating.current === null) return;
-    const referenceNode = reference.current;
-    const floatingNode = floating.current;
-    const requestId = ++updateRequestId;
-    computePosition(referenceNode, floatingNode, {
-      middleware: middlewareOption(),
-      placement: placementOption(),
-      strategy: strategyOption()
-    }).then((position) => {
-      if (requestId !== updateRequestId) return;
-      if (reference.current !== referenceNode || floating.current !== floatingNode) return;
-      const referenceHidden = isReferenceHidden(referenceNode);
-      if (referenceHidden) {
-        middlewareData = {
-          ...middlewareData,
-          hide: {
-            // oxlint-disable-next-line no-explicit-any
-            ...middlewareData.hide,
-            referenceHidden: true
-          }
-        };
-        return;
-      }
-      if (!openOption() && x !== 0 && y !== 0) {
-        const maxExpectedOffset = Math.max(Math.abs(sideOffsetOption()), Math.abs(alignOffsetOption()), 15);
-        if (position.x <= maxExpectedOffset && position.y <= maxExpectedOffset) return;
-      }
-      x = position.x;
-      y = position.y;
-      strategy = position.strategy;
-      placement = position.placement;
-      middlewareData = position.middlewareData;
-      isPositioned = true;
-    });
-  }
-  return {
-    floating,
-    reference,
-    get strategy() {
-      return strategy;
-    },
-    get placement() {
-      return placement;
-    },
-    get middlewareData() {
-      return middlewareData;
-    },
-    get isPositioned() {
-      return isPositioned;
-    },
-    get floatingStyles() {
-      return floatingStyles();
-    },
-    get update() {
-      return update;
-    }
-  };
-}
-function isReferenceHidden(node) {
-  if (!(node instanceof Element)) return false;
-  if (!node.isConnected) return true;
-  if (node instanceof HTMLElement && node.hidden) return true;
-  return node.getClientRects().length === 0;
-}
-const OPPOSITE_SIDE = { top: "bottom", right: "left", bottom: "top", left: "right" };
-const FloatingRootContext = new Context("Floating.Root");
-const FloatingContentContext = new Context("Floating.Content");
-const FloatingTooltipRootContext = new Context("Floating.Root");
-class FloatingRootState {
-  static create(tooltip = false) {
-    return tooltip ? FloatingTooltipRootContext.set(new FloatingRootState()) : FloatingRootContext.set(new FloatingRootState());
-  }
-  anchorNode = simpleBox(null);
-  customAnchorNode = simpleBox(null);
-  triggerNode = simpleBox(null);
-  constructor() {
-  }
-}
-class FloatingContentState {
-  static create(opts, tooltip = false) {
-    return tooltip ? FloatingContentContext.set(new FloatingContentState(opts, FloatingTooltipRootContext.get())) : FloatingContentContext.set(new FloatingContentState(opts, FloatingRootContext.get()));
-  }
-  opts;
-  root;
-  // nodes
-  contentRef = simpleBox(null);
-  wrapperRef = simpleBox(null);
-  arrowRef = simpleBox(null);
-  contentAttachment = attachRef(this.contentRef);
-  wrapperAttachment = attachRef(this.wrapperRef);
-  arrowAttachment = attachRef(this.arrowRef);
-  // ids
-  arrowId = simpleBox(useId());
-  #transformedStyle = derived(() => {
-    if (typeof this.opts.style === "string") return cssToStyleObj(this.opts.style);
-    if (!this.opts.style) return {};
-  });
-  #updatePositionStrategy = void 0;
-  #arrowSize = new ElementSize(() => this.arrowRef.current ?? void 0);
-  #arrowWidth = derived(() => this.#arrowSize?.width ?? 0);
-  #arrowHeight = derived(() => this.#arrowSize?.height ?? 0);
-  #desiredPlacement = derived(() => this.opts.side?.current + (this.opts.align.current !== "center" ? `-${this.opts.align.current}` : ""));
-  #boundary = derived(() => Array.isArray(this.opts.collisionBoundary.current) ? this.opts.collisionBoundary.current : [this.opts.collisionBoundary.current]);
-  #hasExplicitBoundaries = derived(() => this.#boundary().length > 0);
-  get hasExplicitBoundaries() {
-    return this.#hasExplicitBoundaries();
-  }
-  set hasExplicitBoundaries($$value) {
-    return this.#hasExplicitBoundaries($$value);
-  }
-  #detectOverflowOptions = derived(() => ({
-    padding: this.opts.collisionPadding.current,
-    boundary: this.#boundary().filter(isNotNull),
-    altBoundary: this.hasExplicitBoundaries
-  }));
-  get detectOverflowOptions() {
-    return this.#detectOverflowOptions();
-  }
-  set detectOverflowOptions($$value) {
-    return this.#detectOverflowOptions($$value);
-  }
-  #availableWidth = void 0;
-  #availableHeight = void 0;
-  #anchorWidth = void 0;
-  #anchorHeight = void 0;
-  #middleware = derived(() => [
-    offset({
-      mainAxis: this.opts.sideOffset.current + this.#arrowHeight(),
-      alignmentAxis: this.opts.alignOffset.current
-    }),
-    this.opts.avoidCollisions.current && shift({
-      mainAxis: true,
-      crossAxis: false,
-      limiter: this.opts.sticky.current === "partial" ? limitShift() : void 0,
-      ...this.detectOverflowOptions
-    }),
-    this.opts.avoidCollisions.current && flip({ ...this.detectOverflowOptions }),
-    size({
-      ...this.detectOverflowOptions,
-      apply: ({ rects, availableWidth, availableHeight }) => {
-        const { width: anchorWidth, height: anchorHeight } = rects.reference;
-        this.#availableWidth = availableWidth;
-        this.#availableHeight = availableHeight;
-        this.#anchorWidth = anchorWidth;
-        this.#anchorHeight = anchorHeight;
-      }
-    }),
-    this.arrowRef.current && arrow({
-      element: this.arrowRef.current,
-      padding: this.opts.arrowPadding.current
-    }),
-    transformOrigin({
-      arrowWidth: this.#arrowWidth(),
-      arrowHeight: this.#arrowHeight()
-    }),
-    this.opts.hideWhenDetached.current && hide({ strategy: "referenceHidden", ...this.detectOverflowOptions })
-  ].filter(Boolean));
-  get middleware() {
-    return this.#middleware();
-  }
-  set middleware($$value) {
-    return this.#middleware($$value);
-  }
-  floating;
-  #placedSide = derived(() => getSideFromPlacement(this.floating.placement));
-  get placedSide() {
-    return this.#placedSide();
-  }
-  set placedSide($$value) {
-    return this.#placedSide($$value);
-  }
-  #placedAlign = derived(() => getAlignFromPlacement(this.floating.placement));
-  get placedAlign() {
-    return this.#placedAlign();
-  }
-  set placedAlign($$value) {
-    return this.#placedAlign($$value);
-  }
-  #arrowX = derived(() => this.floating.middlewareData.arrow?.x ?? 0);
-  get arrowX() {
-    return this.#arrowX();
-  }
-  set arrowX($$value) {
-    return this.#arrowX($$value);
-  }
-  #arrowY = derived(() => this.floating.middlewareData.arrow?.y ?? 0);
-  get arrowY() {
-    return this.#arrowY();
-  }
-  set arrowY($$value) {
-    return this.#arrowY($$value);
-  }
-  #cannotCenterArrow = derived(() => this.floating.middlewareData.arrow?.centerOffset !== 0);
-  get cannotCenterArrow() {
-    return this.#cannotCenterArrow();
-  }
-  set cannotCenterArrow($$value) {
-    return this.#cannotCenterArrow($$value);
-  }
-  contentZIndex;
-  #arrowBaseSide = derived(() => OPPOSITE_SIDE[this.placedSide]);
-  get arrowBaseSide() {
-    return this.#arrowBaseSide();
-  }
-  set arrowBaseSide($$value) {
-    return this.#arrowBaseSide($$value);
-  }
-  #wrapperProps = derived(() => ({
-    id: this.opts.wrapperId.current,
-    "data-bits-floating-content-wrapper": "",
-    style: {
-      ...this.floating.floatingStyles,
-      transform: this.floating.isPositioned ? this.floating.floatingStyles.transform : "translate(0, -200%)",
-      minWidth: "max-content",
-      zIndex: this.contentZIndex,
-      "--bits-floating-transform-origin": `${this.floating.middlewareData.transformOrigin?.x} ${this.floating.middlewareData.transformOrigin?.y}`,
-      "--bits-floating-available-width": `${this.#availableWidth}px`,
-      "--bits-floating-available-height": `${this.#availableHeight}px`,
-      "--bits-floating-anchor-width": `${this.#anchorWidth}px`,
-      "--bits-floating-anchor-height": `${this.#anchorHeight}px`,
-      ...this.floating.middlewareData.hide?.referenceHidden && { visibility: "hidden", "pointer-events": "none" },
-      ...this.#transformedStyle()
-    },
-    dir: this.opts.dir.current,
-    ...this.wrapperAttachment
-  }));
-  get wrapperProps() {
-    return this.#wrapperProps();
-  }
-  set wrapperProps($$value) {
-    return this.#wrapperProps($$value);
-  }
-  #props = derived(() => ({
-    "data-side": this.placedSide,
-    "data-align": this.placedAlign,
-    style: styleToString({ ...this.#transformedStyle() }),
-    ...this.contentAttachment
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-  #arrowStyle = derived(() => ({
-    position: "absolute",
-    left: this.arrowX ? `${this.arrowX}px` : void 0,
-    top: this.arrowY ? `${this.arrowY}px` : void 0,
-    [this.arrowBaseSide]: 0,
-    "transform-origin": { top: "", right: "0 0", bottom: "center 0", left: "100% 0" }[this.placedSide],
-    transform: {
-      top: "translateY(100%)",
-      right: "translateY(50%) rotate(90deg) translateX(-50%)",
-      bottom: "rotate(180deg)",
-      left: "translateY(50%) rotate(-90deg) translateX(50%)"
-    }[this.placedSide],
-    visibility: this.cannotCenterArrow ? "hidden" : void 0
-  }));
-  get arrowStyle() {
-    return this.#arrowStyle();
-  }
-  set arrowStyle($$value) {
-    return this.#arrowStyle($$value);
-  }
-  constructor(opts, root) {
-    this.opts = opts;
-    this.root = root;
-    this.#updatePositionStrategy = opts.updatePositionStrategy;
-    if (opts.customAnchor) {
-      this.root.customAnchorNode.current = opts.customAnchor.current;
-    }
-    watch(() => opts.customAnchor.current, (customAnchor) => {
-      this.root.customAnchorNode.current = customAnchor;
-    });
-    this.floating = useFloating({
-      strategy: () => this.opts.strategy.current,
-      placement: () => this.#desiredPlacement(),
-      middleware: () => this.middleware,
-      reference: this.root.anchorNode,
-      open: () => this.opts.enabled.current,
-      sideOffset: () => this.opts.sideOffset.current,
-      alignOffset: () => this.opts.alignOffset.current
-    });
-    watch(() => this.contentRef.current, (contentNode) => {
-      if (!contentNode || !this.opts.enabled.current) return;
-      const win = getWindow$1(contentNode);
-      const rafId = win.requestAnimationFrame(() => {
-        if (this.contentRef.current !== contentNode || !this.opts.enabled.current) return;
-        const zIndex = win.getComputedStyle(contentNode).zIndex;
-        if (zIndex !== this.contentZIndex) {
-          this.contentZIndex = zIndex;
-        }
-      });
-      return () => {
-        win.cancelAnimationFrame(rafId);
-      };
-    });
-  }
-}
-class FloatingAnchorState {
-  static create(opts, tooltip = false) {
-    return tooltip ? new FloatingAnchorState(opts, FloatingTooltipRootContext.get()) : new FloatingAnchorState(opts, FloatingRootContext.get());
-  }
-  opts;
-  root;
-  constructor(opts, root) {
-    this.opts = opts;
-    this.root = root;
-    if (opts.virtualEl && opts.virtualEl.current) {
-      root.triggerNode = boxFrom(opts.virtualEl.current);
-    } else {
-      root.triggerNode = opts.ref;
-    }
-  }
-}
-function transformOrigin(options) {
-  return {
-    name: "transformOrigin",
-    options,
-    fn(data) {
-      const { placement, rects, middlewareData } = data;
-      const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;
-      const isArrowHidden = cannotCenterArrow;
-      const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;
-      const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;
-      const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);
-      const noArrowAlign = { start: "0%", center: "50%", end: "100%" }[placedAlign];
-      const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2;
-      const arrowYCenter = (middlewareData.arrow?.y ?? 0) + arrowHeight / 2;
-      let x = "";
-      let y = "";
-      if (placedSide === "bottom") {
-        x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
-        y = `${-arrowHeight}px`;
-      } else if (placedSide === "top") {
-        x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
-        y = `${rects.floating.height + arrowHeight}px`;
-      } else if (placedSide === "right") {
-        x = `${-arrowHeight}px`;
-        y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
-      } else if (placedSide === "left") {
-        x = `${rects.floating.width + arrowHeight}px`;
-        y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
-      }
-      return { data: { x, y } };
-    }
-  };
-}
-function getSideAndAlignFromPlacement(placement) {
-  const [side, align = "center"] = placement.split("-");
-  return [side, align];
-}
-function getSideFromPlacement(placement) {
-  return getSideAndAlignFromPlacement(placement)[0];
-}
-function getAlignFromPlacement(placement) {
-  return getSideAndAlignFromPlacement(placement)[1];
-}
-function Floating_layer($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let { children, tooltip = false } = $$props;
-    FloatingRootState.create(tooltip);
-    children?.($$renderer2);
-    $$renderer2.push(`<!---->`);
-  });
-}
-class DataTypeahead {
-  #opts;
-  #candidateValues = derived(() => this.#opts.candidateValues());
-  #search;
-  constructor(opts) {
-    this.#opts = opts;
-    this.#search = boxAutoReset("", { afterMs: 1e3, getWindow: this.#opts.getWindow });
-    this.handleTypeaheadSearch = this.handleTypeaheadSearch.bind(this);
-    this.resetTypeahead = this.resetTypeahead.bind(this);
-  }
-  handleTypeaheadSearch(key) {
-    if (!this.#opts.enabled() || !this.#candidateValues().length) return;
-    this.#search.current = this.#search.current + key;
-    const currentItem = this.#opts.getCurrentItem();
-    const currentMatch = this.#candidateValues().find((item) => item === currentItem) ?? "";
-    const values = this.#candidateValues().map((item) => item ?? "");
-    const nextMatch = getNextMatch(values, this.#search.current, currentMatch);
-    const newItem = this.#candidateValues().find((item) => item === nextMatch);
-    if (newItem) {
-      this.#opts.onMatch(newItem);
-    }
-    return newItem;
-  }
-  resetTypeahead() {
-    this.#search.current = "";
-  }
-}
-const FIRST_KEYS = [ARROW_DOWN, PAGE_UP, HOME];
-const LAST_KEYS = [ARROW_UP, PAGE_DOWN, END];
-const FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
-const selectAttrs = createBitsAttrs({
-  component: "select",
-  parts: [
-    "trigger",
-    "content",
-    "item",
-    "viewport",
-    "scroll-up-button",
-    "scroll-down-button",
-    "group",
-    "group-label",
-    "separator",
-    "arrow",
-    "input",
-    "content-wrapper",
-    "item-text",
-    "value"
-  ]
-});
-const SelectRootContext = new Context("Select.Root | Combobox.Root");
-const SelectContentContext = new Context("Select.Content | Combobox.Content");
-class SelectBaseRootState {
-  opts;
-  touchedInput = false;
-  inputNode = null;
-  contentNode = null;
-  contentPresence;
-  viewportNode = null;
-  triggerNode = null;
-  valueNode = null;
-  valueId = "";
-  highlightedNode = null;
-  #highlightedValue = derived(() => {
-    if (!this.highlightedNode) return null;
-    return this.highlightedNode.getAttribute("data-value");
-  });
-  get highlightedValue() {
-    return this.#highlightedValue();
-  }
-  set highlightedValue($$value) {
-    return this.#highlightedValue($$value);
-  }
-  #highlightedId = derived(() => {
-    if (!this.highlightedNode) return void 0;
-    return this.highlightedNode.id;
-  });
-  get highlightedId() {
-    return this.#highlightedId();
-  }
-  set highlightedId($$value) {
-    return this.#highlightedId($$value);
-  }
-  #highlightedLabel = derived(() => {
-    if (!this.highlightedNode) return null;
-    return this.highlightedNode.getAttribute("data-label");
-  });
-  get highlightedLabel() {
-    return this.#highlightedLabel();
-  }
-  set highlightedLabel($$value) {
-    return this.#highlightedLabel($$value);
-  }
-  contentIsPositioned = false;
-  isUsingKeyboard = false;
-  isCombobox = false;
-  domContext = new DOMContext(() => null);
-  constructor(opts) {
-    this.opts = opts;
-    this.isCombobox = opts.isCombobox;
-    this.contentPresence = new PresenceManager({
-      ref: boxWith(() => this.contentNode),
-      open: this.opts.open,
-      onComplete: () => {
-        this.opts.onOpenChangeComplete.current(this.opts.open.current);
-      }
-    });
-  }
-  setHighlightedNode(node, initial = false) {
-    this.highlightedNode = node;
-    if (node && (this.isUsingKeyboard || initial)) {
-      this.scrollHighlightedNodeIntoView(node);
-    }
-  }
-  scrollHighlightedNodeIntoView(node) {
-    if (!this.viewportNode || !this.contentIsPositioned) return;
-    node.scrollIntoView({ block: this.opts.scrollAlignment.current });
-  }
-  getCandidateNodes() {
-    const node = this.contentNode;
-    if (!node) return [];
-    return Array.from(node.querySelectorAll(`[${this.getBitsAttr("item")}]:not([data-disabled])`));
-  }
-  setHighlightedToFirstCandidate(initial = false) {
-    this.setHighlightedNode(null);
-    let nodes = this.getCandidateNodes();
-    if (!nodes.length) return;
-    if (this.viewportNode) {
-      const viewportRect = this.viewportNode.getBoundingClientRect();
-      nodes = nodes.filter((node) => {
-        if (!this.viewportNode) return false;
-        const nodeRect = node.getBoundingClientRect();
-        const isNodeFullyVisible = nodeRect.right <= viewportRect.right && nodeRect.left >= viewportRect.left && nodeRect.bottom <= viewportRect.bottom && nodeRect.top >= viewportRect.top;
-        return isNodeFullyVisible;
-      });
-    }
-    this.setHighlightedNode(nodes[0], initial);
-  }
-  getNodeByValue(value) {
-    const candidateNodes = this.getCandidateNodes();
-    return candidateNodes.find((node) => node.dataset.value === value) ?? null;
-  }
-  /**
-   * Resolves the display label for a value: `items` entry when present, otherwise the
-   * mounted item's `data-label` or its text content.
-   */
-  getLabelForValue(value) {
-    if (value === "") return "";
-    const fromItems = this.opts.items.current.find((item) => item.value === value)?.label;
-    if (fromItems !== void 0) return fromItems;
-    const node = this.getNodeByValue(value);
-    if (node) {
-      const dataLabel = node.getAttribute("data-label");
-      if (dataLabel !== null && dataLabel !== "") return dataLabel;
-      return node.textContent?.trim() ?? value;
-    }
-    return value;
-  }
-  setOpen(open) {
-    this.opts.open.current = open;
-  }
-  toggleOpen() {
-    this.opts.open.current = !this.opts.open.current;
-  }
-  handleOpen() {
-    this.setOpen(true);
-  }
-  handleClose() {
-    this.setHighlightedNode(null);
-    this.setOpen(false);
-  }
-  toggleMenu() {
-    this.toggleOpen();
-  }
-  getBitsAttr = (part) => {
-    return selectAttrs.getAttr(part, this.isCombobox ? "combobox" : void 0);
-  };
-}
-class SelectSingleRootState extends SelectBaseRootState {
-  opts;
-  isMulti = false;
-  #hasValue = derived(() => this.opts.value.current !== "");
-  get hasValue() {
-    return this.#hasValue();
-  }
-  set hasValue($$value) {
-    return this.#hasValue($$value);
-  }
-  #currentLabel = derived(() => {
-    if (!this.opts.items.current.length) return "";
-    return this.opts.items.current.find((item) => item.value === this.opts.value.current)?.label ?? "";
-  });
-  get currentLabel() {
-    return this.#currentLabel();
-  }
-  set currentLabel($$value) {
-    return this.#currentLabel($$value);
-  }
-  #candidateLabels = derived(() => {
-    if (!this.opts.items.current.length) return [];
-    const filteredItems = this.opts.items.current.filter((item) => !item.disabled);
-    return filteredItems.map((item) => item.label);
-  });
-  get candidateLabels() {
-    return this.#candidateLabels();
-  }
-  set candidateLabels($$value) {
-    return this.#candidateLabels($$value);
-  }
-  #dataTypeaheadEnabled = derived(() => {
-    if (this.isMulti) return false;
-    if (this.opts.items.current.length === 0) return false;
-    return true;
-  });
-  get dataTypeaheadEnabled() {
-    return this.#dataTypeaheadEnabled();
-  }
-  set dataTypeaheadEnabled($$value) {
-    return this.#dataTypeaheadEnabled($$value);
-  }
-  constructor(opts) {
-    super(opts);
-    this.opts = opts;
-    watch(() => this.opts.open.current, () => {
-      if (!this.opts.open.current) return;
-      this.setInitialHighlightedNode();
-    });
-  }
-  includesItem(itemValue) {
-    return this.opts.value.current === itemValue;
-  }
-  toggleItem(itemValue, itemLabel = itemValue) {
-    const newValue = this.includesItem(itemValue) ? "" : itemValue;
-    this.opts.value.current = newValue;
-    if (newValue !== "") {
-      this.opts.inputValue.current = itemLabel;
-    }
-  }
-  setInitialHighlightedNode() {
-    afterTick(() => {
-      if (this.highlightedNode && this.domContext.getDocument().contains(this.highlightedNode)) return;
-      if (this.opts.value.current !== "") {
-        const node = this.getNodeByValue(this.opts.value.current);
-        if (node) {
-          this.setHighlightedNode(node, true);
-          return;
-        }
-      }
-      this.setHighlightedToFirstCandidate(true);
-    });
-  }
-}
-class SelectMultipleRootState extends SelectBaseRootState {
-  opts;
-  isMulti = true;
-  #hasValue = derived(() => this.opts.value.current.length > 0);
-  get hasValue() {
-    return this.#hasValue();
-  }
-  set hasValue($$value) {
-    return this.#hasValue($$value);
-  }
-  constructor(opts) {
-    super(opts);
-    this.opts = opts;
-    watch(() => this.opts.open.current, () => {
-      if (!this.opts.open.current) return;
-      this.setInitialHighlightedNode();
-    });
-  }
-  includesItem(itemValue) {
-    return this.opts.value.current.includes(itemValue);
-  }
-  toggleItem(itemValue, itemLabel = itemValue) {
-    if (this.includesItem(itemValue)) {
-      this.opts.value.current = this.opts.value.current.filter((v) => v !== itemValue);
-    } else {
-      this.opts.value.current = [...this.opts.value.current, itemValue];
-    }
-    this.opts.inputValue.current = itemLabel;
-  }
-  setInitialHighlightedNode() {
-    afterTick(() => {
-      if (!this.domContext) return;
-      if (this.highlightedNode && this.domContext.getDocument().contains(this.highlightedNode)) return;
-      if (this.opts.value.current.length && this.opts.value.current[0] !== "") {
-        const node = this.getNodeByValue(this.opts.value.current[0]);
-        if (node) {
-          this.setHighlightedNode(node, true);
-          return;
-        }
-      }
-      this.setHighlightedToFirstCandidate(true);
-    });
-  }
-}
-class SelectRootState {
-  static create(props) {
-    const { type, ...rest } = props;
-    const rootState = type === "single" ? new SelectSingleRootState(rest) : new SelectMultipleRootState(rest);
-    return SelectRootContext.set(rootState);
-  }
-}
-class SelectTriggerState {
-  static create(opts) {
-    return new SelectTriggerState(opts, SelectRootContext.get());
-  }
-  opts;
-  root;
-  attachment;
-  #domTypeahead;
-  #dataTypeahead;
-  constructor(opts, root) {
-    this.opts = opts;
-    this.root = root;
-    this.attachment = attachRef(opts.ref, (v) => this.root.triggerNode = v);
-    this.root.domContext = new DOMContext(opts.ref);
-    this.#domTypeahead = new DOMTypeahead({
-      getCurrentItem: () => this.root.highlightedNode,
-      onMatch: (node) => {
-        this.root.setHighlightedNode(node);
-      },
-      getActiveElement: () => this.root.domContext.getActiveElement(),
-      getWindow: () => this.root.domContext.getWindow()
-    });
-    this.#dataTypeahead = new DataTypeahead({
-      getCurrentItem: () => {
-        if (this.root.isMulti) return "";
-        return this.root.currentLabel;
-      },
-      onMatch: (label) => {
-        if (this.root.isMulti) return;
-        if (!this.root.opts.items.current) return;
-        const matchedItem = this.root.opts.items.current.find((item) => item.label === label);
-        if (!matchedItem) return;
-        this.root.opts.value.current = matchedItem.value;
-      },
-      enabled: () => !this.root.isMulti && this.root.dataTypeaheadEnabled,
-      candidateValues: () => this.root.isMulti ? [] : this.root.candidateLabels,
-      getWindow: () => this.root.domContext.getWindow()
-    });
-    this.onkeydown = this.onkeydown.bind(this);
-    this.onpointerdown = this.onpointerdown.bind(this);
-    this.onpointerup = this.onpointerup.bind(this);
-    this.onclick = this.onclick.bind(this);
-  }
-  #handleOpen() {
-    this.root.opts.open.current = true;
-    this.#dataTypeahead.resetTypeahead();
-    this.#domTypeahead.resetTypeahead();
-  }
-  #handlePointerOpen(_) {
-    this.#handleOpen();
-  }
-  /**
-   * Logic used to handle keyboard selection/deselection.
-   *
-   * If it returns true, it means the item was selected and whatever is calling
-   * this function should return early
-   *
-   */
-  #handleKeyboardSelection() {
-    const isCurrentSelectedValue = this.root.highlightedValue === this.root.opts.value.current;
-    if (!this.root.opts.allowDeselect.current && isCurrentSelectedValue && !this.root.isMulti) {
-      this.root.handleClose();
-      return true;
-    }
-    if (this.root.highlightedValue !== null) {
-      this.root.toggleItem(this.root.highlightedValue, this.root.highlightedLabel ?? void 0);
-    }
-    if (!this.root.isMulti && !isCurrentSelectedValue) {
-      this.root.handleClose();
-      return true;
-    }
-    return false;
-  }
-  onkeydown(e) {
-    this.root.isUsingKeyboard = true;
-    if (e.key === ARROW_UP || e.key === ARROW_DOWN) e.preventDefault();
-    if (!this.root.opts.open.current) {
-      if (e.key === ENTER || e.key === SPACE || e.key === ARROW_DOWN || e.key === ARROW_UP) {
-        e.preventDefault();
-        this.root.handleOpen();
-      } else if (!this.root.isMulti && this.root.dataTypeaheadEnabled) {
-        this.#dataTypeahead.handleTypeaheadSearch(e.key);
-        return;
-      }
-      if (this.root.hasValue) return;
-      const candidateNodes2 = this.root.getCandidateNodes();
-      if (!candidateNodes2.length) return;
-      if (e.key === ARROW_DOWN) {
-        const firstCandidate = candidateNodes2[0];
-        this.root.setHighlightedNode(firstCandidate);
-      } else if (e.key === ARROW_UP) {
-        const lastCandidate = candidateNodes2[candidateNodes2.length - 1];
-        this.root.setHighlightedNode(lastCandidate);
-      }
-      return;
-    }
-    if (e.key === TAB) {
-      this.root.handleClose();
-      return;
-    }
-    if ((e.key === ENTER || // if we're currently "typing ahead", we don't want to select the item
-    // just yet as the item the user is trying to get to may have a space in it,
-    // so we defer handling the close for this case until further down
-    e.key === SPACE && this.#domTypeahead.search === "") && !e.isComposing) {
-      e.preventDefault();
-      const shouldReturn = this.#handleKeyboardSelection();
-      if (shouldReturn) return;
-    }
-    if (e.key === ARROW_UP && e.altKey) {
-      this.root.handleClose();
-    }
-    if (FIRST_LAST_KEYS.includes(e.key)) {
-      e.preventDefault();
-      const candidateNodes2 = this.root.getCandidateNodes();
-      const currHighlightedNode = this.root.highlightedNode;
-      const currIndex = currHighlightedNode ? candidateNodes2.indexOf(currHighlightedNode) : -1;
-      const loop = this.root.opts.loop.current;
-      let nextItem;
-      if (e.key === ARROW_DOWN) {
-        nextItem = next(candidateNodes2, currIndex, loop);
-      } else if (e.key === ARROW_UP) {
-        nextItem = prev(candidateNodes2, currIndex, loop);
-      } else if (e.key === PAGE_DOWN) {
-        nextItem = forward(candidateNodes2, currIndex, 10, loop);
-      } else if (e.key === PAGE_UP) {
-        nextItem = backward(candidateNodes2, currIndex, 10, loop);
-      } else if (e.key === HOME) {
-        nextItem = candidateNodes2[0];
-      } else if (e.key === END) {
-        nextItem = candidateNodes2[candidateNodes2.length - 1];
-      }
-      if (!nextItem) return;
-      this.root.setHighlightedNode(nextItem);
-      return;
-    }
-    const isModifierKey = e.ctrlKey || e.altKey || e.metaKey;
-    const isCharacterKey = e.key.length === 1;
-    const isSpaceKey = e.key === SPACE;
-    const candidateNodes = this.root.getCandidateNodes();
-    if (e.key === TAB) return;
-    if (!isModifierKey && (isCharacterKey || isSpaceKey)) {
-      const matchedNode = this.#domTypeahead.handleTypeaheadSearch(e.key, candidateNodes);
-      if (!matchedNode && isSpaceKey) {
-        e.preventDefault();
-        this.#handleKeyboardSelection();
-      }
-      return;
-    }
-    if (!this.root.highlightedNode) {
-      this.root.setHighlightedToFirstCandidate();
-    }
-  }
-  onclick(e) {
-    const currTarget = e.currentTarget;
-    currTarget.focus();
-  }
-  onpointerdown(e) {
-    if (this.root.opts.disabled.current) return;
-    if (e.pointerType === "touch") return e.preventDefault();
-    const target = e.target;
-    if (target?.hasPointerCapture(e.pointerId)) {
-      target?.releasePointerCapture(e.pointerId);
-    }
-    if (e.button === 0 && e.ctrlKey === false) {
-      if (this.root.opts.open.current === false) {
-        this.#handlePointerOpen(e);
-      } else {
-        this.root.handleClose();
-      }
-    }
-  }
-  onpointerup(e) {
-    if (this.root.opts.disabled.current) return;
-    e.preventDefault();
-    if (e.pointerType === "touch") {
-      if (this.root.opts.open.current === false) {
-        this.#handlePointerOpen(e);
-      } else {
-        this.root.handleClose();
-      }
-    }
-  }
-  #props = derived(() => ({
-    id: this.opts.id.current,
-    disabled: this.root.opts.disabled.current ? true : void 0,
-    "aria-haspopup": "listbox",
-    "aria-expanded": boolToStr(this.root.opts.open.current),
-    "aria-activedescendant": this.root.highlightedId,
-    "data-state": getDataOpenClosed(this.root.opts.open.current),
-    "data-disabled": boolToEmptyStrOrUndef(this.root.opts.disabled.current),
-    "data-placeholder": this.root.hasValue ? void 0 : "",
-    [this.root.getBitsAttr("trigger")]: "",
-    onpointerdown: this.onpointerdown,
-    onkeydown: this.onkeydown,
-    onclick: this.onclick,
-    onpointerup: this.onpointerup,
-    ...this.attachment
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-}
-class SelectContentState {
-  static create(opts) {
-    return SelectContentContext.set(new SelectContentState(opts, SelectRootContext.get()));
-  }
-  opts;
-  root;
-  attachment;
-  isPositioned = false;
-  domContext;
-  constructor(opts, root) {
-    this.opts = opts;
-    this.root = root;
-    this.attachment = attachRef(opts.ref, (v) => this.root.contentNode = v);
-    this.domContext = new DOMContext(this.opts.ref);
-    if (this.root.domContext === null) {
-      this.root.domContext = this.domContext;
-    }
-    watch(() => this.root.opts.open.current, () => {
-      if (this.root.opts.open.current) return;
-      this.root.contentIsPositioned = false;
-      this.isPositioned = false;
-    });
-    watch([() => this.isPositioned, () => this.root.highlightedNode], () => {
-      if (!this.isPositioned || !this.root.highlightedNode) return;
-      this.root.scrollHighlightedNodeIntoView(this.root.highlightedNode);
-    });
-    this.onpointermove = this.onpointermove.bind(this);
-  }
-  onpointermove(_) {
-    this.root.isUsingKeyboard = false;
-  }
-  #styles = derived(() => {
-    return getFloatingContentCSSVars(this.root.isCombobox ? "combobox" : "select");
-  });
-  onInteractOutside = (e) => {
-    if (e.target === this.root.triggerNode || e.target === this.root.inputNode) {
-      e.preventDefault();
-      return;
-    }
-    this.opts.onInteractOutside.current(e);
-    if (e.defaultPrevented) return;
-    this.root.handleClose();
-  };
-  onEscapeKeydown = (e) => {
-    this.opts.onEscapeKeydown.current(e);
-    if (e.defaultPrevented) return;
-    this.root.handleClose();
-  };
-  onOpenAutoFocus = (e) => {
-    e.preventDefault();
-  };
-  onCloseAutoFocus = (e) => {
-    e.preventDefault();
-  };
-  get shouldRender() {
-    return this.root.contentPresence.shouldRender;
-  }
-  #snippetProps = derived(() => ({ open: this.root.opts.open.current }));
-  get snippetProps() {
-    return this.#snippetProps();
-  }
-  set snippetProps($$value) {
-    return this.#snippetProps($$value);
-  }
-  #props = derived(() => ({
-    id: this.opts.id.current,
-    role: "listbox",
-    "aria-multiselectable": this.root.isMulti ? "true" : void 0,
-    "data-state": getDataOpenClosed(this.root.opts.open.current),
-    ...getDataTransitionAttrs(this.root.contentPresence.transitionStatus),
-    [this.root.getBitsAttr("content")]: "",
-    style: {
-      display: "flex",
-      flexDirection: "column",
-      outline: "none",
-      boxSizing: "border-box",
-      pointerEvents: "auto",
-      ...this.#styles()
-    },
-    onpointermove: this.onpointermove,
-    ...this.attachment
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-  popperProps = {
-    onInteractOutside: this.onInteractOutside,
-    onEscapeKeydown: this.onEscapeKeydown,
-    onOpenAutoFocus: this.onOpenAutoFocus,
-    onCloseAutoFocus: this.onCloseAutoFocus,
-    trapFocus: false,
-    loop: false,
-    onPlaced: () => {
-      if (this.root.opts.open.current) {
-        this.root.contentIsPositioned = true;
-        this.isPositioned = true;
-      }
-    }
-  };
-}
-class SelectItemState {
-  static create(opts) {
-    return new SelectItemState(opts, SelectRootContext.get());
-  }
-  opts;
-  root;
-  attachment;
-  #isSelected = derived(() => this.root.includesItem(this.opts.value.current));
-  get isSelected() {
-    return this.#isSelected();
-  }
-  set isSelected($$value) {
-    return this.#isSelected($$value);
-  }
-  #isHighlighted = derived(() => this.root.highlightedValue === this.opts.value.current);
-  get isHighlighted() {
-    return this.#isHighlighted();
-  }
-  set isHighlighted($$value) {
-    return this.#isHighlighted($$value);
-  }
-  prevHighlighted = new Previous(() => this.isHighlighted);
-  mounted = false;
-  constructor(opts, root) {
-    this.opts = opts;
-    this.root = root;
-    this.attachment = attachRef(opts.ref);
-    watch([() => this.isHighlighted, () => this.prevHighlighted.current], () => {
-      if (this.isHighlighted) {
-        this.opts.onHighlight.current();
-      } else if (this.prevHighlighted.current) {
-        this.opts.onUnhighlight.current();
-      }
-    });
-    watch(() => this.mounted, () => {
-      if (!this.mounted) return;
-      this.root.setInitialHighlightedNode();
-    });
-    this.onpointerdown = this.onpointerdown.bind(this);
-    this.onpointerup = this.onpointerup.bind(this);
-    this.onpointermove = this.onpointermove.bind(this);
-  }
-  handleSelect() {
-    if (this.opts.disabled.current) return;
-    const isCurrentSelectedValue = this.opts.value.current === this.root.opts.value.current;
-    if (!this.root.opts.allowDeselect.current && isCurrentSelectedValue && !this.root.isMulti) {
-      this.root.handleClose();
-      return;
-    }
-    this.root.toggleItem(this.opts.value.current, this.opts.label.current);
-    if (!this.root.isMulti && !isCurrentSelectedValue) {
-      this.root.handleClose();
-    }
-  }
-  #snippetProps = derived(() => ({ selected: this.isSelected, highlighted: this.isHighlighted }));
-  get snippetProps() {
-    return this.#snippetProps();
-  }
-  set snippetProps($$value) {
-    return this.#snippetProps($$value);
-  }
-  onpointerdown(e) {
-    e.preventDefault();
-  }
-  /**
-   * Using `pointerup` instead of `click` allows power users to pointerdown
-   * the trigger, then release pointerup on an item to select it vs having to do
-   * multiple clicks.
-   */
-  onpointerup(e) {
-    if (e.defaultPrevented || !this.opts.ref.current) return;
-    if (e.pointerType === "touch" && !isIOS) {
-      on(
-        this.opts.ref.current,
-        "click",
-        () => {
-          this.handleSelect();
-          this.root.setHighlightedNode(this.opts.ref.current);
-        },
-        { once: true }
-      );
-      return;
-    }
-    e.preventDefault();
-    this.handleSelect();
-    if (e.pointerType === "touch") {
-      this.root.setHighlightedNode(this.opts.ref.current);
-    }
-  }
-  onpointermove(e) {
-    if (e.pointerType === "touch") return;
-    if (this.root.highlightedNode !== this.opts.ref.current) {
-      this.root.setHighlightedNode(this.opts.ref.current);
-    }
-  }
-  #props = derived(() => ({
-    id: this.opts.id.current,
-    role: "option",
-    "aria-selected": this.root.includesItem(this.opts.value.current) ? "true" : void 0,
-    "data-value": this.opts.value.current,
-    "data-disabled": boolToEmptyStrOrUndef(this.opts.disabled.current),
-    "data-highlighted": this.root.highlightedValue === this.opts.value.current && !this.opts.disabled.current ? "" : void 0,
-    "data-selected": this.root.includesItem(this.opts.value.current) ? "" : void 0,
-    "data-label": this.opts.label.current,
-    [this.root.getBitsAttr("item")]: "",
-    onpointermove: this.onpointermove,
-    onpointerdown: this.onpointerdown,
-    onpointerup: this.onpointerup,
-    ...this.attachment
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-}
-class SelectHiddenInputState {
-  static create(opts) {
-    return new SelectHiddenInputState(opts, SelectRootContext.get());
-  }
-  opts;
-  root;
-  #shouldRender = derived(() => this.root.opts.name.current !== "");
-  get shouldRender() {
-    return this.#shouldRender();
-  }
-  set shouldRender($$value) {
-    return this.#shouldRender($$value);
-  }
-  constructor(opts, root) {
-    this.opts = opts;
-    this.root = root;
-    this.onfocus = this.onfocus.bind(this);
-  }
-  onfocus(e) {
-    e.preventDefault();
-    if (!this.root.isCombobox) {
-      this.root.triggerNode?.focus();
-    } else {
-      this.root.inputNode?.focus();
-    }
-  }
-  #props = derived(() => ({
-    disabled: boolToTrueOrUndef(this.root.opts.disabled.current),
-    required: boolToTrueOrUndef(this.root.opts.required.current),
-    name: this.root.opts.name.current,
-    value: this.opts.value.current,
-    onfocus: this.onfocus
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-}
-class SelectViewportState {
-  static create(opts) {
-    return new SelectViewportState(opts, SelectContentContext.get());
-  }
-  opts;
-  content;
-  root;
-  attachment;
-  prevScrollTop = 0;
-  constructor(opts, content) {
-    this.opts = opts;
-    this.content = content;
-    this.root = content.root;
-    this.attachment = attachRef(opts.ref, (v) => {
-      this.root.viewportNode = v;
-    });
-  }
-  #props = derived(() => ({
-    id: this.opts.id.current,
-    role: "presentation",
-    [this.root.getBitsAttr("viewport")]: "",
-    style: {
-      // we use position: 'relative' here on the `viewport` so that when we call
-      // `selectedItem.offsetTop` in calculations, the offset is relative to the viewport
-      // (independent of the scrollUpButton).
-      position: "relative",
-      flex: 1,
-      overflow: "auto"
-    },
-    ...this.attachment
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-}
-class SelectScrollButtonImplState {
-  opts;
-  content;
-  root;
-  attachment;
-  autoScrollTimer = null;
-  userScrollTimer = -1;
-  isUserScrolling = false;
-  onAutoScroll = noop;
-  mounted = false;
-  constructor(opts, content) {
-    this.opts = opts;
-    this.content = content;
-    this.root = content.root;
-    this.attachment = attachRef(opts.ref);
-    watch([() => this.mounted], () => {
-      if (!this.mounted) {
-        this.isUserScrolling = false;
-        return;
-      }
-      if (this.isUserScrolling) return;
-    });
-    this.onpointerdown = this.onpointerdown.bind(this);
-    this.onpointermove = this.onpointermove.bind(this);
-    this.onpointerleave = this.onpointerleave.bind(this);
-  }
-  handleUserScroll() {
-    this.content.domContext.clearTimeout(this.userScrollTimer);
-    this.isUserScrolling = true;
-    this.userScrollTimer = this.content.domContext.setTimeout(
-      () => {
-        this.isUserScrolling = false;
-      },
-      200
-    );
-  }
-  clearAutoScrollInterval() {
-    if (this.autoScrollTimer === null) return;
-    this.content.domContext.clearTimeout(this.autoScrollTimer);
-    this.autoScrollTimer = null;
-  }
-  onpointerdown(_) {
-    if (this.autoScrollTimer !== null) return;
-    const autoScroll = (tick) => {
-      this.onAutoScroll();
-      this.autoScrollTimer = this.content.domContext.setTimeout(() => autoScroll(tick + 1), this.opts.delay.current(tick));
-    };
-    this.autoScrollTimer = this.content.domContext.setTimeout(() => autoScroll(1), this.opts.delay.current(0));
-  }
-  onpointermove(e) {
-    this.onpointerdown(e);
-  }
-  onpointerleave(_) {
-    this.clearAutoScrollInterval();
-  }
-  #props = derived(() => ({
-    id: this.opts.id.current,
-    "aria-hidden": boolToStrTrueOrUndef(true),
-    style: { flexShrink: 0 },
-    onpointerdown: this.onpointerdown,
-    onpointermove: this.onpointermove,
-    onpointerleave: this.onpointerleave,
-    ...this.attachment
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-}
-class SelectScrollDownButtonState {
-  static create(opts) {
-    return new SelectScrollDownButtonState(new SelectScrollButtonImplState(opts, SelectContentContext.get()));
-  }
-  scrollButtonState;
-  content;
-  root;
-  canScrollDown = false;
-  scrollIntoViewTimer = null;
-  constructor(scrollButtonState) {
-    this.scrollButtonState = scrollButtonState;
-    this.content = scrollButtonState.content;
-    this.root = scrollButtonState.root;
-    this.scrollButtonState.onAutoScroll = this.handleAutoScroll;
-    watch(
-      [
-        () => this.root.viewportNode,
-        () => this.content.isPositioned
-      ],
-      () => {
-        if (!this.root.viewportNode || !this.content.isPositioned) return;
-        this.handleScroll(true);
-        return on(this.root.viewportNode, "scroll", () => this.handleScroll());
-      }
-    );
-    watch(
-      [
-        () => this.root.opts.inputValue.current,
-        () => this.root.viewportNode,
-        () => this.content.isPositioned
-      ],
-      () => {
-        if (!this.root.viewportNode || !this.content.isPositioned) return;
-        this.handleScroll(true);
-      }
-    );
-    watch(() => this.scrollButtonState.mounted, () => {
-      if (!this.scrollButtonState.mounted) return;
-      if (this.scrollIntoViewTimer) {
-        clearTimeout(this.scrollIntoViewTimer);
-      }
-      this.scrollIntoViewTimer = afterSleep(5, () => {
-        const activeItem = this.root.highlightedNode;
-        if (!activeItem) return;
-        this.root.scrollHighlightedNodeIntoView(activeItem);
-      });
-    });
-  }
-  /**
-   * @param manual - if true, it means the function was invoked manually outside of an event
-   * listener, so we don't call `handleUserScroll` to prevent the auto scroll from kicking in.
-   */
-  handleScroll = (manual = false) => {
-    if (!manual) {
-      this.scrollButtonState.handleUserScroll();
-    }
-    if (!this.root.viewportNode) return;
-    const maxScroll = this.root.viewportNode.scrollHeight - this.root.viewportNode.clientHeight;
-    const paddingTop = Number.parseInt(getComputedStyle(this.root.viewportNode).paddingTop, 10);
-    this.canScrollDown = Math.ceil(this.root.viewportNode.scrollTop) < maxScroll - paddingTop;
-  };
-  handleAutoScroll = () => {
-    const viewport = this.root.viewportNode;
-    const selectedItem = this.root.highlightedNode;
-    if (!viewport || !selectedItem) return;
-    viewport.scrollTop = viewport.scrollTop + selectedItem.offsetHeight;
-  };
-  #props = derived(() => ({
-    ...this.scrollButtonState.props,
-    [this.root.getBitsAttr("scroll-down-button")]: ""
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-}
-class SelectScrollUpButtonState {
-  static create(opts) {
-    return new SelectScrollUpButtonState(new SelectScrollButtonImplState(opts, SelectContentContext.get()));
-  }
-  scrollButtonState;
-  content;
-  root;
-  canScrollUp = false;
-  constructor(scrollButtonState) {
-    this.scrollButtonState = scrollButtonState;
-    this.content = scrollButtonState.content;
-    this.root = scrollButtonState.root;
-    this.scrollButtonState.onAutoScroll = this.handleAutoScroll;
-    watch(
-      [
-        () => this.root.viewportNode,
-        () => this.content.isPositioned
-      ],
-      () => {
-        if (!this.root.viewportNode || !this.content.isPositioned) return;
-        this.handleScroll(true);
-        return on(this.root.viewportNode, "scroll", () => this.handleScroll());
-      }
-    );
-  }
-  /**
-   * @param manual - if true, it means the function was invoked manually outside of an event
-   * listener, so we don't call `handleUserScroll` to prevent the auto scroll from kicking in.
-   */
-  handleScroll = (manual = false) => {
-    if (!manual) {
-      this.scrollButtonState.handleUserScroll();
-    }
-    if (!this.root.viewportNode) return;
-    const paddingTop = Number.parseInt(getComputedStyle(this.root.viewportNode).paddingTop, 10);
-    this.canScrollUp = this.root.viewportNode.scrollTop - paddingTop > 0.1;
-  };
-  handleAutoScroll = () => {
-    if (!this.root.viewportNode || !this.root.highlightedNode) return;
-    this.root.viewportNode.scrollTop = this.root.viewportNode.scrollTop - this.root.highlightedNode.offsetHeight;
-  };
-  #props = derived(() => ({
-    ...this.scrollButtonState.props,
-    [this.root.getBitsAttr("scroll-up-button")]: ""
-  }));
-  get props() {
-    return this.#props();
-  }
-  set props($$value) {
-    return this.#props($$value);
-  }
-}
-function Select_hidden_input($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let { value = void 0, autocomplete } = $$props;
-    const hiddenInputState = SelectHiddenInputState.create({ value: boxWith(() => value) });
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      if (hiddenInputState.shouldRender) {
-        $$renderer3.push("<!--[0-->");
-        Hidden_input($$renderer3, spread_props([
-          hiddenInputState.props,
-          {
-            autocomplete,
-            get value() {
-              return value;
-            },
-            set value($$value) {
-              value = $$value;
-              $$settled = false;
-            }
-          }
-        ]));
-      } else {
-        $$renderer3.push("<!--[-1-->");
-      }
-      $$renderer3.push(`<!--]-->`);
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { value });
-  });
-}
-function Floating_layer_anchor($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let { id, children, virtualEl, ref, tooltip = false } = $$props;
-    FloatingAnchorState.create(
-      {
-        id: boxWith(() => id),
-        virtualEl: boxWith(() => virtualEl),
-        ref
-      },
-      tooltip
-    );
-    children?.($$renderer2);
-    $$renderer2.push(`<!---->`);
-  });
-}
-function Floating_layer_content($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let {
-      content,
-      side = "bottom",
-      sideOffset = 0,
-      align = "center",
-      alignOffset = 0,
-      id,
-      arrowPadding = 0,
-      avoidCollisions = true,
-      collisionBoundary = [],
-      collisionPadding = 0,
-      hideWhenDetached = false,
-      onPlaced = () => {
-      },
-      sticky = "partial",
-      updatePositionStrategy = "optimized",
-      strategy = "fixed",
-      dir = "ltr",
-      style = {},
-      wrapperId = useId(),
-      customAnchor = null,
-      enabled,
-      tooltip = false
-    } = $$props;
-    const contentState = FloatingContentState.create(
-      {
-        side: boxWith(() => side),
-        sideOffset: boxWith(() => sideOffset),
-        align: boxWith(() => align),
-        alignOffset: boxWith(() => alignOffset),
-        id: boxWith(() => id),
-        arrowPadding: boxWith(() => arrowPadding),
-        avoidCollisions: boxWith(() => avoidCollisions),
-        collisionBoundary: boxWith(() => collisionBoundary),
-        collisionPadding: boxWith(() => collisionPadding),
-        hideWhenDetached: boxWith(() => hideWhenDetached),
-        onPlaced: boxWith(() => onPlaced),
-        sticky: boxWith(() => sticky),
-        updatePositionStrategy: boxWith(() => updatePositionStrategy),
-        strategy: boxWith(() => strategy),
-        dir: boxWith(() => dir),
-        style: boxWith(() => style),
-        enabled: boxWith(() => enabled),
-        wrapperId: boxWith(() => wrapperId),
-        customAnchor: boxWith(() => customAnchor)
-      },
-      tooltip
-    );
-    const mergedProps = derived(() => mergeProps(contentState.wrapperProps, { style: { pointerEvents: "auto" } }));
-    content?.($$renderer2, { props: contentState.props, wrapperProps: mergedProps() });
-    $$renderer2.push(`<!---->`);
-  });
-}
-function Floating_layer_content_static($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let { content } = $$props;
-    content?.($$renderer2, { props: {}, wrapperProps: {} });
-    $$renderer2.push(`<!---->`);
-  });
-}
-function Popper_content($$renderer, $$props) {
-  let {
-    content,
-    isStatic = false,
-    onPlaced,
-    $$slots,
-    $$events,
-    ...restProps
-  } = $$props;
-  if (isStatic) {
-    $$renderer.push("<!--[0-->");
-    Floating_layer_content_static($$renderer, { content });
-  } else {
-    $$renderer.push("<!--[-1-->");
-    Floating_layer_content($$renderer, spread_props([{ content, onPlaced }, restProps]));
-  }
-  $$renderer.push(`<!--]-->`);
-}
-function Popper_layer_inner($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let {
-      popper,
-      onEscapeKeydown,
-      escapeKeydownBehavior,
-      preventOverflowTextSelection,
-      id,
-      onPointerDown,
-      onPointerUp,
-      side,
-      sideOffset,
-      align,
-      alignOffset,
-      arrowPadding,
-      avoidCollisions,
-      collisionBoundary,
-      collisionPadding,
-      sticky,
-      hideWhenDetached,
-      updatePositionStrategy,
-      strategy,
-      dir,
-      preventScroll,
-      wrapperId,
-      style,
-      onPlaced,
-      onInteractOutside,
-      onCloseAutoFocus,
-      onOpenAutoFocus,
-      onFocusOutside,
-      interactOutsideBehavior = "close",
-      loop,
-      trapFocus = true,
-      isValidEvent = () => false,
-      customAnchor = null,
-      isStatic = false,
-      enabled,
-      ref,
-      tooltip = false,
-      contentPointerEvents = "auto",
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    const resolvedPreventScroll = derived(() => preventScroll ?? true);
-    const effectiveStrategy = derived(() => strategy ?? (resolvedPreventScroll() ? "fixed" : "absolute"));
-    {
-      let content = function($$renderer3, { props: floatingProps, wrapperProps }) {
-        if (restProps.forceMount && enabled) {
-          $$renderer3.push("<!--[0-->");
-          Scroll_lock($$renderer3, { preventScroll: resolvedPreventScroll() });
-        } else if (!restProps.forceMount) {
-          $$renderer3.push("<!--[1-->");
-          Scroll_lock($$renderer3, { preventScroll: resolvedPreventScroll() });
-        } else {
-          $$renderer3.push("<!--[-1-->");
-        }
-        $$renderer3.push(`<!--]--> `);
-        {
-          let focusScope = function($$renderer4, { props: focusScopeProps }) {
-            Escape_layer($$renderer4, {
-              onEscapeKeydown,
-              escapeKeydownBehavior,
-              enabled,
-              ref,
-              children: ($$renderer5) => {
-                {
-                  let children = function($$renderer6, { props: dismissibleProps }) {
-                    Text_selection_layer($$renderer6, {
-                      id,
-                      preventOverflowTextSelection,
-                      onPointerDown,
-                      onPointerUp,
-                      enabled,
-                      ref,
-                      children: ($$renderer7) => {
-                        popper?.($$renderer7, {
-                          props: mergeProps(restProps, floatingProps, dismissibleProps, focusScopeProps, { style: { pointerEvents: contentPointerEvents } }),
-                          wrapperProps
-                        });
-                        $$renderer7.push(`<!---->`);
-                      }
-                    });
-                  };
-                  Dismissible_layer($$renderer5, {
-                    id,
-                    onInteractOutside,
-                    onFocusOutside,
-                    interactOutsideBehavior,
-                    isValidEvent,
-                    enabled,
-                    ref,
-                    children
-                  });
-                }
-              }
-            });
-          };
-          Focus_scope($$renderer3, {
-            onOpenAutoFocus,
-            onCloseAutoFocus,
-            loop,
-            enabled,
-            trapFocus,
-            forceMount: restProps.forceMount,
-            ref,
-            focusScope
-          });
-        }
-        $$renderer3.push(`<!---->`);
-      };
-      Popper_content($$renderer2, {
-        isStatic,
-        id,
-        side,
-        sideOffset,
-        align,
-        alignOffset,
-        arrowPadding,
-        avoidCollisions,
-        collisionBoundary,
-        collisionPadding,
-        sticky,
-        hideWhenDetached,
-        updatePositionStrategy,
-        strategy: effectiveStrategy(),
-        dir,
-        wrapperId,
-        style,
-        onPlaced,
-        customAnchor,
-        enabled,
-        tooltip,
-        content,
-        $$slots: { content: true }
-      });
-    }
-  });
-}
-function Popper_layer($$renderer, $$props) {
-  let {
-    popper,
-    open,
-    onEscapeKeydown,
-    escapeKeydownBehavior,
-    preventOverflowTextSelection,
-    id,
-    onPointerDown,
-    onPointerUp,
-    side,
-    sideOffset,
-    align,
-    alignOffset,
-    arrowPadding,
-    avoidCollisions,
-    collisionBoundary,
-    collisionPadding,
-    sticky,
-    hideWhenDetached,
-    updatePositionStrategy,
-    strategy,
-    dir,
-    preventScroll,
-    wrapperId,
-    style,
-    onPlaced,
-    onInteractOutside,
-    onCloseAutoFocus,
-    onOpenAutoFocus,
-    onFocusOutside,
-    interactOutsideBehavior = "close",
-    loop,
-    trapFocus = true,
-    isValidEvent = () => false,
-    customAnchor = null,
-    isStatic = false,
-    ref,
-    shouldRender,
-    $$slots,
-    $$events,
-    ...restProps
-  } = $$props;
-  if (shouldRender) {
-    $$renderer.push("<!--[0-->");
-    Popper_layer_inner($$renderer, spread_props([
-      {
-        popper,
-        onEscapeKeydown,
-        escapeKeydownBehavior,
-        preventOverflowTextSelection,
-        id,
-        onPointerDown,
-        onPointerUp,
-        side,
-        sideOffset,
-        align,
-        alignOffset,
-        arrowPadding,
-        avoidCollisions,
-        collisionBoundary,
-        collisionPadding,
-        sticky,
-        hideWhenDetached,
-        updatePositionStrategy,
-        strategy,
-        dir,
-        preventScroll,
-        wrapperId,
-        style,
-        onPlaced,
-        customAnchor,
-        isStatic,
-        enabled: open,
-        onInteractOutside,
-        onCloseAutoFocus,
-        onOpenAutoFocus,
-        interactOutsideBehavior,
-        loop,
-        trapFocus,
-        isValidEvent,
-        onFocusOutside,
-        forceMount: false,
-        ref
-      },
-      restProps
-    ]));
-  } else {
-    $$renderer.push("<!--[-1-->");
-  }
-  $$renderer.push(`<!--]-->`);
-}
-function Popper_layer_force_mount($$renderer, $$props) {
-  let {
-    popper,
-    onEscapeKeydown,
-    escapeKeydownBehavior,
-    preventOverflowTextSelection,
-    id,
-    onPointerDown,
-    onPointerUp,
-    side,
-    sideOffset,
-    align,
-    alignOffset,
-    arrowPadding,
-    avoidCollisions,
-    collisionBoundary,
-    collisionPadding,
-    sticky,
-    hideWhenDetached,
-    updatePositionStrategy,
-    strategy,
-    dir,
-    preventScroll,
-    wrapperId,
-    style,
-    onPlaced,
-    onInteractOutside,
-    onCloseAutoFocus,
-    onOpenAutoFocus,
-    onFocusOutside,
-    interactOutsideBehavior = "close",
-    loop,
-    trapFocus = true,
-    isValidEvent = () => false,
-    customAnchor = null,
-    isStatic = false,
-    enabled,
-    $$slots,
-    $$events,
-    ...restProps
-  } = $$props;
-  Popper_layer_inner($$renderer, spread_props([
-    {
-      popper,
-      onEscapeKeydown,
-      escapeKeydownBehavior,
-      preventOverflowTextSelection,
-      id,
-      onPointerDown,
-      onPointerUp,
-      side,
-      sideOffset,
-      align,
-      alignOffset,
-      arrowPadding,
-      avoidCollisions,
-      collisionBoundary,
-      collisionPadding,
-      sticky,
-      hideWhenDetached,
-      updatePositionStrategy,
-      strategy,
-      dir,
-      preventScroll,
-      wrapperId,
-      style,
-      onPlaced,
-      customAnchor,
-      isStatic,
-      enabled,
-      onInteractOutside,
-      onCloseAutoFocus,
-      onOpenAutoFocus,
-      interactOutsideBehavior,
-      loop,
-      trapFocus,
-      isValidEvent,
-      onFocusOutside
-    },
-    restProps,
-    { forceMount: true }
-  ]));
-}
-function Select_content$1($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    const uid = props_id($$renderer2);
-    let {
-      id = createId(uid),
-      ref = null,
-      forceMount = false,
-      side = "bottom",
-      onInteractOutside = noop,
-      onEscapeKeydown = noop,
-      children,
-      child,
-      preventScroll = false,
-      style,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    const contentState = SelectContentState.create({
-      id: boxWith(() => id),
-      ref: boxWith(() => ref, (v) => ref = v),
-      onInteractOutside: boxWith(() => onInteractOutside),
-      onEscapeKeydown: boxWith(() => onEscapeKeydown)
-    });
-    const mergedProps = derived(() => mergeProps(restProps, contentState.props));
-    if (forceMount) {
-      $$renderer2.push("<!--[0-->");
-      {
-        let popper = function($$renderer3, { props, wrapperProps }) {
-          const finalProps = mergeProps(props, { style: contentState.props.style }, { style });
-          if (child) {
-            $$renderer3.push("<!--[0-->");
-            child($$renderer3, {
-              props: finalProps,
-              wrapperProps,
-              ...contentState.snippetProps
-            });
-            $$renderer3.push(`<!---->`);
-          } else {
-            $$renderer3.push("<!--[-1-->");
-            $$renderer3.push(`<div${attributes({ ...wrapperProps })}><div${attributes({ ...finalProps })}>`);
-            children?.($$renderer3);
-            $$renderer3.push(`<!----></div></div>`);
-          }
-          $$renderer3.push(`<!--]-->`);
-        };
-        Popper_layer_force_mount($$renderer2, spread_props([
-          mergedProps(),
-          contentState.popperProps,
-          {
-            ref: contentState.opts.ref,
-            side,
-            enabled: contentState.root.opts.open.current,
-            id,
-            preventScroll,
-            forceMount: true,
-            shouldRender: contentState.shouldRender,
-            popper,
-            $$slots: { popper: true }
-          }
-        ]));
-      }
-    } else if (!forceMount) {
-      $$renderer2.push("<!--[1-->");
-      {
-        let popper = function($$renderer3, { props, wrapperProps }) {
-          const finalProps = mergeProps(props, { style: contentState.props.style }, { style });
-          if (child) {
-            $$renderer3.push("<!--[0-->");
-            child($$renderer3, {
-              props: finalProps,
-              wrapperProps,
-              ...contentState.snippetProps
-            });
-            $$renderer3.push(`<!---->`);
-          } else {
-            $$renderer3.push("<!--[-1-->");
-            $$renderer3.push(`<div${attributes({ ...wrapperProps })}><div${attributes({ ...finalProps })}>`);
-            children?.($$renderer3);
-            $$renderer3.push(`<!----></div></div>`);
-          }
-          $$renderer3.push(`<!--]-->`);
-        };
-        Popper_layer($$renderer2, spread_props([
-          mergedProps(),
-          contentState.popperProps,
-          {
-            ref: contentState.opts.ref,
-            side,
-            open: contentState.root.opts.open.current,
-            id,
-            preventScroll,
-            forceMount: false,
-            shouldRender: contentState.shouldRender,
-            popper,
-            $$slots: { popper: true }
-          }
-        ]));
-      }
-    } else {
-      $$renderer2.push("<!--[-1-->");
-    }
-    $$renderer2.push(`<!--]-->`);
-    bind_props($$props, { ref });
-  });
-}
-function Mounted($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let { mounted = false, onMountedChange = noop } = $$props;
-    bind_props($$props, { mounted });
-  });
-}
-function Select_item$1($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    const uid = props_id($$renderer2);
-    let {
-      id = createId(uid),
-      ref = null,
-      value,
-      label = value,
-      disabled = false,
-      children,
-      child,
-      onHighlight = noop,
-      onUnhighlight = noop,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    const itemState = SelectItemState.create({
-      id: boxWith(() => id),
-      ref: boxWith(() => ref, (v) => ref = v),
-      value: boxWith(() => value),
-      disabled: boxWith(() => disabled),
-      label: boxWith(() => label),
-      onHighlight: boxWith(() => onHighlight),
-      onUnhighlight: boxWith(() => onUnhighlight)
-    });
-    const mergedProps = derived(() => mergeProps(restProps, itemState.props));
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      if (child) {
-        $$renderer3.push("<!--[0-->");
-        child($$renderer3, { props: mergedProps(), ...itemState.snippetProps });
-        $$renderer3.push(`<!---->`);
-      } else {
-        $$renderer3.push("<!--[-1-->");
-        $$renderer3.push(`<div${attributes({ ...mergedProps() })}>`);
-        children?.($$renderer3, itemState.snippetProps);
-        $$renderer3.push(`<!----></div>`);
-      }
-      $$renderer3.push(`<!--]--> `);
-      Mounted($$renderer3, {
-        get mounted() {
-          return itemState.mounted;
-        },
-        set mounted($$value) {
-          itemState.mounted = $$value;
-          $$settled = false;
-        }
-      });
-      $$renderer3.push(`<!---->`);
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { ref });
-  });
-}
-function Select_viewport($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    const uid = props_id($$renderer2);
-    let {
-      id = createId(uid),
-      ref = null,
-      children,
-      child,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    const viewportState = SelectViewportState.create({
-      id: boxWith(() => id),
-      ref: boxWith(() => ref, (v) => ref = v)
-    });
-    const mergedProps = derived(() => mergeProps(restProps, viewportState.props));
-    if (child) {
-      $$renderer2.push("<!--[0-->");
-      child($$renderer2, { props: mergedProps() });
-      $$renderer2.push(`<!---->`);
-    } else {
-      $$renderer2.push("<!--[-1-->");
-      $$renderer2.push(`<div${attributes({ ...mergedProps() })}>`);
-      children?.($$renderer2);
-      $$renderer2.push(`<!----></div>`);
-    }
-    $$renderer2.push(`<!--]-->`);
-    bind_props($$props, { ref });
-  });
-}
-function Select_scroll_down_button$1($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    const uid = props_id($$renderer2);
-    let {
-      id = createId(uid),
-      ref = null,
-      delay = () => 50,
-      child,
-      children,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    const scrollButtonState = SelectScrollDownButtonState.create({
-      id: boxWith(() => id),
-      ref: boxWith(() => ref, (v) => ref = v),
-      delay: boxWith(() => delay)
-    });
-    const mergedProps = derived(() => mergeProps(restProps, scrollButtonState.props));
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      if (scrollButtonState.canScrollDown) {
-        $$renderer3.push("<!--[0-->");
-        Mounted($$renderer3, {
-          get mounted() {
-            return scrollButtonState.scrollButtonState.mounted;
-          },
-          set mounted($$value) {
-            scrollButtonState.scrollButtonState.mounted = $$value;
-            $$settled = false;
-          }
-        });
-        $$renderer3.push(`<!----> `);
-        if (child) {
-          $$renderer3.push("<!--[0-->");
-          child($$renderer3, { props: restProps });
-          $$renderer3.push(`<!---->`);
-        } else {
-          $$renderer3.push("<!--[-1-->");
-          $$renderer3.push(`<div${attributes({ ...mergedProps() })}>`);
-          children?.($$renderer3);
-          $$renderer3.push(`<!----></div>`);
-        }
-        $$renderer3.push(`<!--]-->`);
-      } else {
-        $$renderer3.push("<!--[-1-->");
-      }
-      $$renderer3.push(`<!--]-->`);
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { ref });
-  });
-}
-function Select_scroll_up_button$1($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    const uid = props_id($$renderer2);
-    let {
-      id = createId(uid),
-      ref = null,
-      delay = () => 50,
-      child,
-      children,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    const scrollButtonState = SelectScrollUpButtonState.create({
-      id: boxWith(() => id),
-      ref: boxWith(() => ref, (v) => ref = v),
-      delay: boxWith(() => delay)
-    });
-    const mergedProps = derived(() => mergeProps(restProps, scrollButtonState.props));
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      if (scrollButtonState.canScrollUp) {
-        $$renderer3.push("<!--[0-->");
-        Mounted($$renderer3, {
-          get mounted() {
-            return scrollButtonState.scrollButtonState.mounted;
-          },
-          set mounted($$value) {
-            scrollButtonState.scrollButtonState.mounted = $$value;
-            $$settled = false;
-          }
-        });
-        $$renderer3.push(`<!----> `);
-        if (child) {
-          $$renderer3.push("<!--[0-->");
-          child($$renderer3, { props: restProps });
-          $$renderer3.push(`<!---->`);
-        } else {
-          $$renderer3.push("<!--[-1-->");
-          $$renderer3.push(`<div${attributes({ ...mergedProps() })}>`);
-          children?.($$renderer3);
-          $$renderer3.push(`<!----></div>`);
-        }
-        $$renderer3.push(`<!--]-->`);
-      } else {
-        $$renderer3.push("<!--[-1-->");
-      }
-      $$renderer3.push(`<!--]-->`);
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { ref });
-  });
-}
-function Select($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let {
-      value = void 0,
-      onValueChange = noop,
-      name = "",
-      disabled = false,
-      type,
-      open = false,
-      onOpenChange = noop,
-      onOpenChangeComplete = noop,
-      loop = false,
-      scrollAlignment = "nearest",
-      required = false,
-      items = [],
-      allowDeselect = false,
-      autocomplete,
-      children
-    } = $$props;
-    function handleDefaultValue() {
-      if (value !== void 0) return;
-      value = type === "single" ? "" : [];
-    }
-    handleDefaultValue();
-    watch.pre(() => value, () => {
-      handleDefaultValue();
-    });
-    let inputValue = "";
-    const rootState = SelectRootState.create({
-      type,
-      value: boxWith(() => value, (v) => {
-        value = v;
-        onValueChange(v);
-      }),
-      disabled: boxWith(() => disabled),
-      required: boxWith(() => required),
-      open: boxWith(() => open, (v) => {
-        open = v;
-        onOpenChange(v);
-      }),
-      loop: boxWith(() => loop),
-      scrollAlignment: boxWith(() => scrollAlignment),
-      name: boxWith(() => name),
-      isCombobox: false,
-      items: boxWith(() => items),
-      allowDeselect: boxWith(() => allowDeselect),
-      inputValue: boxWith(() => inputValue, (v) => inputValue = v),
-      onOpenChangeComplete: boxWith(() => onOpenChangeComplete)
-    });
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      Floating_layer($$renderer3, {
-        children: ($$renderer4) => {
-          children?.($$renderer4);
-          $$renderer4.push(`<!---->`);
-        }
-      });
-      $$renderer3.push(`<!----> `);
-      if (Array.isArray(rootState.opts.value.current)) {
-        $$renderer3.push("<!--[0-->");
-        if (rootState.opts.value.current.length === 0) {
-          $$renderer3.push("<!--[0-->");
-          Select_hidden_input($$renderer3, { autocomplete });
-        } else {
-          $$renderer3.push("<!--[-1-->");
-          $$renderer3.push(`<!--[-->`);
-          const each_array = ensure_array_like(rootState.opts.value.current);
-          for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
-            let item = each_array[$$index];
-            Select_hidden_input($$renderer3, { value: item, autocomplete });
-          }
-          $$renderer3.push(`<!--]-->`);
-        }
-        $$renderer3.push(`<!--]-->`);
-      } else {
-        $$renderer3.push("<!--[-1-->");
-        Select_hidden_input($$renderer3, {
-          autocomplete,
-          get value() {
-            return rootState.opts.value.current;
-          },
-          set value($$value) {
-            rootState.opts.value.current = $$value;
-            $$settled = false;
-          }
-        });
-      }
-      $$renderer3.push(`<!--]-->`);
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { value, open });
-  });
-}
-function Select_trigger$1($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    const uid = props_id($$renderer2);
-    let {
-      id = createId(uid),
-      ref = null,
-      child,
-      children,
-      type = "button",
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    const triggerState = SelectTriggerState.create({
-      id: boxWith(() => id),
-      ref: boxWith(() => ref, (v) => ref = v)
-    });
-    const mergedProps = derived(() => mergeProps(restProps, triggerState.props, { type }));
-    if (Floating_layer_anchor) {
-      $$renderer2.push("<!--[-->");
-      Floating_layer_anchor($$renderer2, {
-        id,
-        ref: triggerState.opts.ref,
-        children: ($$renderer3) => {
-          if (child) {
-            $$renderer3.push("<!--[0-->");
-            child($$renderer3, { props: mergedProps() });
-            $$renderer3.push(`<!---->`);
-          } else {
-            $$renderer3.push("<!--[-1-->");
-            $$renderer3.push(`<button${attributes({ ...mergedProps() })}>`);
-            children?.($$renderer3);
-            $$renderer3.push(`<!----></button>`);
-          }
-          $$renderer3.push(`<!--]-->`);
-        }
-      });
-      $$renderer2.push("<!--]-->");
-    } else {
-      $$renderer2.push("<!--[!-->");
-      $$renderer2.push("<!--]-->");
-    }
-    bind_props($$props, { ref });
-  });
-}
-function Select_item($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let {
-      ref = null,
-      class: className,
-      value,
-      label,
-      children: childrenProp,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      {
-        let children = function($$renderer4, { selected, highlighted }) {
-          $$renderer4.push(`<span class="right-2 size-3.5 absolute flex items-center justify-center">`);
-          if (selected) {
-            $$renderer4.push("<!--[0-->");
-            Check($$renderer4, { class: "size-4" });
-          } else {
-            $$renderer4.push("<!--[-1-->");
-          }
-          $$renderer4.push(`<!--]--></span> `);
-          if (childrenProp) {
-            $$renderer4.push("<!--[0-->");
-            childrenProp($$renderer4, { selected, highlighted });
-            $$renderer4.push(`<!---->`);
-          } else {
-            $$renderer4.push("<!--[-1-->");
-            $$renderer4.push(`${escape_html(label || value)}`);
-          }
-          $$renderer4.push(`<!--]-->`);
-        };
-        if (Select_item$1) {
-          $$renderer3.push("<!--[-->");
-          Select_item$1($$renderer3, spread_props([
-            {
-              value,
-              "data-slot": "select-item",
-              class: cn("gap-2 py-1.5 pr-8 pl-2 text-sm [&_svg:not([class*='size-'])]:size-4 *:[span]:last:gap-2 relative flex w-full cursor-default items-center rounded-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[highlighted]:bg-accent data-[highlighted]:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='text-'])]:text-muted-foreground *:[span]:last:flex *:[span]:last:items-center", className)
-            },
-            restProps,
-            {
-              get ref() {
-                return ref;
-              },
-              set ref($$value) {
-                ref = $$value;
-                $$settled = false;
-              },
-              children,
-              $$slots: { default: true }
-            }
-          ]));
-          $$renderer3.push("<!--]-->");
-        } else {
-          $$renderer3.push("<!--[!-->");
-          $$renderer3.push("<!--]-->");
-        }
-      }
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { ref });
-  });
-}
-function Select_scroll_up_button($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let {
-      ref = null,
-      class: className,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      if (Select_scroll_up_button$1) {
-        $$renderer3.push("<!--[-->");
-        Select_scroll_up_button$1($$renderer3, spread_props([
-          {
-            "data-slot": "select-scroll-up-button",
-            class: cn("py-1 flex cursor-default items-center justify-center", className)
-          },
-          restProps,
-          {
-            get ref() {
-              return ref;
-            },
-            set ref($$value) {
-              ref = $$value;
-              $$settled = false;
-            },
-            children: ($$renderer4) => {
-              Chevron_up($$renderer4, { class: "size-4" });
-            },
-            $$slots: { default: true }
-          }
-        ]));
-        $$renderer3.push("<!--]-->");
-      } else {
-        $$renderer3.push("<!--[!-->");
-        $$renderer3.push("<!--]-->");
-      }
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { ref });
-  });
-}
-function Select_scroll_down_button($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let {
-      ref = null,
-      class: className,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      if (Select_scroll_down_button$1) {
-        $$renderer3.push("<!--[-->");
-        Select_scroll_down_button$1($$renderer3, spread_props([
-          {
-            "data-slot": "select-scroll-down-button",
-            class: cn("py-1 flex cursor-default items-center justify-center", className)
-          },
-          restProps,
-          {
-            get ref() {
-              return ref;
-            },
-            set ref($$value) {
-              ref = $$value;
-              $$settled = false;
-            },
-            children: ($$renderer4) => {
-              Chevron_down($$renderer4, { class: "size-4" });
-            },
-            $$slots: { default: true }
-          }
-        ]));
-        $$renderer3.push("<!--]-->");
-      } else {
-        $$renderer3.push("<!--[!-->");
-        $$renderer3.push("<!--]-->");
-      }
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { ref });
-  });
-}
-function Select_content($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let {
-      ref = null,
-      class: className,
-      sideOffset = 4,
-      portalProps,
-      children,
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      if (Portal) {
-        $$renderer3.push("<!--[-->");
-        Portal($$renderer3, spread_props([
-          portalProps,
-          {
-            children: ($$renderer4) => {
-              if (Select_content$1) {
-                $$renderer4.push("<!--[-->");
-                Select_content$1($$renderer4, spread_props([
-                  {
-                    sideOffset,
-                    "data-slot": "select-content",
-                    class: cn("shadow-md data-[side=bottom]:translate-y-1 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:-translate-x-1 data-[side=left]:slide-in-from-right-2 data-[side=right]:translate-x-1 data-[side=right]:slide-in-from-left-2 data-[side=top]:-translate-y-1 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95 relative z-50 max-h-(--bits-select-content-available-height) min-w-[8rem] origin-(--bits-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border bg-popover text-popover-foreground", className)
-                  },
-                  restProps,
-                  {
-                    get ref() {
-                      return ref;
-                    },
-                    set ref($$value) {
-                      ref = $$value;
-                      $$settled = false;
-                    },
-                    children: ($$renderer5) => {
-                      Select_scroll_up_button($$renderer5, {});
-                      $$renderer5.push(`<!----> `);
-                      if (Select_viewport) {
-                        $$renderer5.push("<!--[-->");
-                        Select_viewport($$renderer5, {
-                          class: cn("scroll-my-1 p-1 h-(--bits-select-anchor-height) w-full min-w-(--bits-select-anchor-width)"),
-                          children: ($$renderer6) => {
-                            children?.($$renderer6);
-                            $$renderer6.push(`<!---->`);
-                          },
-                          $$slots: { default: true }
-                        });
-                        $$renderer5.push("<!--]-->");
-                      } else {
-                        $$renderer5.push("<!--[!-->");
-                        $$renderer5.push("<!--]-->");
-                      }
-                      $$renderer5.push(` `);
-                      Select_scroll_down_button($$renderer5, {});
-                      $$renderer5.push(`<!---->`);
-                    },
-                    $$slots: { default: true }
-                  }
-                ]));
-                $$renderer4.push("<!--]-->");
-              } else {
-                $$renderer4.push("<!--[!-->");
-                $$renderer4.push("<!--]-->");
-              }
-            },
-            $$slots: { default: true }
-          }
-        ]));
-        $$renderer3.push("<!--]-->");
-      } else {
-        $$renderer3.push("<!--[!-->");
-        $$renderer3.push("<!--]-->");
-      }
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { ref });
-  });
-}
-function Select_trigger($$renderer, $$props) {
-  $$renderer.component(($$renderer2) => {
-    let {
-      ref = null,
-      class: className,
-      children,
-      size: size2 = "default",
-      $$slots,
-      $$events,
-      ...restProps
-    } = $$props;
-    let $$settled = true;
-    let $$inner_renderer;
-    function $$render_inner($$renderer3) {
-      if (Select_trigger$1) {
-        $$renderer3.push("<!--[-->");
-        Select_trigger$1($$renderer3, spread_props([
-          {
-            "data-slot": "select-trigger",
-            "data-size": size2,
-            class: cn("gap-2 px-3 py-2 text-sm shadow-xs data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:gap-2 [&_svg:not([class*='size-'])]:size-4 flex w-fit items-center justify-between rounded-md border border-input bg-transparent whitespace-nowrap transition-[color,box-shadow] outline-none select-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 data-[placeholder]:text-muted-foreground *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='text-'])]:text-muted-foreground", className)
-          },
-          restProps,
-          {
-            get ref() {
-              return ref;
-            },
-            set ref($$value) {
-              ref = $$value;
-              $$settled = false;
-            },
-            children: ($$renderer4) => {
-              children?.($$renderer4);
-              $$renderer4.push(`<!----> `);
-              Chevron_down($$renderer4, { class: "size-4 opacity-50" });
-              $$renderer4.push(`<!---->`);
-            },
-            $$slots: { default: true }
-          }
-        ]));
-        $$renderer3.push("<!--]-->");
-      } else {
-        $$renderer3.push("<!--[!-->");
-        $$renderer3.push("<!--]-->");
-      }
-    }
-    do {
-      $$settled = true;
-      $$inner_renderer = $$renderer2.copy();
-      $$render_inner($$inner_renderer);
-    } while (!$$settled);
-    $$renderer2.subsume($$inner_renderer);
-    bind_props($$props, { ref });
-  });
-}
-const Root = Select;
-
-export { Floating_layer as F, Hidden_input as H, Popper_layer_force_mount as P, Root as R, Select_trigger as S, Select_content as a, Select_item as b, Floating_layer_anchor as c, Popper_layer as d, getFloatingContentCSSVars as g, isFunction as i };
-//# sourceMappingURL=index5.js-DtflJpxD.js.map