@selvajs/selva 2.0.11 → 4.0.0

package/build/server/chunks/index3-AGemCGcn.js

@@ -0,0 +1,4388 @@
+import { q as bind_props, Q as ensure_array_like, I as derived, aA as spread_props, p as attributes, an as props_id, T as escape_html } from './renderer-x4cX3Aau.js';
+import { c as cn } from './utils3-B05Dmz_H.js';
+import { x as styleToString, k as createBitsAttrs, h as boxWith, w as simpleBox, e as boolToTrueOrUndef, v as mergeProps, l as createId, a as attachRef, b as boolToEmptyStrOrUndef, p as getDataOpenClosed, c as boolToStr, q as getDataTransitionAttrs, g as boxFrom, d as boolToStrTrueOrUndef, m as cssToStyleObj } from './create-id-B-AKukLt.js';
+import { n as noop, w as watch, C as Context, c as ARROW_UP, A as ARROW_DOWN, d as ENTER, S as SPACE, T as TAB, f as PAGE_UP, H as HOME, P as PAGE_DOWN, E as END, l as isNotNull, g as defaultWindow, k as isIOS } from './noop-iPXixleG.js';
+import { I as Icon } from './Icon-DbkwAOkZ.js';
+import { C as Chevron_down } from './chevron-down-Cqowxf45.js';
+import { d as afterTick, D as DOMContext, b as PresenceManager, P as Portal, c as afterSleep, u as useId, g as getWindow$1, S as Scroll_lock, F as Focus_scope, E as Escape_layer, a as Dismissible_layer, T as Text_selection_layer } from './scroll-lock-BVxv0Dsn.js';
+import 'clsx';
+import { c as createSubscriber } from './index-server-DMc-UvjC.js';
+import { o as on } from './events-qfxQNxtp.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 isValidIndex(index, arr) {
+  return index >= 0 && index < arr.length;
+}
+function next(array, index, loop = true) {
+  if (array.length === 0 || index < 0 || index >= array.length)
+    return;
+  if (array.length === 1 && index === 0)
+    return array[0];
+  if (index === array.length - 1)
+    return loop ? array[0] : void 0;
+  return array[index + 1];
+}
+function prev(array, index, loop = true) {
+  if (array.length === 0 || index < 0 || index >= array.length)
+    return;
+  if (array.length === 1 && index === 0)
+    return array[0];
+  if (index === 0)
+    return loop ? array[array.length - 1] : void 0;
+  return array[index - 1];
+}
+function forward(array, index, increment, loop = true) {
+  if (array.length === 0 || index < 0 || index >= array.length)
+    return;
+  let targetIndex = index + increment;
+  if (loop) {
+    targetIndex = (targetIndex % array.length + array.length) % array.length;
+  } else {
+    targetIndex = Math.max(0, Math.min(targetIndex, array.length - 1));
+  }
+  return array[targetIndex];
+}
+function backward(array, index, decrement, loop = true) {
+  if (array.length === 0 || index < 0 || index >= array.length)
+    return;
+  let targetIndex = index - decrement;
+  if (loop) {
+    targetIndex = (targetIndex % array.length + array.length) % array.length;
+  } else {
+    targetIndex = Math.max(0, Math.min(targetIndex, array.length - 1));
+  }
+  return array[targetIndex];
+}
+function getNextMatch(values, search, currentMatch) {
+  const lowerSearch = search.toLowerCase();
+  if (lowerSearch.endsWith(" ")) {
+    const searchWithoutSpace = lowerSearch.slice(0, -1);
+    const matchesWithoutSpace = values.filter((value) => value.toLowerCase().startsWith(searchWithoutSpace));
+    if (matchesWithoutSpace.length <= 1) {
+      return getNextMatch(values, searchWithoutSpace, currentMatch);
+    }
+    const currentMatchLowercase = currentMatch?.toLowerCase();
+    if (currentMatchLowercase && currentMatchLowercase.startsWith(searchWithoutSpace) && currentMatchLowercase.charAt(searchWithoutSpace.length) === " " && search.trim() === searchWithoutSpace) {
+      return currentMatch;
+    }
+    const spacedMatches = values.filter((value) => value.toLowerCase().startsWith(lowerSearch));
+    if (spacedMatches.length > 0) {
+      const currentMatchIndex2 = currentMatch ? values.indexOf(currentMatch) : -1;
+      let wrappedMatches = wrapArray(spacedMatches, Math.max(currentMatchIndex2, 0));
+      const nextMatch2 = wrappedMatches.find((match) => match !== currentMatch);
+      return nextMatch2 || currentMatch;
+    }
+  }
+  const isRepeated = search.length > 1 && Array.from(search).every((char) => char === search[0]);
+  const normalizedSearch = isRepeated ? search[0] : search;
+  const normalizedLowerSearch = normalizedSearch.toLowerCase();
+  const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
+  let wrappedValues = wrapArray(values, Math.max(currentMatchIndex, 0));
+  const excludeCurrentMatch = normalizedSearch.length === 1;
+  if (excludeCurrentMatch)
+    wrappedValues = wrappedValues.filter((v) => v !== currentMatch);
+  const nextMatch = wrappedValues.find((value) => value?.toLowerCase().startsWith(normalizedLowerSearch));
+  return nextMatch !== currentMatch ? nextMatch : void 0;
+}
+function wrapArray(array, startIndex) {
+  return array.map((_, index) => array[(startIndex + index) % array.length]);
+}
+const defaultOptions = { afterMs: 1e4, onChange: noop };
+function boxAutoReset(defaultValue, options) {
+  const { afterMs, onChange, getWindow: getWindow2 } = { ...defaultOptions, ...options };
+  let timeout = null;
+  let value = defaultValue;
+  function resetAfter() {
+    return getWindow2().setTimeout(
+      () => {
+        value = defaultValue;
+        onChange?.(defaultValue);
+      },
+      afterMs
+    );
+  }
+  return boxWith(() => value, (v) => {
+    value = v;
+    onChange?.(v);
+    if (timeout) getWindow2().clearTimeout(timeout);
+    timeout = resetAfter();
+  });
+}
+class DOMTypeahead {
+  #opts;
+  #search;
+  #onMatch = derived(() => {
+    if (this.#opts.onMatch) return this.#opts.onMatch;
+    return (node) => node.focus();
+  });
+  #getCurrentItem = derived(() => {
+    if (this.#opts.getCurrentItem) return this.#opts.getCurrentItem;
+    return this.#opts.getActiveElement;
+  });
+  constructor(opts) {
+    this.#opts = opts;
+    this.#search = boxAutoReset("", { afterMs: 1e3, getWindow: opts.getWindow });
+    this.handleTypeaheadSearch = this.handleTypeaheadSearch.bind(this);
+    this.resetTypeahead = this.resetTypeahead.bind(this);
+  }
+  handleTypeaheadSearch(key, candidates) {
+    if (!candidates.length) return;
+    this.#search.current = this.#search.current + key;
+    const currentItem = this.#getCurrentItem()();
+    const currentMatch = candidates.find((item) => item === currentItem)?.textContent?.trim() ?? "";
+    const values = candidates.map((item) => item.textContent?.trim() ?? "");
+    const nextMatch = getNextMatch(values, this.#search.current, currentMatch);
+    const newItem = candidates.find((item) => item.textContent?.trim() === nextMatch);
+    if (newItem) this.#onMatch()(newItem);
+    return newItem;
+  }
+  resetTypeahead() {
+    this.#search.current = "";
+  }
+  get search() {
+    return this.#search.current;
+  }
+}
+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 Check($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconNode = [["path", { "d": "M20 6 9 17l-5-5" }]];
+  Icon($$renderer, spread_props([{ name: "check" }, props, { iconNode }]));
+}
+function Chevron_up($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconNode = [["path", { "d": "m18 15-6-6-6 6" }]];
+  Icon($$renderer, spread_props([{ name: "chevron-up" }, props, { iconNode }]));
+}
+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 { Check as C, Hidden_input as H, Root as R, Select_content as S, Select_item as a, Select_trigger as b, isValidIndex as c, isFunction as i };
+//# sourceMappingURL=index3-AGemCGcn.js.map