@altinn/altinn-components 0.52.2 → 0.52.4

package/dist/textfield-B_OMMEbF.js

@@ -0,0 +1,1442 @@
+"use client";
+import * as le from "react";
+import xe, { forwardRef as w, useState as A, useRef as F, useEffect as D, createContext as se, useContext as R, useMemo as J, useId as Q, isValidElement as Et, memo as It, useCallback as St, Children as Be, version as kt } from "react";
+import { jsx as c, jsxs as _, Fragment as Se } from "react/jsx-runtime";
+import { c as E } from "./lite-1fxw3LjI.js";
+import { S as M, a as _t } from "./index-D7FJjvrv.js";
+import { C as q, u as ke, a as qe, o as ce, p as P, r as Ee, b as _e, i as Nt, c as Mt, d as zt, e as Tt, f as Rt, g as Pt, h as Dt, s as Ft, j as At, k as Ue, l as Lt, m as ae, F as Bt, n as Vt, q as $t, t as jt, v as Wt, w as Kt, x as Ht } from "./index-Dg71_7ad.js";
+import { flushSync as Xe } from "react-dom";
+import { S as qt, u as Ut } from "./spinner-0Qe_jRGB.js";
+import { V as Ne, u as Me, F as de, a as Xt, b as Yt, c as Ve } from "./index-z82sbSVU.js";
+import { P as Ie } from "./paragraph-BRiIBpbY.js";
+import { I as ue } from "./input-wBv_FkEV.js";
+import { S as Gt } from "./XMark-tKk6aExO.js";
+import { S as Jt, a as Qt } from "./ChevronUp-_BBfEirx.js";
+import { L as K } from "./label-xTmTyPhk.js";
+import { u as Zt } from "./useId-BVFxCjkq.js";
+import { S as en } from "./Checkmark-Byz_C9x4.js";
+import { B as he } from "./button-MzZgmHyA.js";
+import { u as U } from "./use-merge-refs-Cj4kTYVj.js";
+import { T as tn } from "./textarea-BBstVlPT.js";
+var nn = function(o, s) {
+  var e = {};
+  for (var t in o) Object.prototype.hasOwnProperty.call(o, t) && s.indexOf(t) < 0 && (e[t] = o[t]);
+  if (o != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var n = 0, t = Object.getOwnPropertySymbols(o); n < t.length; n++)
+      s.indexOf(t[n]) < 0 && Object.prototype.propertyIsEnumerable.call(o, t[n]) && (e[t[n]] = o[t[n]]);
+  return e;
+};
+const on = w((o, s) => {
+  var { title: e, titleId: t } = o, n = nn(o, ["title", "titleId"]);
+  let i = Zt();
+  return i = e ? t || "title-" + i : void 0, xe.createElement(
+    "svg",
+    Object.assign({ xmlns: "http://www.w3.org/2000/svg", width: "1em", height: "1em", fill: "none", viewBox: "0 0 24 24", focusable: !1, role: "img", ref: s, "aria-labelledby": i }, n),
+    e ? xe.createElement("title", { id: i }, e) : null,
+    xe.createElement("path", { fill: "currentColor", fillRule: "evenodd", d: "M12 2.25A4.75 4.75 0 0 0 7.25 7v2.25H7A1.75 1.75 0 0 0 5.25 11v9c0 .414.336.75.75.75h12a.75.75 0 0 0 .75-.75v-9A1.75 1.75 0 0 0 17 9.25h-.25V7A4.75 4.75 0 0 0 12 2.25m3.25 7V7a3.25 3.25 0 0 0-6.5 0v2.25zM12 13a1.5 1.5 0 0 0-.75 2.8V17a.75.75 0 0 0 1.5 0v-1.2A1.5 1.5 0 0 0 12 13", clipRule: "evenodd" })
+  );
+}), Ye = se({
+  elements: { current: /* @__PURE__ */ new Map() },
+  getOrderedItems: () => [],
+  setFocusableValue: () => {
+  },
+  onShiftTab: () => {
+  },
+  focusableValue: null,
+  orientation: "horizontal"
+}), sn = w(({ activeValue: o, asChild: s, orientation: e = "horizontal", onBlur: t, onFocus: n, ...i }, r) => {
+  const a = s ? M : "div", l = o ?? null, [d, h] = A(l), [p, u] = A(!1), f = F(/* @__PURE__ */ new Map()), g = F(null), y = U([r, g]), C = () => {
+    if (!g.current)
+      return [];
+    const b = Array.from(g.current.querySelectorAll("[data-roving-tabindex-item]"));
+    return Array.from(f.current).sort((m, v) => b.indexOf(m[1]) - b.indexOf(v[1])).map(([m, v]) => ({ value: m, element: v }));
+  };
+  return D(() => {
+    h(l);
+  }, [l]), c(Ye.Provider, { value: {
+    elements: f,
+    getOrderedItems: C,
+    focusableValue: d,
+    setFocusableValue: h,
+    onShiftTab: () => {
+      u(!0);
+    },
+    orientation: e
+  }, children: c(a, { ...i, tabIndex: p ? -1 : 0, onBlur: (b) => {
+    t?.(b), u(!1), h(o ?? null);
+  }, onFocus: (b) => {
+    if (n?.(b), b.target !== b.currentTarget)
+      return;
+    const m = C();
+    m.length !== 0 && (d != null ? f.current.get(d)?.focus() : o != null ? f.current.get(o)?.focus() : m.at(0)?.element.focus());
+  }, ref: y }) });
+}), rn = (o) => {
+  const { elements: s, getOrderedItems: e, setFocusableValue: t, focusableValue: n, onShiftTab: i, orientation: r } = R(Ye);
+  return {
+    getOrderedItems: e,
+    isFocusable: n === o,
+    orientation: r,
+    getRovingProps: (a) => ({
+      ...a,
+      ref: (l) => {
+        l ? s.current.set(o, l) : s.current.delete(o);
+      },
+      onKeyDown: (l) => {
+        if (a?.onKeyDown?.(l), l.shiftKey && l.key === "Tab") {
+          i();
+          return;
+        }
+      },
+      onFocus: (l) => {
+        a?.onFocus?.(l), t(o);
+      },
+      "data-roving-tabindex-item": !0,
+      tabIndex: n === o ? 0 : -1
+    })
+  };
+};
+function we(o, s) {
+  const e = o.findIndex((t) => t.value === s);
+  return o.at(e === o.length - 1 ? 0 : e + 1);
+}
+function Oe(o, s) {
+  const e = o.findIndex((t) => t.value === s);
+  return o.at(e === 0 ? -1 : e - 1);
+}
+const an = w(({ value: o, asChild: s, ...e }, t) => {
+  const n = s ? M : "div", i = o ?? (typeof e.children == "string" ? e.children : ""), { getOrderedItems: r, getRovingProps: a, orientation: l } = rn(i), d = a({
+    onKeyDown: (p) => {
+      e?.onKeyDown?.(p);
+      const u = r();
+      let f;
+      switch (l) {
+        case "horizontal":
+          p.key === "ArrowRight" && (f = we(u, i)), p.key === "ArrowLeft" && (f = Oe(u, i));
+          break;
+        case "vertical":
+          p.key === "ArrowDown" && (f = we(u, i)), p.key === "ArrowUp" && (f = Oe(u, i));
+          break;
+        case "ambiguous":
+          ["ArrowRight", "ArrowDown"].includes(p.key) && (f = we(u, i)), ["ArrowLeft", "ArrowUp"].includes(p.key) && (f = Oe(u, i));
+      }
+      p.key === "Home" && (f = u[0]), p.key === "End" && (f = u[u.length - 1]), f && (p.preventDefault(), f.element.focus());
+    }
+  }), h = U([t, d.ref]);
+  return c(n, { ...e, ...d, ref: h, children: e.children });
+}), ln = (o, s, e) => {
+  const t = (e - 1) / 2, n = Math.max(1, Math.min(Math.max(o - Math.floor(t), 1), s - e + 1)), i = Math.min(Math.max(o + Math.ceil(t), e), s), r = Array.from({ length: i + 1 - n }, (a, l) => l + n);
+  return e > 4 && n > 1 && r.splice(0, 2, 1, 0), e > 3 && i < s && r.splice(-2, 2, 0, s), r;
+}, po = ({ currentPage: o = 1, setCurrentPage: s, onChange: e, totalPages: t = 1, showPages: n = 7 }) => J(() => {
+  const i = o < t, r = o !== 1, a = (l) => (d) => {
+    if (l < 1 || l > t)
+      return d.preventDefault();
+    e?.(d, l), d.defaultPrevented || s?.(l);
+  };
+  return {
+    /** Number of steps */
+    pages: ln(o, t, n).map((l, d) => ({
+      /**
+       * Page number or "ellipsis" for the ellipsis item
+       */
+      page: l || "ellipsis",
+      /**
+       * Unique key for the item
+       */
+      itemKey: l ? `page-${l}` : `ellipsis-${d}`,
+      // React key utility
+      /**
+       * Properties to spread on Pagination.Button
+       */
+      buttonProps: l ? {
+        "aria-current": l === o ? "page" : void 0,
+        onClick: a(l),
+        variant: l === o ? "primary" : "tertiary"
+      } : null
+    })),
+    /** Properties to spread on Pagination.Button used for previous naviagation */
+    prevButtonProps: {
+      "aria-hidden": !r,
+      // Using aria-hidden to support all HTML elements because of potential asChild
+      onClick: a(o - 1),
+      variant: "tertiary"
+    },
+    /** Properties to spread on Pagination.Button used for next naviagation */
+    nextButtonProps: {
+      "aria-hidden": !i,
+      // Using aria-hidden to support all HTML elements because of potential asChild
+      onClick: a(o + 1),
+      variant: "tertiary"
+    },
+    /** Indication if previous page action should be shown or not */
+    hasPrev: r,
+    /** Indication if next page action should be shown or not */
+    hasNext: i
+  };
+}, [o, t, n]), cn = w(function({ className: s, count: e, maxCount: t, variant: n = "base", ...i }, r) {
+  return c("span", { className: E("ds-badge", s), "data-count": e && t && e > t ? `${t}+` : e, "data-variant": n, ref: r, ...i });
+}), dn = w(function({ className: s, overlap: e = "rectangle", placement: t = "top-right", ...n }, i) {
+  return c("span", { className: E("ds-badge--position", s), "data-overlap": e, "data-placement": t, ref: i, ...n });
+}), un = Object.assign(cn, { Position: dn });
+un.Position.displayName = "Badge.Position";
+const hn = w(({ asChild: o, className: s, ...e }, t) => c(o ? M : "a", { className: E("ds-link", s), ref: t, ...e }));
+hn.displayName = "Link";
+function G(o, s, e) {
+  let t = e.initialDeps ?? [], n, i = !0;
+  function r() {
+    var a, l, d;
+    let h;
+    e.key && ((a = e.debug) != null && a.call(e)) && (h = Date.now());
+    const p = o();
+    if (!(p.length !== t.length || p.some((g, y) => t[y] !== g)))
+      return n;
+    t = p;
+    let f;
+    if (e.key && ((l = e.debug) != null && l.call(e)) && (f = Date.now()), n = s(...p), e.key && ((d = e.debug) != null && d.call(e))) {
+      const g = Math.round((Date.now() - h) * 100) / 100, y = Math.round((Date.now() - f) * 100) / 100, C = y / 16, b = (m, v) => {
+        for (m = String(m); m.length < v; )
+          m = " " + m;
+        return m;
+      };
+      console.info(
+        `%c⏱ ${b(y, 5)} /${b(g, 5)} ms`,
+        `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(
+          0,
+          Math.min(120 - 120 * C, 120)
+        )}deg 100% 31%);`,
+        e?.key
+      );
+    }
+    return e?.onChange && !(i && e.skipInitialOnChange) && e.onChange(n), i = !1, n;
+  }
+  return r.updateDeps = (a) => {
+    t = a;
+  }, r;
+}
+function $e(o, s) {
+  if (o === void 0)
+    throw new Error("Unexpected undefined");
+  return o;
+}
+const fn = (o, s) => Math.abs(o - s) < 1.01, mn = (o, s, e) => {
+  let t;
+  return function(...n) {
+    o.clearTimeout(t), t = o.setTimeout(() => s.apply(this, n), e);
+  };
+}, je = (o) => {
+  const { offsetWidth: s, offsetHeight: e } = o;
+  return { width: s, height: e };
+}, pn = (o) => o, bn = (o) => {
+  const s = Math.max(o.startIndex - o.overscan, 0), e = Math.min(o.endIndex + o.overscan, o.count - 1), t = [];
+  for (let n = s; n <= e; n++)
+    t.push(n);
+  return t;
+}, gn = (o, s) => {
+  const e = o.scrollElement;
+  if (!e)
+    return;
+  const t = o.targetWindow;
+  if (!t)
+    return;
+  const n = (r) => {
+    const { width: a, height: l } = r;
+    s({ width: Math.round(a), height: Math.round(l) });
+  };
+  if (n(je(e)), !t.ResizeObserver)
+    return () => {
+    };
+  const i = new t.ResizeObserver((r) => {
+    const a = () => {
+      const l = r[0];
+      if (l?.borderBoxSize) {
+        const d = l.borderBoxSize[0];
+        if (d) {
+          n({ width: d.inlineSize, height: d.blockSize });
+          return;
+        }
+      }
+      n(je(e));
+    };
+    o.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(a) : a();
+  });
+  return i.observe(e, { box: "border-box" }), () => {
+    i.unobserve(e);
+  };
+}, We = {
+  passive: !0
+}, Ke = typeof window > "u" ? !0 : "onscrollend" in window, vn = (o, s) => {
+  const e = o.scrollElement;
+  if (!e)
+    return;
+  const t = o.targetWindow;
+  if (!t)
+    return;
+  let n = 0;
+  const i = o.options.useScrollendEvent && Ke ? () => {
+  } : mn(
+    t,
+    () => {
+      s(n, !1);
+    },
+    o.options.isScrollingResetDelay
+  ), r = (h) => () => {
+    const { horizontal: p, isRtl: u } = o.options;
+    n = p ? e.scrollLeft * (u && -1 || 1) : e.scrollTop, i(), s(n, h);
+  }, a = r(!0), l = r(!1);
+  e.addEventListener("scroll", a, We);
+  const d = o.options.useScrollendEvent && Ke;
+  return d && e.addEventListener("scrollend", l, We), () => {
+    e.removeEventListener("scroll", a), d && e.removeEventListener("scrollend", l);
+  };
+}, yn = (o, s, e) => {
+  if (s?.borderBoxSize) {
+    const t = s.borderBoxSize[0];
+    if (t)
+      return Math.round(
+        t[e.options.horizontal ? "inlineSize" : "blockSize"]
+      );
+  }
+  return o[e.options.horizontal ? "offsetWidth" : "offsetHeight"];
+}, Cn = (o, {
+  adjustments: s = 0,
+  behavior: e
+}, t) => {
+  var n, i;
+  const r = o + s;
+  (i = (n = t.scrollElement) == null ? void 0 : n.scrollTo) == null || i.call(n, {
+    [t.options.horizontal ? "left" : "top"]: r,
+    behavior: e
+  });
+};
+class xn {
+  constructor(s) {
+    this.unsubs = [], this.scrollElement = null, this.targetWindow = null, this.isScrolling = !1, this.currentScrollToIndex = null, this.measurementsCache = [], this.itemSizeCache = /* @__PURE__ */ new Map(), this.laneAssignments = /* @__PURE__ */ new Map(), this.pendingMeasuredCacheIndexes = [], this.prevLanes = void 0, this.lanesChangedFlag = !1, this.lanesSettling = !1, this.scrollRect = null, this.scrollOffset = null, this.scrollDirection = null, this.scrollAdjustments = 0, this.elementsCache = /* @__PURE__ */ new Map(), this.observer = /* @__PURE__ */ (() => {
+      let e = null;
+      const t = () => e || (!this.targetWindow || !this.targetWindow.ResizeObserver ? null : e = new this.targetWindow.ResizeObserver((n) => {
+        n.forEach((i) => {
+          const r = () => {
+            this._measureElement(i.target, i);
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(r) : r();
+        });
+      }));
+      return {
+        disconnect: () => {
+          var n;
+          (n = t()) == null || n.disconnect(), e = null;
+        },
+        observe: (n) => {
+          var i;
+          return (i = t()) == null ? void 0 : i.observe(n, { box: "border-box" });
+        },
+        unobserve: (n) => {
+          var i;
+          return (i = t()) == null ? void 0 : i.unobserve(n);
+        }
+      };
+    })(), this.range = null, this.setOptions = (e) => {
+      Object.entries(e).forEach(([t, n]) => {
+        typeof n > "u" && delete e[t];
+      }), this.options = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: pn,
+        rangeExtractor: bn,
+        onChange: () => {
+        },
+        measureElement: yn,
+        initialRect: { width: 0, height: 0 },
+        scrollMargin: 0,
+        gap: 0,
+        indexAttribute: "data-index",
+        initialMeasurementsCache: [],
+        lanes: 1,
+        isScrollingResetDelay: 150,
+        enabled: !0,
+        isRtl: !1,
+        useScrollendEvent: !1,
+        useAnimationFrameWithResizeObserver: !1,
+        ...e
+      };
+    }, this.notify = (e) => {
+      var t, n;
+      (n = (t = this.options).onChange) == null || n.call(t, this, e);
+    }, this.maybeNotify = G(
+      () => (this.calculateRange(), [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ]),
+      (e) => {
+        this.notify(e);
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "maybeNotify",
+        debug: () => this.options.debug,
+        initialDeps: [
+          this.isScrolling,
+          this.range ? this.range.startIndex : null,
+          this.range ? this.range.endIndex : null
+        ]
+      }
+    ), this.cleanup = () => {
+      this.unsubs.filter(Boolean).forEach((e) => e()), this.unsubs = [], this.observer.disconnect(), this.scrollElement = null, this.targetWindow = null;
+    }, this._didMount = () => () => {
+      this.cleanup();
+    }, this._willUpdate = () => {
+      var e;
+      const t = this.options.enabled ? this.options.getScrollElement() : null;
+      if (this.scrollElement !== t) {
+        if (this.cleanup(), !t) {
+          this.maybeNotify();
+          return;
+        }
+        this.scrollElement = t, this.scrollElement && "ownerDocument" in this.scrollElement ? this.targetWindow = this.scrollElement.ownerDocument.defaultView : this.targetWindow = ((e = this.scrollElement) == null ? void 0 : e.window) ?? null, this.elementsCache.forEach((n) => {
+          this.observer.observe(n);
+        }), this.unsubs.push(
+          this.options.observeElementRect(this, (n) => {
+            this.scrollRect = n, this.maybeNotify();
+          })
+        ), this.unsubs.push(
+          this.options.observeElementOffset(this, (n, i) => {
+            this.scrollAdjustments = 0, this.scrollDirection = i ? this.getScrollOffset() < n ? "forward" : "backward" : null, this.scrollOffset = n, this.isScrolling = i, this.maybeNotify();
+          })
+        ), this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        });
+      }
+    }, this.getSize = () => this.options.enabled ? (this.scrollRect = this.scrollRect ?? this.options.initialRect, this.scrollRect[this.options.horizontal ? "width" : "height"]) : (this.scrollRect = null, 0), this.getScrollOffset = () => this.options.enabled ? (this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset == "function" ? this.options.initialOffset() : this.options.initialOffset), this.scrollOffset) : (this.scrollOffset = null, 0), this.getFurthestMeasurement = (e, t) => {
+      const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+      for (let r = t - 1; r >= 0; r--) {
+        const a = e[r];
+        if (n.has(a.lane))
+          continue;
+        const l = i.get(
+          a.lane
+        );
+        if (l == null || a.end > l.end ? i.set(a.lane, a) : a.end < l.end && n.set(a.lane, !0), n.size === this.options.lanes)
+          break;
+      }
+      return i.size === this.options.lanes ? Array.from(i.values()).sort((r, a) => r.end === a.end ? r.index - a.index : r.end - a.end)[0] : void 0;
+    }, this.getMeasurementOptions = G(
+      () => [
+        this.options.count,
+        this.options.paddingStart,
+        this.options.scrollMargin,
+        this.options.getItemKey,
+        this.options.enabled,
+        this.options.lanes
+      ],
+      (e, t, n, i, r, a) => (this.prevLanes !== void 0 && this.prevLanes !== a && (this.lanesChangedFlag = !0), this.prevLanes = a, this.pendingMeasuredCacheIndexes = [], {
+        count: e,
+        paddingStart: t,
+        scrollMargin: n,
+        getItemKey: i,
+        enabled: r,
+        lanes: a
+      }),
+      {
+        key: !1
+      }
+    ), this.getMeasurements = G(
+      () => [this.getMeasurementOptions(), this.itemSizeCache],
+      ({ count: e, paddingStart: t, scrollMargin: n, getItemKey: i, enabled: r, lanes: a }, l) => {
+        if (!r)
+          return this.measurementsCache = [], this.itemSizeCache.clear(), this.laneAssignments.clear(), [];
+        if (this.laneAssignments.size > e)
+          for (const u of this.laneAssignments.keys())
+            u >= e && this.laneAssignments.delete(u);
+        this.lanesChangedFlag && (this.lanesChangedFlag = !1, this.lanesSettling = !0, this.measurementsCache = [], this.itemSizeCache.clear(), this.laneAssignments.clear(), this.pendingMeasuredCacheIndexes = []), this.measurementsCache.length === 0 && !this.lanesSettling && (this.measurementsCache = this.options.initialMeasurementsCache, this.measurementsCache.forEach((u) => {
+          this.itemSizeCache.set(u.key, u.size);
+        }));
+        const d = this.lanesSettling ? 0 : this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
+        this.pendingMeasuredCacheIndexes = [], this.lanesSettling && this.measurementsCache.length === e && (this.lanesSettling = !1);
+        const h = this.measurementsCache.slice(0, d), p = new Array(a).fill(
+          void 0
+        );
+        for (let u = 0; u < d; u++) {
+          const f = h[u];
+          f && (p[f.lane] = u);
+        }
+        for (let u = d; u < e; u++) {
+          const f = i(u), g = this.laneAssignments.get(u);
+          let y, C;
+          if (g !== void 0 && this.options.lanes > 1) {
+            y = g;
+            const x = p[y], O = x !== void 0 ? h[x] : void 0;
+            C = O ? O.end + this.options.gap : t + n;
+          } else {
+            const x = this.options.lanes === 1 ? h[u - 1] : this.getFurthestMeasurement(h, u);
+            C = x ? x.end + this.options.gap : t + n, y = x ? x.lane : u % this.options.lanes, this.options.lanes > 1 && this.laneAssignments.set(u, y);
+          }
+          const b = l.get(f), m = typeof b == "number" ? b : this.options.estimateSize(u), v = C + m;
+          h[u] = {
+            index: u,
+            start: C,
+            size: m,
+            end: v,
+            key: f,
+            lane: y
+          }, p[y] = u;
+        }
+        return this.measurementsCache = h, h;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getMeasurements",
+        debug: () => this.options.debug
+      }
+    ), this.calculateRange = G(
+      () => [
+        this.getMeasurements(),
+        this.getSize(),
+        this.getScrollOffset(),
+        this.options.lanes
+      ],
+      (e, t, n, i) => this.range = e.length > 0 && t > 0 ? wn({
+        measurements: e,
+        outerSize: t,
+        scrollOffset: n,
+        lanes: i
+      }) : null,
+      {
+        key: process.env.NODE_ENV !== "production" && "calculateRange",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualIndexes = G(
+      () => {
+        let e = null, t = null;
+        const n = this.calculateRange();
+        return n && (e = n.startIndex, t = n.endIndex), this.maybeNotify.updateDeps([this.isScrolling, e, t]), [
+          this.options.rangeExtractor,
+          this.options.overscan,
+          this.options.count,
+          e,
+          t
+        ];
+      },
+      (e, t, n, i, r) => i === null || r === null ? [] : e({
+        startIndex: i,
+        endIndex: r,
+        overscan: t,
+        count: n
+      }),
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+        debug: () => this.options.debug
+      }
+    ), this.indexFromElement = (e) => {
+      const t = this.options.indexAttribute, n = e.getAttribute(t);
+      return n ? parseInt(n, 10) : (console.warn(
+        `Missing attribute name '${t}={index}' on measured element.`
+      ), -1);
+    }, this._measureElement = (e, t) => {
+      const n = this.indexFromElement(e), i = this.measurementsCache[n];
+      if (!i)
+        return;
+      const r = i.key, a = this.elementsCache.get(r);
+      a !== e && (a && this.observer.unobserve(a), this.observer.observe(e), this.elementsCache.set(r, e)), e.isConnected && this.resizeItem(n, this.options.measureElement(e, t, this));
+    }, this.resizeItem = (e, t) => {
+      const n = this.measurementsCache[e];
+      if (!n)
+        return;
+      const i = this.itemSizeCache.get(n.key) ?? n.size, r = t - i;
+      r !== 0 && ((this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(n, r, this) : n.start < this.getScrollOffset() + this.scrollAdjustments) && (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", r), this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += r,
+        behavior: void 0
+      })), this.pendingMeasuredCacheIndexes.push(n.index), this.itemSizeCache = new Map(this.itemSizeCache.set(n.key, t)), this.notify(!1));
+    }, this.measureElement = (e) => {
+      if (!e) {
+        this.elementsCache.forEach((t, n) => {
+          t.isConnected || (this.observer.unobserve(t), this.elementsCache.delete(n));
+        });
+        return;
+      }
+      this._measureElement(e, void 0);
+    }, this.getVirtualItems = G(
+      () => [this.getVirtualIndexes(), this.getMeasurements()],
+      (e, t) => {
+        const n = [];
+        for (let i = 0, r = e.length; i < r; i++) {
+          const a = e[i], l = t[a];
+          n.push(l);
+        }
+        return n;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualItemForOffset = (e) => {
+      const t = this.getMeasurements();
+      if (t.length !== 0)
+        return $e(
+          t[Ge(
+            0,
+            t.length - 1,
+            (n) => $e(t[n]).start,
+            e
+          )]
+        );
+    }, this.getMaxScrollOffset = () => {
+      if (!this.scrollElement) return 0;
+      if ("scrollHeight" in this.scrollElement)
+        return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
+      {
+        const e = this.scrollElement.document.documentElement;
+        return this.options.horizontal ? e.scrollWidth - this.scrollElement.innerWidth : e.scrollHeight - this.scrollElement.innerHeight;
+      }
+    }, this.getOffsetForAlignment = (e, t, n = 0) => {
+      if (!this.scrollElement) return 0;
+      const i = this.getSize(), r = this.getScrollOffset();
+      t === "auto" && (t = e >= r + i ? "end" : "start"), t === "center" ? e += (n - i) / 2 : t === "end" && (e -= i);
+      const a = this.getMaxScrollOffset();
+      return Math.max(Math.min(a, e), 0);
+    }, this.getOffsetForIndex = (e, t = "auto") => {
+      e = Math.max(0, Math.min(e, this.options.count - 1));
+      const n = this.measurementsCache[e];
+      if (!n)
+        return;
+      const i = this.getSize(), r = this.getScrollOffset();
+      if (t === "auto")
+        if (n.end >= r + i - this.options.scrollPaddingEnd)
+          t = "end";
+        else if (n.start <= r + this.options.scrollPaddingStart)
+          t = "start";
+        else
+          return [r, t];
+      if (t === "end" && e === this.options.count - 1)
+        return [this.getMaxScrollOffset(), t];
+      const a = t === "end" ? n.end + this.options.scrollPaddingEnd : n.start - this.options.scrollPaddingStart;
+      return [
+        this.getOffsetForAlignment(a, t, n.size),
+        t
+      ];
+    }, this.isDynamicMode = () => this.elementsCache.size > 0, this.scrollToOffset = (e, { align: t = "start", behavior: n } = {}) => {
+      n === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), this._scrollToOffset(this.getOffsetForAlignment(e, t), {
+        adjustments: void 0,
+        behavior: n
+      });
+    }, this.scrollToIndex = (e, { align: t = "auto", behavior: n } = {}) => {
+      n === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), e = Math.max(0, Math.min(e, this.options.count - 1)), this.currentScrollToIndex = e;
+      let i = 0;
+      const r = 10, a = (d) => {
+        if (!this.targetWindow) return;
+        const h = this.getOffsetForIndex(e, d);
+        if (!h) {
+          console.warn("Failed to get offset for index:", e);
+          return;
+        }
+        const [p, u] = h;
+        this._scrollToOffset(p, { adjustments: void 0, behavior: n }), this.targetWindow.requestAnimationFrame(() => {
+          const f = () => {
+            if (this.currentScrollToIndex !== e) return;
+            const g = this.getScrollOffset(), y = this.getOffsetForIndex(e, u);
+            if (!y) {
+              console.warn("Failed to get offset for index:", e);
+              return;
+            }
+            fn(y[0], g) || l(u);
+          };
+          this.isDynamicMode() ? this.targetWindow.requestAnimationFrame(f) : f();
+        });
+      }, l = (d) => {
+        this.targetWindow && this.currentScrollToIndex === e && (i++, i < r ? (process.env.NODE_ENV !== "production" && this.options.debug && console.info("Schedule retry", i, r), this.targetWindow.requestAnimationFrame(() => a(d))) : console.warn(
+          `Failed to scroll to index ${e} after ${r} attempts.`
+        ));
+      };
+      a(t);
+    }, this.scrollBy = (e, { behavior: t } = {}) => {
+      t === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), this._scrollToOffset(this.getScrollOffset() + e, {
+        adjustments: void 0,
+        behavior: t
+      });
+    }, this.getTotalSize = () => {
+      var e;
+      const t = this.getMeasurements();
+      let n;
+      if (t.length === 0)
+        n = this.options.paddingStart;
+      else if (this.options.lanes === 1)
+        n = ((e = t[t.length - 1]) == null ? void 0 : e.end) ?? 0;
+      else {
+        const i = Array(this.options.lanes).fill(null);
+        let r = t.length - 1;
+        for (; r >= 0 && i.some((a) => a === null); ) {
+          const a = t[r];
+          i[a.lane] === null && (i[a.lane] = a.end), r--;
+        }
+        n = Math.max(...i.filter((a) => a !== null));
+      }
+      return Math.max(
+        n - this.options.scrollMargin + this.options.paddingEnd,
+        0
+      );
+    }, this._scrollToOffset = (e, {
+      adjustments: t,
+      behavior: n
+    }) => {
+      this.options.scrollToFn(e, { behavior: n, adjustments: t }, this);
+    }, this.measure = () => {
+      this.itemSizeCache = /* @__PURE__ */ new Map(), this.laneAssignments = /* @__PURE__ */ new Map(), this.notify(!1);
+    }, this.setOptions(s);
+  }
+}
+const Ge = (o, s, e, t) => {
+  for (; o <= s; ) {
+    const n = (o + s) / 2 | 0, i = e(n);
+    if (i < t)
+      o = n + 1;
+    else if (i > t)
+      s = n - 1;
+    else
+      return n;
+  }
+  return o > 0 ? o - 1 : 0;
+};
+function wn({
+  measurements: o,
+  outerSize: s,
+  scrollOffset: e,
+  lanes: t
+}) {
+  const n = o.length - 1, i = (l) => o[l].start;
+  if (o.length <= t)
+    return {
+      startIndex: 0,
+      endIndex: n
+    };
+  let r = Ge(
+    0,
+    n,
+    i,
+    e
+  ), a = r;
+  if (t === 1)
+    for (; a < n && o[a].end < e + s; )
+      a++;
+  else if (t > 1) {
+    const l = Array(t).fill(0);
+    for (; a < n && l.some((h) => h < e + s); ) {
+      const h = o[a];
+      l[h.lane] = h.end, a++;
+    }
+    const d = Array(t).fill(e + s);
+    for (; r >= 0 && d.some((h) => h >= e); ) {
+      const h = o[r];
+      d[h.lane] = h.start, r--;
+    }
+    r = Math.max(0, r - r % t), a = Math.min(n, a + (t - 1 - a % t));
+  }
+  return { startIndex: r, endIndex: a };
+}
+const He = typeof document < "u" ? le.useLayoutEffect : le.useEffect;
+function On({
+  useFlushSync: o = !0,
+  ...s
+}) {
+  const e = le.useReducer(() => ({}), {})[1], t = {
+    ...s,
+    onChange: (i, r) => {
+      var a;
+      o && r ? Xe(e) : e(), (a = s.onChange) == null || a.call(s, i, r);
+    }
+  }, [n] = le.useState(
+    () => new xn(t)
+  );
+  return n.setOptions(t), He(() => n._didMount(), []), He(() => n._willUpdate()), n;
+}
+function En(o) {
+  return On({
+    observeElementRect: gn,
+    observeElementOffset: vn,
+    scrollToFn: Cn,
+    ...o
+  });
+}
+const Je = ({ size: o, error: s, formFieldProps: e }) => c("div", { className: "ds-combobox__error-message", id: e.errorId, "aria-live": "polite", "aria-relevant": "additions removals", children: s && c(Ne, { "data-size": o, children: s }) });
+Je.displayName = "ComboboxError";
+const Qe = w(function({ asChild: s, className: e, ...t }, n) {
+  return c(s ? M : "button", { className: E("ds-chip", e), type: s ? void 0 : "button", ref: n, ...t });
+}), Ze = w(function(s, e) {
+  return c(Qe, { "data-removable": !0, ref: e, ...s });
+}), et = w(function({ asChild: s, children: e, className: t, "data-size": n, "data-color": i, ...r }, a) {
+  const l = r.type ?? "checkbox";
+  return _(s ? M : "label", { className: E("ds-chip", t), "data-size": n, "data-color": i, ref: a, children: [c(ue, { ...r, type: l }), c(_t, { children: e })] });
+}), In = w(function(s, e) {
+  return c(et, { ref: e, type: "radio", ...s });
+}), fe = {
+  Button: Qe,
+  Checkbox: et,
+  Radio: In,
+  Removable: Ze
+};
+fe.Button.displayName = "Chip.Button";
+fe.Checkbox.displayName = "Chip.Checkbox";
+fe.Radio.displayName = "Chip.Radio";
+fe.Removable.displayName = "Chip.Removable";
+const tt = () => {
+  const o = R(q);
+  if (!o)
+    throw new Error("ComboboxContext is missing");
+  const { size: s, readOnly: e, disabled: t, selectedOptions: n, chipSrLabel: i, handleSelectOption: r, inputRef: a } = o;
+  return c(Se, { children: Object.keys(n).map((l) => c(Ze, { "data-size": s, disabled: t, onKeyDown: (d) => {
+    e || t || d.key === "Enter" && (d.stopPropagation(), r({
+      option: n[l],
+      remove: !0
+    }), a?.current?.focus());
+  }, onClick: () => {
+    e || t || r({
+      option: n[l],
+      remove: !0
+    });
+  }, "aria-label": i(n[l]), children: n[l].label }, l)) });
+};
+tt.displayName = "ComboboxChips";
+const nt = w((o, s) => {
+  const e = R(q);
+  if (!e)
+    throw new Error("ComboboxContext is missing");
+  const { readOnly: t, disabled: n, clearButtonLabel: i, handleSelectOption: r } = e;
+  return c("button", { ...o, ref: s, disabled: n, className: E("ds-combobox__clear-button", "ds-focus"), onClick: () => {
+    t || n || r({ option: null, clear: !0 });
+  }, onKeyDown: (a) => {
+    t || n || a.key === "Enter" && (a.stopPropagation(), r({ option: null, clear: !0 }));
+  }, type: "button", "aria-label": i, children: c(Gt, { fontSize: "1.5em", title: "Clear selection" }) });
+});
+nt.displayName = "ComboboxClearButton";
+const ot = ({ hideClearButton: o, listId: s, error: e, hideChips: t, handleKeyDown: n, ...i }) => {
+  const r = R(q), a = ke(), l = F(null);
+  if (!r)
+    throw new Error("ComboboxContext is missing");
+  const d = (T) => {
+    a?.({ type: "SET_ACTIVE_INDEX", payload: T });
+  }, { forwareddRef: h, readOnly: p, disabled: u, open: f, inputRef: g, refs: y, inputValue: C, multiple: b, selectedOptions: m, formFieldProps: v, htmlSize: x, options: O, setOpen: S, getReferenceProps: k, setInputValue: B, handleSelectOption: L, size: $ } = r, V = qe([h, g]), ie = (T) => {
+    const X = T.target.value;
+    B(X), d(0);
+    for (const Y of Object.values(O))
+      if (Y.label.toLowerCase() === X.toLowerCase()) {
+        if (m[P(Y.value)])
+          continue;
+        L({ option: Y });
+      }
+  }, z = !o && Object.keys(m).length > 0, Z = k({
+    ref: y?.setReference,
+    role: null,
+    "aria-controls": null,
+    "aria-expanded": null,
+    "aria-haspopup": null,
+    /* If we click the wrapper, toggle open, set index to first option, and focus the input */
+    onClick(T) {
+      u || p || l.current?.contains(T.target) || (S(!f), d(0), g.current?.focus());
+    },
+    /* Handles list navigation */
+    onKeyDown: n,
+    // preventDefault on keydown to avoid sending in form
+    onKeyPress(T) {
+      T.key === "Enter" && T.preventDefault();
+    }
+  });
+  return c(Ie, { "data-size": $, asChild: !0, children: _("div", { ...Z, "aria-disabled": u ? "true" : void 0, className: E("ds-textfield__input", "ds-combobox__input__wrapper", p && "ds-combobox--readonly", e && "ds-combobox--error"), children: [_("div", { className: "ds-combobox__chip-and-input", children: [b && !t && c(tt, {}), c(Ie, { "data-size": $, asChild: !0, children: c("input", { ref: V, "aria-activedescendant": Z["aria-activedescendant"], readOnly: p, "aria-autocomplete": "list", role: "combobox", "aria-expanded": f, "aria-controls": f ? s : void 0, autoComplete: "off", size: x, value: C, ...ce(["style", "className"], i), ...v.inputProps, className: "ds-combobox__input", onChange: (T) => {
+    ie(T), !f && S(!0), i.onChange?.(T);
+  } }) })] }), z && c(nt, { ref: l }), c("div", { className: "ds-combobox__arrow", children: f ? c(Jt, { title: "arrow up", fontSize: "1.5em" }) : c(Qt, { title: "arrow down", fontSize: "1.5em" }) })] }) });
+};
+ot.displayName = "ComboboxInput";
+const st = ({ label: o, description: s, hideLabel: e, size: t, readOnly: n, formFieldProps: i }) => _(Se, { children: [o && _(K, { "data-size": t, htmlFor: i.inputProps.id, className: E("ds-combobox__label", e && "ds-sr-only"), children: [n && c(on, { "aria-hidden": !0, className: "ds-combobox__readonly__icon" }), o] }), s && c(Ie, { asChild: !0, "data-size": t, children: c("div", { id: i.descriptionId, className: E("ds-combobox__description", e && "ds-sr-only"), children: s }) })] });
+st.displayName = "ComboboxLabel";
+const it = ({ selectedOptions: o, multiple: s, name: e }) => {
+  const t = Object.keys(o).map((n) => Ee(n));
+  return c("select", { name: e, multiple: s, style: { display: "none" }, value: s ? t : t[0], onChange: () => {
+  }, children: t.map((n) => c("option", { value: n }, n)) });
+};
+it.displayName = "ComboboxNative";
+const rt = w(({ children: o, className: s, ...e }, t) => c("span", { className: E("ds-combobox__option__description", s), ref: t, ...e, children: o }));
+rt.displayName = "ComboboxOptionDescription";
+const at = ({ multiple: o, selected: s }) => c("div", { className: E(o && "ds-combobox__option__icon-wrapper", s && "ds-combobox__option__icon-wrapper--selected"), children: s && c(en, { className: "ds-combobox__option__icon-wrapper__icon", "aria-hidden": !0 }) });
+at.displayName = "SelectedIcon";
+const Sn = ({ id: o, ref: s, value: e }) => {
+  const t = Q(), n = o || t, i = R(q), { activeIndex: r } = _e(), a = ke();
+  if (!i)
+    throw new Error("ComboboxOption must be used within a Combobox");
+  const { selectedOptions: l, onOptionClick: d, setListRef: h, customIds: p, filteredOptions: u } = i, f = J(() => u.indexOf(P(String(e))) + p.length, [p.length, u, e]), g = qe([
+    (m) => {
+      h(f, m);
+    },
+    s
+  ]);
+  if (f === -1)
+    throw new Error("Internal error: ComboboxOption did not find index");
+  const y = l[P(e)], C = r === f;
+  D(() => {
+    C && a?.({ type: "SET_ACTIVE_INDEX", payload: f });
+  }, [t, o, a, C, f]);
+  const b = Me(() => d(e), 50);
+  return {
+    id: n,
+    ref: g,
+    selected: y,
+    active: C,
+    onOptionClick: b
+  };
+}, ze = It(w(({ value: o, description: s, children: e, className: t, ...n }, i) => {
+  const r = Q(), { id: a, ref: l, selected: d, active: h, onOptionClick: p } = Sn({
+    id: n.id,
+    ref: i,
+    value: o
+  }), u = R(q);
+  if (!u)
+    throw new Error("ComboboxOption must be used within a Combobox");
+  const { size: f, multiple: g, getItemProps: y } = u, C = y();
+  return c(K, { "data-size": "md", asChild: !0, children: _("button", { ref: l, id: a, role: "option", type: "button", "aria-selected": !!d, "aria-labelledby": r, tabIndex: -1, onClick: (b) => {
+    p(), n.onClick?.(b);
+  }, className: E("ds-combobox__option", h && "ds-combobox__option--active", g && "ds-combobox__option--multiple", t), ...ce(["displayValue"], n), ...ce(["onClick", "onPointerLeave"], C), children: [c(K, { asChild: !0, "data-size": f, children: c("span", { children: c(at, { multiple: g, selected: !!d }) }) }), _(K, { className: "ds-combobox__option__label", "data-size": f, id: r, children: [e, s && c(rt, { children: s })] })] }) });
+}));
+ze.displayName = "ComboboxOption";
+function kn(o) {
+  return Et(o) && o.type === ze;
+}
+const _n = (o) => !!o;
+function Nn({ children: o, inputValue: s, multiple: e, filter: t = (i, r) => r.label.toLowerCase().startsWith(i.toLowerCase()), initialValue: n }) {
+  const i = St(t, [t]), { optionsChildren: r, customIds: a, restChildren: l, interactiveChildren: d } = J(() => Be.toArray(o).reduce((m, v) => {
+    if (kn(v))
+      m.optionsChildren.push(v);
+    else if (m.restChildren.push(v), Nt(v)) {
+      const x = v;
+      if (m.interactiveChildren.push(x), !x.props.id)
+        throw new Error("If ComboboxCustom is interactive, it must have an id");
+      m.customIds.push(x.props.id);
+    }
+    return m;
+  }, {
+    optionsChildren: [],
+    customIds: [],
+    restChildren: [],
+    interactiveChildren: []
+  }), [o]), h = J(() => {
+    const C = [], b = {};
+    return r.map((m) => {
+      const v = m.props;
+      let x = v.displayValue || "";
+      if (!v.displayValue) {
+        let O = "";
+        Be.forEach(v.children, (S) => {
+          if (typeof S == "string")
+            O += S;
+          else
+            throw new Error("If ComboboxOption is not a string, it must have a displayValue prop");
+        }), x = O;
+      }
+      return C.includes(v.value) && console.warn(`Combobox has multiple options with the same value: ${v.value}`), C.push(v.value), b[P(String(v.value))] = {
+        value: String(v.value),
+        label: x,
+        displayValue: v.displayValue,
+        description: v.description
+      }, null;
+    }), b;
+  }, [r]), p = J(() => (n?.map((C) => P(C)) || []).reduce((C, b) => {
+    const m = h[b];
+    return _n(m) && (C[b] = m), C;
+  }, {}), [n, h]), [u, f] = A(p), { filteredOptions: g, filteredOptionsChildren: y } = J(() => {
+    const C = [], b = Object.keys(h).map((m, v) => !e && Object.keys(u).length === 1 || e && u[m] || i(s, h[m]) ? (C.push(m), r[v]) : null).filter((m) => m);
+    return { filteredOptions: C, filteredOptionsChildren: b };
+  }, [
+    i,
+    s,
+    e,
+    h,
+    r,
+    u
+  ]);
+  return {
+    filteredOptionsChildren: y,
+    filteredOptions: g,
+    restChildren: l,
+    options: h,
+    customIds: a,
+    selectedOptions: u,
+    interactiveChildren: d,
+    setSelectedOptions: f
+  };
+}
+const Mn = ({ readOnly: o, disabled: s, interactiveChildren: e, filteredOptions: t, inputValue: n, selectedOptions: i, multiple: r, open: a, options: l, setOpen: d, handleSelectOption: h }) => {
+  const { activeIndex: p } = _e();
+  return Me((g) => {
+    if (!(o || s) && g)
+      switch (g.key) {
+        case "ArrowDown":
+          if (g.preventDefault(), a)
+            break;
+          d(!0);
+          break;
+        case "ArrowUp":
+          if (g.preventDefault(), p !== 0)
+            break;
+          d(!1);
+          break;
+        case "Enter": {
+          if (g.preventDefault(), !a)
+            break;
+          if (p <= e.length - 1) {
+            const b = e[p];
+            if (b.props.onSelect) {
+              b?.props.onSelect();
+              return;
+            }
+          }
+          const y = p - e.length, C = t[y];
+          h({ option: l[C] });
+          break;
+        }
+        case "Backspace":
+          if (!r) {
+            const y = Object.keys(i).pop();
+            y && h({
+              option: i[y],
+              remove: !0
+            });
+            break;
+          }
+          if (n === "" && r) {
+            const y = Object.keys(i).pop();
+            y && h({
+              option: i[y],
+              remove: !0
+            });
+          }
+          break;
+      }
+  }, 20);
+}, zn = ({ listRef: o }) => {
+  const [s, e] = A(!1), { activeIndex: t } = _e(), n = ke(), { refs: i, floatingStyles: r, context: a } = Mt({
+    open: s,
+    onOpenChange: (g) => {
+      g || n?.({ type: "SET_ACTIVE_INDEX", payload: 0 }), Xe(() => {
+        i.floating.current && !g && (i.floating.current.scrollTop = 0), setTimeout(() => {
+          e(g);
+        }, 1);
+      });
+    },
+    whileElementsMounted: (g, y, C) => (Ue(g, y, C), () => {
+      y.scrollTop = 0;
+    }),
+    middleware: [
+      Dt({ padding: 10 }),
+      Ft({
+        apply({ rects: g, elements: y }) {
+          requestAnimationFrame(() => {
+            Object.assign(y.floating.style, {
+              width: `${g.reference.width}px`,
+              maxHeight: "200px"
+            });
+          });
+        }
+      }),
+      At(10)
+    ]
+  }), l = zt(a, { role: "listbox" }), d = Tt(a), h = Rt(a, {
+    listRef: o,
+    activeIndex: t,
+    virtual: !0,
+    scrollItemIntoView: !0,
+    enabled: s,
+    focusItemOnHover: !0,
+    onNavigate: (g) => {
+      n?.({ type: "SET_ACTIVE_INDEX", payload: g || 0 });
+    }
+  }), { getReferenceProps: p, getFloatingProps: u, getItemProps: f } = Pt([l, d, h]);
+  return {
+    open: s,
+    setOpen: e,
+    activeIndex: t,
+    refs: i,
+    floatingStyles: r,
+    context: a,
+    getReferenceProps: p,
+    getFloatingProps: u,
+    getItemProps: f
+  };
+}, Tn = se(null), Rn = (o, s) => {
+  const e = R(Tn), t = Q(), n = o.id ?? `${s}-${t}`, i = o.errorId ?? `${s}-error-${t}`, r = `${s}-description-${t}`, a = o.size ?? e?.size ?? "md", l = e?.disabled || o?.disabled, d = !l && !!(o.error || e?.error);
+  return {
+    hasError: d,
+    errorId: i,
+    descriptionId: r,
+    size: a,
+    inputProps: {
+      id: n,
+      disabled: l,
+      "aria-invalid": d ? !0 : void 0,
+      "aria-describedby": E(o["aria-describedby"], !!o?.description && typeof o?.description == "string" && r, d && !e?.error && i, d && !!e?.error && e?.errorId) || void 0
+    }
+  };
+}, Pn = w(({ value: o, initialValue: s = [], onValueChange: e, label: t, hideLabel: n = !1, description: i, multiple: r = !1, disabled: a = !1, readOnly: l = !1, hideChips: d = !1, clearButtonLabel: h = "Fjern alt", hideClearButton: p = !1, error: u, errorId: f, id: g, name: y, portal: C = !0, htmlSize: b = 0, virtual: m = !1, children: v, style: x, size: O = "md", loading: S, loadingLabel: k = "Laster...", filter: B, chipSrLabel: L = (z) => "Slett " + z.label, className: $, ...V }, ie) => {
+  const z = F(null), Z = F(null), T = F([]), [X, Y] = A(V.inputValue || "");
+  D(() => {
+    typeof V.inputValue == "string" && Y(V.inputValue);
+  }, [V.inputValue]);
+  const { selectedOptions: ee, options: j, restChildren: mt, interactiveChildren: pt, customIds: bt, filteredOptionsChildren: be, filteredOptions: Ae, setSelectedOptions: te } = Nn({
+    children: v,
+    inputValue: X,
+    filter: B,
+    multiple: r,
+    initialValue: s
+  }), { open: ge, setOpen: ve, refs: re, floatingStyles: gt, context: Le, getReferenceProps: vt, getFloatingProps: yt, getItemProps: Ct } = zn({
+    listRef: T
+  }), ne = Rn({
+    disabled: a,
+    error: u,
+    errorId: f,
+    size: O,
+    description: i,
+    id: g
+  }, "combobox");
+  D(() => {
+    if (o && o.length > 0 && !r) {
+      const N = j[P(o[0])];
+      z.current && ae(z.current, N?.label || "");
+    }
+  }, [r, o, j]), D(() => {
+    if (o && Object.keys(j).length >= 0) {
+      const N = o.map((I) => j[P(I)]);
+      te(N.reduce((I, oe) => (I[P(oe.value)] = oe, I), {}));
+    }
+  }, [r, o, j, te]);
+  const ye = Me((N) => {
+    const { option: I, clear: oe, remove: wt } = N;
+    if (oe) {
+      te({}), z.current && ae(z.current, ""), e?.([]);
+      return;
+    }
+    if (!I)
+      return;
+    if (wt) {
+      const H = { ...ee };
+      delete H[P(I.value)], te(H), e?.(Object.keys(H).map((Ot) => Ee(Ot)));
+      return;
+    }
+    const W = { ...ee };
+    if (r)
+      W[P(I.value)] ? delete W[P(I.value)] : W[P(I.value)] = I, z.current && ae(z.current, ""), z.current?.focus();
+    else {
+      for (const H of Object.keys(W))
+        delete W[H];
+      W[P(I.value)] = I, z.current && ae(z.current, I?.label || ""), setTimeout(() => {
+        z.current?.setSelectionRange(I?.label?.length || 0, I?.label?.length || 0);
+      }, 0);
+    }
+    te(W), e?.(Object.keys(W).map((H) => Ee(H))), !r && ve(!1), re.domReference.current?.focus();
+  }, 50), xt = Mn({
+    filteredOptions: Ae,
+    selectedOptions: ee,
+    readOnly: ne.readOnly || !1,
+    disabled: a,
+    multiple: r,
+    inputValue: X,
+    options: j,
+    open: ge,
+    interactiveChildren: pt,
+    setOpen: ve,
+    handleSelectOption: ye
+  }), Ce = En({
+    count: Object.keys(be).length,
+    getScrollElement: () => m ? re.floating.current : null,
+    estimateSize: () => 70,
+    measureElement: (N) => N.getBoundingClientRect().height,
+    overscan: 7
+  });
+  return _(q.Provider, { value: {
+    size: O,
+    options: j,
+    selectedOptions: ee,
+    multiple: r,
+    disabled: a,
+    readOnly: l,
+    open: ge,
+    inputRef: z,
+    refs: re,
+    inputValue: X,
+    formFieldProps: ne,
+    htmlSize: b,
+    clearButtonLabel: h,
+    customIds: bt,
+    filteredOptions: Ae,
+    setInputValue: Y,
+    setOpen: ve,
+    getReferenceProps: vt,
+    getItemProps: Ct,
+    /* Recieves the value of the option, and searches for it in our values lookup */
+    onOptionClick: (N) => {
+      if (l || a)
+        return;
+      const I = j[P(N)];
+      ye({ option: I });
+    },
+    handleSelectOption: ye,
+    chipSrLabel: L,
+    listRef: T,
+    forwareddRef: ie,
+    setListRef: (N, I) => {
+      T.current[N] = I;
+    }
+  }, children: [_("div", { className: E("ds-combobox", `ds-combobox--${O}`, a && "ds-combobox__disabled", $), style: x, ref: Z, children: [y && c(it, { name: y, selectedOptions: ee, multiple: r }), c(st, { label: t, description: i, size: O, readOnly: l, hideLabel: n, formFieldProps: ne }), c(ot, { ...ce(["inputValue"], V), hideClearButton: p, listId: Le.floatingId || "", error: u, hideChips: d, handleKeyDown: xt, "aria-busy": S }), c(Je, { size: O, error: u, formFieldProps: ne })] }), ge && c(Bt, { root: C ? null : Z, children: c(Vt, { context: Le, initialFocus: -1, visuallyHiddenDismiss: !0, children: _("div", { "aria-labelledby": ne.inputProps.id, "aria-autocomplete": "list", tabIndex: -1, ...yt({
+    ref: re.setFloating,
+    style: {
+      ...gt
+    }
+  }), className: E("ds-combobox__options-wrapper", `ds-combobox--${O}`), children: [m && c("div", { style: {
+    height: `${Ce.getTotalSize()}px`,
+    width: "100%",
+    position: "relative"
+  }, children: Ce.getVirtualItems().map((N) => c("div", { ref: Ce.measureElement, "data-index": N.index, style: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    width: "100%",
+    transform: `translateY(${N.start}px)`
+  }, children: be[N.index] }, N.index)) }), S ? _($t, { className: "ds-combobox__loading", children: [c(qt, { "aria-label": "Laster", "data-size": "sm" }), k] }) : _(Se, { children: [mt, !m && be] })] }) }) })] });
+}), lt = w((o, s) => c(Lt, { children: c(Pn, { ...o, ref: s }) }));
+lt.displayName = "Combobox";
+const ct = w(({ children: o, className: s, ...e }, t) => {
+  const n = R(q);
+  if (!n)
+    throw new Error("ComboboxEmpty must be used within a Combobox");
+  const { filteredOptions: i, size: r } = n;
+  return i.length === 0 && c(K, { "data-size": r, asChild: !0, children: c("div", { ref: t, className: E("ds-combobox__empty", s), ...e, children: o }) });
+});
+ct.displayName = "ComboboxEmpty";
+const me = lt;
+me.Option = ze;
+me.Empty = ct;
+me.Option.displayName = "Combobox.Option";
+me.Empty.displayName = "Combobox.Empty";
+const bo = w(function({ "data-size": s, className: e, style: t, children: n, label: i, description: r, error: a, ...l }, d) {
+  return _(de, { "data-size": s, className: e, style: t, children: [c(ue, { type: "checkbox", ref: d, ...l }), !!i && c(K, { weight: "regular", children: i }), !!r && c("div", { "data-field": "description", children: r }), !!a && c(Ne, { children: a })] });
+}), Te = se({
+  current: null
+}), dt = ({ children: o }) => {
+  const s = F(null);
+  return c(Te.Provider, { value: s, children: o });
+};
+dt.displayName = "DialogTriggerContext";
+const Dn = w(function({ asChild: s, children: e, className: t, placement: n = "center", closeButton: i = "Lukk dialogvindu", closedby: r = "closerequest", modal: a = !0, onClose: l, open: d, ...h }, p) {
+  const u = R(Te), f = F(null), g = s ? M : "dialog", y = U([u, p, f]), C = a ? "showModal" : "show";
+  return D(() => f.current?.[d ? C : "close"](), [d]), D(() => {
+    const b = f.current, m = (x) => {
+      if (x.defaultPrevented)
+        return;
+      const { clientY: O, clientX: S, target: k } = x;
+      if (k instanceof Element && x.type === "click" && k.closest('[data-command="close"]'))
+        return b?.close();
+      if (!(b && "closedBy" in b)) {
+        if (x instanceof KeyboardEvent)
+          return r === "none" && x.key === "Escape" && x.preventDefault();
+        if (!window.getSelection()?.toString() && b && k === b && r === "any") {
+          const { top: B, left: L, right: $, bottom: V } = b.getBoundingClientRect();
+          B <= O && O <= V && L <= S && S <= $ || b?.close();
+        }
+      }
+    }, v = () => {
+      const x = b?.querySelector("[autofocus]");
+      document.activeElement !== x && x?.focus();
+    };
+    return b?.addEventListener("animationend", v), b?.addEventListener("click", m), b?.addEventListener("keydown", m), () => {
+      b?.removeEventListener("animationend", v), b?.removeEventListener("click", m), b?.removeEventListener("keydown", m);
+    };
+  }, [r]), D(() => {
+    const b = (v) => l?.(v), m = f.current;
+    return m?.addEventListener("close", b), () => m?.removeEventListener("close", b);
+  }, [l]), _(g, { className: E("ds-dialog", t), ref: y, "data-placement": n, "data-modal": a, closedby: r, ...h, children: [i !== !1 && c(he, { "aria-label": i, "data-color": "neutral", icon: !0, variant: "tertiary", "data-command": "close" }), e] });
+}), Fn = w(function({ asChild: s, className: e, ...t }, n) {
+  return c(s ? M : "div", { className: E("ds-dialog__block", e), ref: n, ...t });
+}), An = w(function({ asChild: s, ...e }, t) {
+  const n = R(Te);
+  return c(s ? M : he, { "aria-haspopup": "dialog", onClick: () => {
+    n.current?.getAttribute("data-modal") === "true" ? n.current?.showModal() : n.current?.show();
+  }, ref: t, ...e });
+}), Re = Object.assign(Dn, {
+  Block: Fn,
+  TriggerContext: dt,
+  Trigger: An
+});
+Re.Block.displayName = "Dialog.Block";
+Re.TriggerContext.displayName = "Dialog.TriggerContext";
+Re.Trigger.displayName = "Dialog.Trigger";
+const ut = ({ children: o }) => {
+  const s = Q(), [e, t] = A(s);
+  return c(Pe.Provider, { value: { popoverId: e, setPopoverId: t }, children: o });
+};
+ut.displayName = "PopoverTriggerContext";
+const Pe = se({}), Ln = w(function({ id: s, className: e, onClose: t, onOpen: n, open: i, variant: r = "default", placement: a = "top", autoPlacement: l = !0, asChild: d = !1, ...h }, p) {
+  const u = d ? M : "div", f = F(null), g = U([f, p]), { popoverId: y, setPopoverId: C } = R(Pe), [b, m] = A(!1), v = i ?? b;
+  return D(() => {
+    const x = f.current, O = (k) => {
+      const B = k.target, L = B?.closest?.(`[popovertarget="${x?.id}"]`), $ = !L && !x?.contains(B);
+      L && k.preventDefault(), v && (L || $) ? (m(!1), t?.()) : !v && L && (m(!0), n?.());
+    }, S = (k) => {
+      k.key !== "Escape" || !v || (k.preventDefault(), m(!1), t?.());
+    };
+    return x?.togglePopover?.(v), document.addEventListener("click", O, !0), document.addEventListener("keydown", S), () => {
+      document.removeEventListener("click", O, !0), document.removeEventListener("keydown", S);
+    };
+  }, [v]), D(() => {
+    const x = f.current, O = document.querySelector(`[popovertarget="${x?.id}"]`);
+    if (x && O && v)
+      return Ue(O, x, () => {
+        jt(O, x, {
+          placement: a,
+          strategy: "fixed",
+          middleware: [
+            Wt((S) => {
+              const k = getComputedStyle(S.elements.floating, "::before");
+              return parseFloat(k.height);
+            }),
+            ...l ? [Kt({ fallbackAxisSideDirection: "start" }), Ht()] : [],
+            Bn
+          ]
+        }).then(({ x: S, y: k }) => {
+          x.style.translate = `${Math.round(S)}px ${Math.round(k)}px`;
+        });
+      });
+  }, [v, a, s, l]), D(() => {
+    s && C?.(s);
+  }, [s]), c(u, { className: E("ds-popover", e), id: s || y, popover: "manual", "data-variant": r, ref: g, ...h });
+}), Bn = {
+  name: "ArrowPseudoElement",
+  fn(o) {
+    const { elements: s, rects: e, placement: t } = o;
+    let n = `${Math.round(e.reference.width / 2 + e.reference.x - o.x)}px`, i = `${Math.round(e.reference.height / 2 + e.reference.y - o.y)}px`;
+    switch (e.reference.width > e.floating.width && (n = `${Math.round(e.floating.width / 2)}px`), e.reference.height > e.floating.height && (i = `${Math.round(e.floating.height / 2)}px`), t.split("-")[0]) {
+      case "top":
+        i = "100%";
+        break;
+      case "right":
+        n = "0";
+        break;
+      case "bottom":
+        i = "0";
+        break;
+      case "left":
+        n = "100%";
+        break;
+    }
+    return s.floating.setAttribute("data-placement", t.split("-")[0]), s.floating.style.setProperty("--ds-popover-arrow-x", n), s.floating.style.setProperty("--ds-popover-arrow-y", i), o;
+  }
+}, Vn = w(function({ id: s, inline: e, asChild: t, ...n }, i) {
+  const { popoverId: r } = R(Pe), a = t ? M : e ? "button" : he, l = Object.assign({
+    [kt.startsWith("19") ? "popoverTarget" : "popovertarget"]: r,
+    ...e ? {
+      "data-popover": "inline"
+    } : {}
+  }, n);
+  return c(a, { ref: i, ...l });
+}), go = w(function({ asChild: s, ...e }, t) {
+  return c(s ? M : "li", { ...e, ref: t });
+}), ht = (o, { asChild: s, className: e, ...t }, n) => c(s ? M : o, { className: E("ds-list", e), ref: n, ...t }), vo = w(function(s, e) {
+  return ht("ul", s, e);
+});
+w(function(s, e) {
+  return ht("ol", s, e);
+});
+const $n = w(function({ "aria-label": s = "Sidenavigering", asChild: e, className: t, ...n }, i) {
+  return c(e ? M : "nav", { "aria-label": s, className: E("ds-pagination", t), ref: i, ...n });
+}), jn = w(function(s, e) {
+  return c(he, { ref: e, ...s });
+}), Wn = w(function({ asChild: s, className: e, ...t }, n) {
+  return c(s ? M : "li", { ref: n, ...t });
+}), Kn = w(function({ asChild: s, ...e }, t) {
+  return c(s ? M : "ul", { ref: t, ...e });
+}), De = Object.assign($n, {
+  List: Kn,
+  Item: Wn,
+  Button: jn
+});
+De.List.displayName = "Pagination.List";
+De.Item.displayName = "Pagination.Item";
+De.Button.displayName = "Pagination.Button";
+const ft = Object.assign(Ln, {
+  TriggerContext: ut,
+  Trigger: Vn
+});
+ft.TriggerContext.displayName = "Popover.TriggerContext";
+ft.Trigger.displayName = "Popover.Trigger";
+const yo = w(function({ asChild: s, className: e, height: t, style: n, variant: i = "rectangle", width: r, ...a }, l) {
+  const d = s ? M : "span", h = i === "text", p = Ut("ds-skeleton-opacity-fade"), u = U([p, l]);
+  return c(d, { "aria-hidden": "true", className: E("ds-skeleton", e), "data-text": h ? "-".repeat(Number(r) || 1) : void 0, "data-variant": i, ref: u, style: h ? n : { width: r, height: t, ...n }, ...a });
+}), Co = w(function({ "data-size": s, children: e, className: t, description: n, label: i, position: r, style: a, ...l }, d) {
+  return _(de, { className: t, "data-position": r, "data-size": s, style: a, children: [c(ue, { type: "checkbox", role: "switch", ref: d, ...l }), !!i && c(K, { weight: "regular", children: i }), !!n && c("div", { "data-field": "description", children: n })] });
+}), pe = se({}), Hn = w(function({ value: s, defaultValue: e, className: t, onChange: n, ...i }, r) {
+  const a = F(null), l = s !== void 0, [d, h] = A(e), [p, u] = A(/* @__PURE__ */ new Map());
+  let f = n;
+  return l || (f = (g) => {
+    h(g), n?.(g);
+  }, s = d), c(pe.Provider, { value: {
+    value: s,
+    defaultValue: e,
+    onChange: f,
+    tablistRef: a,
+    panelButtonMap: p,
+    setPanelButtonMap: u
+  }, children: c("div", { className: E("ds-tabs", t), ref: r, ...i }) });
+}), qn = w(function({ children: s, ...e }, t) {
+  const { value: n, tablistRef: i } = R(pe), r = U([t, i]);
+  return c(sn, { role: "tablist", activeValue: n, orientation: "ambiguous", ref: r, ...e, children: s });
+}), Un = w(function({ children: s, value: e, id: t, ...n }, i) {
+  const { value: r, tablistRef: a, setPanelButtonMap: l } = R(pe), d = e === r, h = Q(), p = t ?? `tabpanel-${h}`, [u, f] = A(!1), [g, y] = A(void 0), C = F(null), b = U([i, C]);
+  return D(() => {
+    if (!C.current)
+      return;
+    const m = C.current.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
+    f(m.length > 0);
+  }, [s]), D(() => {
+    if (!a)
+      return;
+    const m = a.current?.querySelector(`[role="tab"][data-value="${e}"]`);
+    y(m ? m.id : void 0), m && l?.((v) => new Map(v).set(m.id, p));
+  }, [a]), c("div", { ref: b, id: p, role: "tabpanel", tabIndex: u ? void 0 : 0, "aria-labelledby": g, hidden: !d, ...n, children: s });
+}), Xn = w(function({ value: s, id: e, onClick: t, ...n }, i) {
+  const r = R(pe), a = Q(), l = e ?? `tab-${a}`;
+  return c(an, { value: s, ...n, asChild: !0, children: c("button", { ref: i, id: l, "aria-selected": r.value === s, "data-value": s, role: "tab", type: "button", onClick: (d) => {
+    r.onChange?.(s), t?.(d);
+  }, "aria-controls": r.panelButtonMap?.get(l), ...n }) });
+}), Fe = Object.assign(Hn, {
+  List: qn,
+  Tab: Xn,
+  Panel: Un
+});
+Fe.Tab.displayName = "Tabs.Tab";
+Fe.List.displayName = "Tabs.List";
+Fe.Panel.displayName = "Tabs.Panel";
+const xo = w(function({ label: s, description: e, error: t, multiline: n, prefix: i, suffix: r, "data-size": a, counter: l, style: d, className: h, ...p }, u) {
+  return _(de, { className: h, "data-size": a, style: d, children: [!!s && c(K, { children: s }), !!e && c(Xt, { children: e }), _(Yt, { children: [i === void 0 || c(Ve, { children: i }), n === !0 ? c(tn, { ref: u, "aria-invalid": !!t || void 0, ...p }) : c(ue, { ref: u, "aria-invalid": !!t || void 0, ...p }), r === void 0 || c(Ve, { children: r })] }), !!l && c(de.Counter, { ...typeof l == "number" ? { limit: l } : l }), !!t && c(Ne, { children: t })] });
+});
+export {
+  un as B,
+  bo as C,
+  Re as D,
+  hn as L,
+  De as P,
+  Co as S,
+  xo as T,
+  fe as a,
+  me as b,
+  go as c,
+  vo as d,
+  ft as e,
+  yo as f,
+  Fe as g,
+  po as u
+};