@synnaxlabs/pluto 0.40.0 → 0.41.0

package/dist/Text-3PiRcn8q.js

@@ -0,0 +1,1246 @@
+import { j as x } from "./jsx-runtime-C5mzlN2N.js";
+import { f as $, d as A, y as V, T as oe, c as ze, g as ie } from "./Divider-Bpe7zJig.js";
+import { b as Ae, F as U, a as ke, w as le, C as _e, m as H } from "./index-CSKP1UPN.js";
+import * as L from "react";
+import { useState as k, useCallback as T, use as _, createContext as M, useEffect as R, useMemo as w, useRef as j, memo as je, useContext as ae, useLayoutEffect as ce } from "react";
+import "./Stack-D50qN0Vu.js";
+import { S as q } from "./Space-DunsWl06.js";
+import { C as y, a0 as G } from "./css-Dyt-QnKy.js";
+import { a as Fe, C as Ne } from "./ContextMenu-GUed89mt.js";
+import "./state-CjGemC7S.js";
+import { d as Q } from "./dimensions-Cc0z-IDd.js";
+import { W as ue } from "./WithIcon-CC-RSx6r.js";
+import { c as Ve, C as Le } from "./Provider-UAXPVomG.js";
+import "./provider-CH0eoGfz.js";
+import { u as We } from "./font-BXKdXsr5.js";
+import { flushSync as Be } from "react-dom";
+import { s as J, m as W, a as Pe } from "./hooks-BQJQyGWV.js";
+import { A as $e, o as ee } from "./toArray-Dvn9FA_3.js";
+import { u as Ue } from "./useMemoCompare-BEDaTIXL.js";
+import { a as He, A as Ge, c as qe } from "./aggregator-DMvP8cai.js";
+import { C as Ke } from "./Center-Dr9Np3yZ.js";
+const Xe = ({
+  transforms: r = []
+}) => {
+  const [l, e] = k(r), t = T(
+    (n, i, a = 0) => e((d) => {
+      const u = d.filter((h) => h.key !== n);
+      return u.push({ key: n, transform: i, priority: a }), u.sort((h, m) => m.priority - h.priority), u;
+    }),
+    [e]
+  ), s = T(
+    (n) => e((i) => i.filter((a) => a.key !== n)),
+    [t]
+  );
+  return { transform: T(
+    (n) => l.reduce((i, a) => a.transform(i), {
+      ...n,
+      transformed: !1
+    }),
+    [l]
+  ), setTransform: t, deleteTransform: s };
+}, K = (r) => {
+  const l = _(r);
+  if (l === null) throw new Error("useRequiredContext: context value is null");
+  return l;
+}, de = M({
+  transformedData: [],
+  sourceData: [],
+  transformed: !1
+}), he = M({
+  setSourceData: () => {
+  },
+  getSourceData: () => [],
+  getTransformedData: () => [],
+  deleteTransform: () => {
+  },
+  setTransform: () => {
+  },
+  setEmptyContent: () => {
+  },
+  getEmptyContent: () => {
+  },
+  getDefaultEmptyContent: () => {
+  },
+  getTransformed: () => !1
+}), F = () => K(de), X = () => K(he), es = () => F().transformedData, Ye = () => F().sourceData, fe = () => X().getTransformedData, ts = () => X().setSourceData, Ze = ({
+  data: r,
+  emptyContent: l,
+  children: e
+}) => {
+  const { transform: t, setTransform: s, deleteTransform: o } = Xe({}), [n, i, a] = $(() => r ?? []);
+  R(() => {
+    r != null && i(r);
+  }, [r]);
+  const d = w(
+    () => t({ data: [...n], transformed: !1 }),
+    [n, t]
+  ), u = A(d), h = A(
+    l
+  ), [m, p, g] = $(void 0);
+  R(() => {
+    l != null && p(l);
+  }, [l]);
+  const c = w(
+    () => ({
+      setSourceData: i,
+      getSourceData: () => a.current,
+      getTransformedData: () => u.current.data,
+      getTransformed: () => u.current.transformed,
+      deleteTransform: o,
+      setTransform: s,
+      setEmptyContent: p,
+      getEmptyContent: () => g.current,
+      getDefaultEmptyContent: () => h.current
+    }),
+    [i, a, u, o, s]
+  ), f = w(
+    () => ({
+      transformed: d.transformed,
+      transformedData: d.data,
+      sourceData: n,
+      emptyContent: m
+    }),
+    [d, n, m]
+  );
+  return /* @__PURE__ */ x.jsx(he, { value: c, children: /* @__PURE__ */ x.jsx(de, { value: f, children: e }) });
+}, Qe = ({
+  entry: r,
+  selected: l,
+  hovered: e,
+  onSelect: t,
+  className: s,
+  direction: o = "x",
+  draggingOver: n,
+  rightAligned: i = !1,
+  highlightHovered: a = !1,
+  allowSelect: d = !0,
+  translate: u,
+  style: h,
+  sourceIndex: m,
+  ...p
+}) => /* @__PURE__ */ x.jsx(
+  q,
+  {
+    id: r.key.toString(),
+    direction: o,
+    onClick: () => t == null ? void 0 : t(r.key),
+    tabIndex: 0,
+    className: y(
+      s,
+      Fe,
+      l && Ne,
+      d && y.M("selectable"),
+      e && y.M("hovered"),
+      i && y.M("right-aligned"),
+      a && y.M("highlight-hover"),
+      y.BE("list", "item"),
+      y.selected(l)
+    ),
+    style: {
+      position: u != null ? "absolute" : "relative",
+      transform: `translateY(${u}px)`,
+      ...h
+    },
+    ...p
+  }
+), me = M(null), Je = () => K(me), B = "sort", et = ({
+  hide: r = !1,
+  columns: l,
+  children: e,
+  level: t = "p",
+  weight: s,
+  shade: o
+}) => {
+  const n = Ye(), { setTransform: i, deleteTransform: a } = X(), d = We("p").toString(), [u, h] = k([null, !1]), [m, p] = k({
+    columns: l
+  }), g = (c) => {
+    const [f, v] = u;
+    f === c ? v ? (h([c, !v]), i(B, te(c, !v))) : (h([null, !1]), a(B)) : (h([c, !0]), i(B, te(c, !0)));
+  };
+  return R(() => {
+    p((c) => ({
+      columns: nt(
+        c.columns.length === 0 ? l : c.columns,
+        n,
+        d
+      )
+    }));
+  }, [d, n, l]), /* @__PURE__ */ x.jsxs(me, { value: m, children: [
+    !r && /* @__PURE__ */ x.jsx(
+      q,
+      {
+        x: !0,
+        size: "medium",
+        className: y(y.BE("list-col-header", "container"), y.visible(!r)),
+        children: m.columns.filter(({ visible: c = !0 }) => c).map(({ key: c, cWidth: f, name: v }) => {
+          const [S, E] = u;
+          let O;
+          const C = n[0];
+          return c === S && (O = E ? /* @__PURE__ */ x.jsx(V.Caret.Up, {}) : /* @__PURE__ */ x.jsx(V.Caret.Down, {})), /* @__PURE__ */ x.jsx(
+            ue,
+            {
+              className: y.BE("list-col-header", "item"),
+              justify: "spaceBetween",
+              level: t,
+              weight: s,
+              shade: o,
+              endIcon: O,
+              style: { width: f },
+              shrink: !1,
+              onClick: () => C != null && c in C && g(c),
+              children: v
+            },
+            c.toString()
+          );
+        })
+      }
+    ),
+    e
+  ] });
+}, tt = ({
+  entry: r,
+  onSelect: l,
+  className: e,
+  ...t
+}) => {
+  const { columns: s } = Je(), { index: o } = t;
+  return /* @__PURE__ */ x.jsx(
+    Qe,
+    {
+      entry: r,
+      onSelect: l,
+      className: y(
+        e,
+        y.BE("list-col-item", "container"),
+        l != null && y.BEM("list-col-item", "container", "selectable")
+      ),
+      align: "center",
+      size: "medium",
+      ...t,
+      children: s.filter(({ visible: n = !0 }) => n).map((n) => /* @__PURE__ */ x.jsx(
+        st,
+        {
+          entry: r,
+          col: n,
+          index: o
+        },
+        n.key.toString()
+      ))
+    },
+    r.key.toString()
+  );
+}, st = ({
+  entry: r,
+  index: l,
+  col: { width: e, ...t }
+}) => {
+  const s = {
+    width: t.cWidth,
+    userSelect: "none",
+    padding: "1rem",
+    flexShrink: 0
+  };
+  if (t.render != null) return t.render({ key: t.key, entry: r, style: s, index: l });
+  let o;
+  return t.stringer != null ? o = t.stringer(r) : o = r[t.key], /* @__PURE__ */ x.jsx(
+    oe,
+    {
+      className: y.BE("list-col-item-value", t.key.toString()),
+      level: "p",
+      style: s,
+      shade: t.shade,
+      weight: t.weight,
+      children: Ae(o)
+    },
+    t.key.toString()
+  );
+}, nt = (r, l, e, t = 30) => {
+  const s = rt(l, r);
+  return r.map((o) => {
+    if (o.width != null) o.cWidth = o.width;
+    else {
+      const { width: n } = Q(o.name, e), { width: i } = Q(s[o.key], e);
+      o.cWidth = Math.max(n, i) + t;
+    }
+    return o;
+  });
+}, rt = (r, l) => {
+  const e = {};
+  return r.forEach(
+    (t) => l.forEach(({ key: s, stringer: o }) => {
+      const n = t[s];
+      if (n == null) return;
+      const i = o != null ? o(t) : n.toString();
+      (!(s in e) || i.length > e[s].length) && (e[s] = i);
+    })
+  ), e;
+}, te = (r, l) => ({ data: e }) => e.length === 0 ? { data: e, transformed: !1 } : {
+  data: [...e].sort(U.newFieldF(r, e[0], !l)),
+  transformed: !0
+}, ss = {
+  /**
+   * The header for a column list.
+   *
+   * @param columns - The columns to render. See {@link ListColumnT}.
+   */
+  Header: et,
+  /**
+   * The item to use for a column list. This should be used as the child render prop
+   * in a list render implementation e.g. {@link List.Core.Virtual}.
+   *
+   * @param props - implements the {@link ItemProps} interface. All these props
+   * should be provided by the list render implementation.
+   */
+  Item: tt,
+  /** The default height of a column list item. */
+  itemHeight: 5.5 * 6
+};
+function z(r, l, e) {
+  let t = e.initialDeps ?? [], s;
+  function o() {
+    var n, i, a, d;
+    let u;
+    e.key && ((n = e.debug) != null && n.call(e)) && (u = Date.now());
+    const h = r();
+    if (!(h.length !== t.length || h.some((g, c) => t[c] !== g)))
+      return s;
+    t = h;
+    let p;
+    if (e.key && ((i = e.debug) != null && i.call(e)) && (p = Date.now()), s = l(...h), e.key && ((a = e.debug) != null && a.call(e))) {
+      const g = Math.round((Date.now() - u) * 100) / 100, c = Math.round((Date.now() - p) * 100) / 100, f = c / 16, v = (S, E) => {
+        for (S = String(S); S.length < E; )
+          S = " " + S;
+        return S;
+      };
+      console.info(
+        `%c⏱ ${v(c, 5)} /${v(g, 5)} ms`,
+        `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(
+          0,
+          Math.min(120 - 120 * f, 120)
+        )}deg 100% 31%);`,
+        e == null ? void 0 : e.key
+      );
+    }
+    return (d = e == null ? void 0 : e.onChange) == null || d.call(e, s), s;
+  }
+  return o.updateDeps = (n) => {
+    t = n;
+  }, o;
+}
+function P(r, l) {
+  if (r === void 0)
+    throw new Error("Unexpected undefined");
+  return r;
+}
+const ot = (r, l) => Math.abs(r - l) < 1, it = (r, l, e) => {
+  let t;
+  return function(...s) {
+    r.clearTimeout(t), t = r.setTimeout(() => l.apply(this, s), e);
+  };
+}, lt = (r) => r, at = (r) => {
+  const l = Math.max(r.startIndex - r.overscan, 0), e = Math.min(r.endIndex + r.overscan, r.count - 1), t = [];
+  for (let s = l; s <= e; s++)
+    t.push(s);
+  return t;
+}, ct = (r, l) => {
+  const e = r.scrollElement;
+  if (!e)
+    return;
+  const t = r.targetWindow;
+  if (!t)
+    return;
+  const s = (n) => {
+    const { width: i, height: a } = n;
+    l({ width: Math.round(i), height: Math.round(a) });
+  };
+  if (s(e.getBoundingClientRect()), !t.ResizeObserver)
+    return () => {
+    };
+  const o = new t.ResizeObserver((n) => {
+    const i = () => {
+      const a = n[0];
+      if (a != null && a.borderBoxSize) {
+        const d = a.borderBoxSize[0];
+        if (d) {
+          s({ width: d.inlineSize, height: d.blockSize });
+          return;
+        }
+      }
+      s(e.getBoundingClientRect());
+    };
+    r.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(i) : i();
+  });
+  return o.observe(e, { box: "border-box" }), () => {
+    o.unobserve(e);
+  };
+}, se = {
+  passive: !0
+}, ne = typeof window > "u" ? !0 : "onscrollend" in window, ut = (r, l) => {
+  const e = r.scrollElement;
+  if (!e)
+    return;
+  const t = r.targetWindow;
+  if (!t)
+    return;
+  let s = 0;
+  const o = r.options.useScrollendEvent && ne ? () => {
+  } : it(
+    t,
+    () => {
+      l(s, !1);
+    },
+    r.options.isScrollingResetDelay
+  ), n = (u) => () => {
+    const { horizontal: h, isRtl: m } = r.options;
+    s = h ? e.scrollLeft * (m && -1 || 1) : e.scrollTop, o(), l(s, u);
+  }, i = n(!0), a = n(!1);
+  a(), e.addEventListener("scroll", i, se);
+  const d = r.options.useScrollendEvent && ne;
+  return d && e.addEventListener("scrollend", a, se), () => {
+    e.removeEventListener("scroll", i), d && e.removeEventListener("scrollend", a);
+  };
+}, dt = (r, l, e) => {
+  if (l != null && l.borderBoxSize) {
+    const t = l.borderBoxSize[0];
+    if (t)
+      return Math.round(
+        t[e.options.horizontal ? "inlineSize" : "blockSize"]
+      );
+  }
+  return Math.round(
+    r.getBoundingClientRect()[e.options.horizontal ? "width" : "height"]
+  );
+}, ht = (r, {
+  adjustments: l = 0,
+  behavior: e
+}, t) => {
+  var s, o;
+  const n = r + l;
+  (o = (s = t.scrollElement) == null ? void 0 : s.scrollTo) == null || o.call(s, {
+    [t.options.horizontal ? "left" : "top"]: n,
+    behavior: e
+  });
+};
+class ft {
+  constructor(l) {
+    this.unsubs = [], this.scrollElement = null, this.targetWindow = null, this.isScrolling = !1, this.scrollToIndexTimeoutId = null, this.measurementsCache = [], this.itemSizeCache = /* @__PURE__ */ new Map(), this.pendingMeasuredCacheIndexes = [], this.scrollRect = null, this.scrollOffset = null, this.scrollDirection = null, this.scrollAdjustments = 0, this.elementsCache = /* @__PURE__ */ new Map(), this.observer = /* @__PURE__ */ (() => {
+      let e = null;
+      const t = () => e || (!this.targetWindow || !this.targetWindow.ResizeObserver ? null : e = new this.targetWindow.ResizeObserver((s) => {
+        s.forEach((o) => {
+          const n = () => {
+            this._measureElement(o.target, o);
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(n) : n();
+        });
+      }));
+      return {
+        disconnect: () => {
+          var s;
+          (s = t()) == null || s.disconnect(), e = null;
+        },
+        observe: (s) => {
+          var o;
+          return (o = t()) == null ? void 0 : o.observe(s, { box: "border-box" });
+        },
+        unobserve: (s) => {
+          var o;
+          return (o = t()) == null ? void 0 : o.unobserve(s);
+        }
+      };
+    })(), this.range = null, this.setOptions = (e) => {
+      Object.entries(e).forEach(([t, s]) => {
+        typeof s > "u" && delete e[t];
+      }), this.options = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: lt,
+        rangeExtractor: at,
+        onChange: () => {
+        },
+        measureElement: dt,
+        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, s;
+      (s = (t = this.options).onChange) == null || s.call(t, this, e);
+    }, this.maybeNotify = z(
+      () => (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((s) => {
+          this.observer.observe(s);
+        }), this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        }), this.unsubs.push(
+          this.options.observeElementRect(this, (s) => {
+            this.scrollRect = s, this.maybeNotify();
+          })
+        ), this.unsubs.push(
+          this.options.observeElementOffset(this, (s, o) => {
+            this.scrollAdjustments = 0, this.scrollDirection = o ? this.getScrollOffset() < s ? "forward" : "backward" : null, this.scrollOffset = s, this.isScrolling = o, this.maybeNotify();
+          })
+        );
+      }
+    }, 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 s = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+      for (let n = t - 1; n >= 0; n--) {
+        const i = e[n];
+        if (s.has(i.lane))
+          continue;
+        const a = o.get(
+          i.lane
+        );
+        if (a == null || i.end > a.end ? o.set(i.lane, i) : i.end < a.end && s.set(i.lane, !0), s.size === this.options.lanes)
+          break;
+      }
+      return o.size === this.options.lanes ? Array.from(o.values()).sort((n, i) => n.end === i.end ? n.index - i.index : n.end - i.end)[0] : void 0;
+    }, this.getMeasurementOptions = z(
+      () => [
+        this.options.count,
+        this.options.paddingStart,
+        this.options.scrollMargin,
+        this.options.getItemKey,
+        this.options.enabled
+      ],
+      (e, t, s, o, n) => (this.pendingMeasuredCacheIndexes = [], {
+        count: e,
+        paddingStart: t,
+        scrollMargin: s,
+        getItemKey: o,
+        enabled: n
+      }),
+      {
+        key: !1
+      }
+    ), this.getMeasurements = z(
+      () => [this.getMeasurementOptions(), this.itemSizeCache],
+      ({ count: e, paddingStart: t, scrollMargin: s, getItemKey: o, enabled: n }, i) => {
+        if (!n)
+          return this.measurementsCache = [], this.itemSizeCache.clear(), [];
+        this.measurementsCache.length === 0 && (this.measurementsCache = this.options.initialMeasurementsCache, this.measurementsCache.forEach((u) => {
+          this.itemSizeCache.set(u.key, u.size);
+        }));
+        const a = this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
+        this.pendingMeasuredCacheIndexes = [];
+        const d = this.measurementsCache.slice(0, a);
+        for (let u = a; u < e; u++) {
+          const h = o(u), m = this.options.lanes === 1 ? d[u - 1] : this.getFurthestMeasurement(d, u), p = m ? m.end + this.options.gap : t + s, g = i.get(h), c = typeof g == "number" ? g : this.options.estimateSize(u), f = p + c, v = m ? m.lane : u % this.options.lanes;
+          d[u] = {
+            index: u,
+            start: p,
+            size: c,
+            end: f,
+            key: h,
+            lane: v
+          };
+        }
+        return this.measurementsCache = d, d;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getMeasurements",
+        debug: () => this.options.debug
+      }
+    ), this.calculateRange = z(
+      () => [
+        this.getMeasurements(),
+        this.getSize(),
+        this.getScrollOffset(),
+        this.options.lanes
+      ],
+      (e, t, s, o) => this.range = e.length > 0 && t > 0 ? mt({
+        measurements: e,
+        outerSize: t,
+        scrollOffset: s,
+        lanes: o
+      }) : null,
+      {
+        key: process.env.NODE_ENV !== "production" && "calculateRange",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualIndexes = z(
+      () => {
+        let e = null, t = null;
+        const s = this.calculateRange();
+        return s && (e = s.startIndex, t = s.endIndex), this.maybeNotify.updateDeps([this.isScrolling, e, t]), [
+          this.options.rangeExtractor,
+          this.options.overscan,
+          this.options.count,
+          e,
+          t
+        ];
+      },
+      (e, t, s, o, n) => o === null || n === null ? [] : e({
+        startIndex: o,
+        endIndex: n,
+        overscan: t,
+        count: s
+      }),
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+        debug: () => this.options.debug
+      }
+    ), this.indexFromElement = (e) => {
+      const t = this.options.indexAttribute, s = e.getAttribute(t);
+      return s ? parseInt(s, 10) : (console.warn(
+        `Missing attribute name '${t}={index}' on measured element.`
+      ), -1);
+    }, this._measureElement = (e, t) => {
+      const s = this.indexFromElement(e), o = this.measurementsCache[s];
+      if (!o)
+        return;
+      const n = o.key, i = this.elementsCache.get(n);
+      i !== e && (i && this.observer.unobserve(i), this.observer.observe(e), this.elementsCache.set(n, e)), e.isConnected && this.resizeItem(s, this.options.measureElement(e, t, this));
+    }, this.resizeItem = (e, t) => {
+      const s = this.measurementsCache[e];
+      if (!s)
+        return;
+      const o = this.itemSizeCache.get(s.key) ?? s.size, n = t - o;
+      n !== 0 && ((this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(s, n, this) : s.start < this.getScrollOffset() + this.scrollAdjustments) && (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", n), this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += n,
+        behavior: void 0
+      })), this.pendingMeasuredCacheIndexes.push(s.index), this.itemSizeCache = new Map(this.itemSizeCache.set(s.key, t)), this.notify(!1));
+    }, this.measureElement = (e) => {
+      if (!e) {
+        this.elementsCache.forEach((t, s) => {
+          t.isConnected || (this.observer.unobserve(t), this.elementsCache.delete(s));
+        });
+        return;
+      }
+      this._measureElement(e, void 0);
+    }, this.getVirtualItems = z(
+      () => [this.getVirtualIndexes(), this.getMeasurements()],
+      (e, t) => {
+        const s = [];
+        for (let o = 0, n = e.length; o < n; o++) {
+          const i = e[o], a = t[i];
+          s.push(a);
+        }
+        return s;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualItemForOffset = (e) => {
+      const t = this.getMeasurements();
+      if (t.length !== 0)
+        return P(
+          t[ge(
+            0,
+            t.length - 1,
+            (s) => P(t[s]).start,
+            e
+          )]
+        );
+    }, this.getOffsetForAlignment = (e, t, s = 0) => {
+      const o = this.getSize(), n = this.getScrollOffset();
+      t === "auto" && (t = e >= n + o ? "end" : "start"), t === "center" ? e += (s - o) / 2 : t === "end" && (e -= o);
+      const i = this.options.horizontal ? "scrollWidth" : "scrollHeight", d = (this.scrollElement ? "document" in this.scrollElement ? this.scrollElement.document.documentElement[i] : this.scrollElement[i] : 0) - o;
+      return Math.max(Math.min(d, e), 0);
+    }, this.getOffsetForIndex = (e, t = "auto") => {
+      e = Math.max(0, Math.min(e, this.options.count - 1));
+      const s = this.measurementsCache[e];
+      if (!s)
+        return;
+      const o = this.getSize(), n = this.getScrollOffset();
+      if (t === "auto")
+        if (s.end >= n + o - this.options.scrollPaddingEnd)
+          t = "end";
+        else if (s.start <= n + this.options.scrollPaddingStart)
+          t = "start";
+        else
+          return [n, t];
+      const i = t === "end" ? s.end + this.options.scrollPaddingEnd : s.start - this.options.scrollPaddingStart;
+      return [
+        this.getOffsetForAlignment(i, t, s.size),
+        t
+      ];
+    }, this.isDynamicMode = () => this.elementsCache.size > 0, this.cancelScrollToIndex = () => {
+      this.scrollToIndexTimeoutId !== null && this.targetWindow && (this.targetWindow.clearTimeout(this.scrollToIndexTimeoutId), this.scrollToIndexTimeoutId = null);
+    }, this.scrollToOffset = (e, { align: t = "start", behavior: s } = {}) => {
+      this.cancelScrollToIndex(), s === "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: s
+      });
+    }, this.scrollToIndex = (e, { align: t = "auto", behavior: s } = {}) => {
+      e = Math.max(0, Math.min(e, this.options.count - 1)), this.cancelScrollToIndex(), s === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      );
+      const o = this.getOffsetForIndex(e, t);
+      if (!o) return;
+      const [n, i] = o;
+      this._scrollToOffset(n, { adjustments: void 0, behavior: s }), s !== "smooth" && this.isDynamicMode() && this.targetWindow && (this.scrollToIndexTimeoutId = this.targetWindow.setTimeout(() => {
+        if (this.scrollToIndexTimeoutId = null, this.elementsCache.has(
+          this.options.getItemKey(e)
+        )) {
+          const [d] = P(
+            this.getOffsetForIndex(e, i)
+          );
+          ot(d, this.getScrollOffset()) || this.scrollToIndex(e, { align: i, behavior: s });
+        } else
+          this.scrollToIndex(e, { align: i, behavior: s });
+      }));
+    }, this.scrollBy = (e, { behavior: t } = {}) => {
+      this.cancelScrollToIndex(), 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 s;
+      if (t.length === 0)
+        s = this.options.paddingStart;
+      else if (this.options.lanes === 1)
+        s = ((e = t[t.length - 1]) == null ? void 0 : e.end) ?? 0;
+      else {
+        const o = Array(this.options.lanes).fill(null);
+        let n = t.length - 1;
+        for (; n >= 0 && o.some((i) => i === null); ) {
+          const i = t[n];
+          o[i.lane] === null && (o[i.lane] = i.end), n--;
+        }
+        s = Math.max(...o.filter((i) => i !== null));
+      }
+      return Math.max(
+        s - this.options.scrollMargin + this.options.paddingEnd,
+        0
+      );
+    }, this._scrollToOffset = (e, {
+      adjustments: t,
+      behavior: s
+    }) => {
+      this.options.scrollToFn(e, { behavior: s, adjustments: t }, this);
+    }, this.measure = () => {
+      this.itemSizeCache = /* @__PURE__ */ new Map(), this.notify(!1);
+    }, this.setOptions(l);
+  }
+}
+const ge = (r, l, e, t) => {
+  for (; r <= l; ) {
+    const s = (r + l) / 2 | 0, o = e(s);
+    if (o < t)
+      r = s + 1;
+    else if (o > t)
+      l = s - 1;
+    else
+      return s;
+  }
+  return r > 0 ? r - 1 : 0;
+};
+function mt({
+  measurements: r,
+  outerSize: l,
+  scrollOffset: e,
+  lanes: t
+}) {
+  const s = r.length - 1, o = (a) => r[a].start;
+  if (r.length <= t)
+    return {
+      startIndex: 0,
+      endIndex: s
+    };
+  let n = ge(
+    0,
+    s,
+    o,
+    e
+  ), i = n;
+  if (t === 1)
+    for (; i < s && r[i].end < e + l; )
+      i++;
+  else if (t > 1) {
+    const a = Array(t).fill(0);
+    for (; i < s && a.some((u) => u < e + l); ) {
+      const u = r[i];
+      a[u.lane] = u.end, i++;
+    }
+    const d = Array(t).fill(e + l);
+    for (; n >= 0 && d.some((u) => u >= e); ) {
+      const u = r[n];
+      d[u.lane] = u.start, n--;
+    }
+    n = Math.max(0, n - n % t), i = Math.min(s, i + (t - 1 - i % t));
+  }
+  return { startIndex: n, endIndex: i };
+}
+const re = typeof document < "u" ? L.useLayoutEffect : L.useEffect;
+function gt(r) {
+  const l = L.useReducer(() => ({}), {})[1], e = {
+    ...r,
+    onChange: (s, o) => {
+      var n;
+      o ? Be(l) : l(), (n = r.onChange) == null || n.call(r, s, o);
+    }
+  }, [t] = L.useState(
+    () => new ft(e)
+  );
+  return t.setOptions(e), re(() => t._didMount(), []), re(() => t._willUpdate()), t;
+}
+function pt(r) {
+  return gt({
+    observeElementRect: ct,
+    observeElementOffset: ut,
+    scrollToFn: ht,
+    ...r
+  });
+}
+const vt = (r) => r == null ? !0 : Array.isArray(r) || typeof r == "string" ? r.length === 0 : !1, xt = [], Et = [], St = ({
+  data: r = xt,
+  value: l = Et,
+  allowMultiple: e,
+  allowNone: t,
+  replaceOnSingle: s = !1,
+  autoSelectOnNone: o = !1,
+  onChange: n
+}) => {
+  const i = j(null), a = J({ triggers: [["Shift"]], loose: !0 }), d = J({ triggers: [["Control"]], loose: !0 }), u = A(l), h = A(r), m = T(
+    (c, f) => {
+      if (u.current = c, c.length === 0 && t !== !1)
+        return n(e !== !1 ? [] : null, f);
+      if (e !== !1) return n(c, f);
+      if (c.length > 0) return n(c[0], f);
+    },
+    [n, t, e]
+  );
+  R(() => {
+    let c = h.current;
+    if (Array.isArray(c) || (c = c()), vt(l) && t === !1 && c.length > 0 && o) {
+      const f = c[0];
+      i.current = f.key, m([f.key], {
+        entries: [f],
+        clicked: f.key,
+        clickedIndex: 0
+      });
+    }
+  }, [m, h, l, t]);
+  const p = T(
+    (c) => {
+      const f = i.current;
+      let v = h.current;
+      Array.isArray(v) || (v = v());
+      let S = [];
+      const E = $e(u.current).filter((C) => C != null);
+      if (e === !1) S = E.includes(c) ? [] : [c];
+      else if (d.current.held && s)
+        E.includes(c) ? S = E.filter((C) => C !== c) : S = [...E, c];
+      else if (a.current.held && f !== null) {
+        const [C, N] = [
+          v.findIndex((I) => I.key === c),
+          v.findIndex((I) => I.key === f)
+        ].sort((I, D) => I - D), b = v.slice(C, N + 1).map(({ key: I }) => I);
+        b.slice(1, b.length - 1).every((I) => E.includes(I)) && E.includes(c) ? S = E.filter((I) => !b.includes(I)) : S = [...E, ...b], i.current = null;
+      } else
+        i.current = c, s ? S = E.includes(c) && E.length === 1 ? [] : [c] : E.includes(c) ? S = E.filter((C) => C !== c) : S = [...E, c];
+      const O = ke.unique(S);
+      if (t === !1 && O.length === 0)
+        return m(E, {
+          entries: v.filter(({ key: C }) => E.includes(C)),
+          clicked: c,
+          clickedIndex: v.findIndex(({ key: C }) => C === c)
+        });
+      O.length === 0 && (i.current = null), m(O, {
+        entries: v.filter(({ key: C }) => S.includes(C)),
+        clicked: c,
+        clickedIndex: v.findIndex(({ key: C }) => C === c)
+      });
+    },
+    [u, h, m, e, t]
+  ), g = T(
+    () => m([], { entries: [], clicked: null, clickedIndex: 0 }),
+    [m]
+  );
+  return { onSelect: p, clear: g };
+}, pe = M({ selected: [] }), ve = M({
+  onSelect: () => {
+  },
+  clear: () => {
+  },
+  getSelected: () => []
+}), xe = () => ae(pe), yt = () => xe().selected, Y = () => ae(ve), Ee = je(
+  ({
+    value: r,
+    children: l,
+    ...e
+  }) => {
+    const t = fe(), { onSelect: s, clear: o } = St({
+      ...e,
+      value: r,
+      data: t
+    }), n = A(r), i = w(
+      () => ({ selected: ee(r) }),
+      [r]
+    ), a = w(
+      () => ({ onSelect: s, clear: o, getSelected: () => ee(n.current) }),
+      [s, o]
+    );
+    return /* @__PURE__ */ x.jsx(ve, { value: a, children: /* @__PURE__ */ x.jsx(pe, { value: i, children: l }) });
+  }
+);
+Ee.displayName = "List.Selector";
+const ns = Ee, Se = ["ArrowUp"], ye = ["ArrowDown"], Ce = ["Enter"], Ct = [Se, ye, Ce], Ie = M({
+  hover: -1,
+  setHover: () => {
+  }
+}), be = () => _(Ie), rs = ({
+  children: r,
+  initialHover: l = -1,
+  disabled: e = !1,
+  onEnter: t
+}) => {
+  const s = fe(), { transformedData: o } = F(), { onSelect: n } = Y(), [i, a, d] = $(l), u = j(l);
+  R(() => {
+    e && (u.current = i), a(e ? -1 : u.current);
+  }, [e]), R(() => {
+    i >= o.length && a(0);
+  }, [o.length]);
+  const h = j(null), m = T(
+    ({ triggers: g, stage: c }) => {
+      if (h.current != null && (clearInterval(h.current), h.current = null), c !== "start" || e) return;
+      const f = s();
+      if (W(g, [Ce])) {
+        if (d.current === -1) return;
+        t == null || t(f[d.current].key), n == null || n(f[d.current].key);
+        return;
+      }
+      const v = () => {
+        const S = s();
+        W(g, [Se], { loose: !0 }) ? a((E) => E <= 0 ? S.length - 1 : E - 1) : W(g, [ye], { loose: !0 }) && a((E) => E >= S.length - 1 ? 0 : E + 1);
+      };
+      v(), h.current = setTimeout(() => {
+        h.current = setInterval(v, 100);
+      }, 200);
+    },
+    [n, e]
+  );
+  Pe({ triggers: Ct, callback: m, loose: !0 });
+  const p = w(
+    () => ({ hover: i, setHover: a }),
+    [i, a]
+  );
+  return /* @__PURE__ */ x.jsx(Ie, { value: p, children: r });
+}, Te = M({
+  hasMore: !1,
+  onFetchMore: () => {
+  }
+}), we = M({
+  setHasMore: () => {
+  },
+  setOnFetchMore: () => {
+  }
+}), It = () => _(Te), os = () => _(we), bt = ({ children: r }) => {
+  const [l, e] = k(!1), [t, s] = ze(
+    () => {
+    }
+  ), o = T(() => {
+    var a;
+    (a = t.current) == null || a.call(t);
+  }, [t]), n = w(
+    () => ({ hasMore: l, onFetchMore: o }),
+    [l, o]
+  ), i = w(
+    () => ({
+      setHasMore: e,
+      setOnFetchMore: (a) => {
+        s(() => a);
+      }
+    }),
+    [e, s]
+  );
+  return /* @__PURE__ */ x.jsx(Te, { value: n, children: /* @__PURE__ */ x.jsx(we, { value: i, children: r }) });
+}, Tt = (r, l, e) => {
+  var n;
+  const t = r > l ? 1 : -1;
+  let s;
+  const o = r + t * 2;
+  G.contains({ lower: 0, upper: e.children.length }, o) ? s = r + t * 2 : s = r, (n = e.children[s]) == null || n.scrollIntoView({
+    block: "nearest",
+    inline: "nearest",
+    behavior: "smooth"
+  });
+}, wt = ({
+  itemHeight: r,
+  children: l,
+  overscan: e = 0,
+  className: t,
+  ...s
+}) => {
+  var N;
+  const { hasMore: o, onFetchMore: n } = It(), { hover: i, setHover: a } = be(), {
+    transformedData: d,
+    emptyContent: u,
+    transformed: h,
+    sourceData: m
+  } = F(), p = yt(), { onSelect: g } = Y(), c = j(null), f = pt({
+    count: d.length,
+    getScrollElement: () => c.current,
+    estimateSize: () => r,
+    overscan: e
+  }), v = ie(d);
+  ce(() => {
+    v == null || v.length === 0 || d.length > 0 && d[0].key !== v[0].key && (f == null || f.scrollToIndex(0), a(0));
+  }, [d]), R(() => {
+    if (c.current == null) return;
+    const b = f.calculateRange();
+    if (b == null) return;
+    const I = G.construct(b.startIndex + 2, b.endIndex - 2);
+    G.contains(I, i) || f.scrollToIndex(i);
+  }, [i, r]);
+  const S = f.getVirtualItems(), E = (N = S.at(-1)) == null ? void 0 : N.index, O = d.length;
+  if (R(() => {
+    E === O - 1 && o && (n == null || n());
+  }, [E, O, o]), r <= 0) throw new Error("itemHeight must be greater than 0");
+  const C = d.length === 0;
+  return /* @__PURE__ */ x.jsx(
+    "div",
+    {
+      ref: c,
+      className: y(
+        t,
+        y.BE("list", "container"),
+        C && y.BM("list", "empty")
+      ),
+      ...s,
+      children: C ? u : /* @__PURE__ */ x.jsx(
+        "div",
+        {
+          className: y.BE("list", "virtualizer"),
+          style: { height: f.getTotalSize() },
+          children: S.map(({ index: b, start: I }) => {
+            const D = d[b];
+            let Z = b;
+            return h && (Z = m.findIndex((De) => De.key === D.key)), l({
+              key: D.key,
+              sourceIndex: Z,
+              index: b,
+              onSelect: g,
+              entry: D,
+              selected: p.includes(D.key),
+              hovered: b === i,
+              translate: I
+            });
+          })
+        }
+      )
+    }
+  );
+}, Mt = ({
+  itemHeight: r = 50,
+  className: l,
+  children: e,
+  ...t
+}) => {
+  const {
+    transformedData: s,
+    transformed: o,
+    emptyContent: n,
+    sourceData: i
+  } = F(), { hover: a } = be(), { selected: d } = xe(), { onSelect: u } = Y(), h = j(null), m = ie(a) ?? 0;
+  ce(() => {
+    h.current != null && Tt(a, m, h.current);
+  }, [a, r]);
+  const p = T(
+    (g, c) => {
+      let f = i.findIndex((v) => v.key === g.key);
+      return o && (f = i.findIndex((v) => v.key === g.key)), e({
+        key: g.key,
+        index: c,
+        sourceIndex: f,
+        onSelect: u,
+        entry: g,
+        selected: d.includes(g.key),
+        hovered: c === a
+      });
+    },
+    [e, o, d, a, i]
+  );
+  return /* @__PURE__ */ x.jsx(
+    q,
+    {
+      className: y(l, y.BE("list", "container")),
+      ref: h,
+      size: 0,
+      ...t,
+      children: s.length === 0 ? n : /* @__PURE__ */ x.jsx(x.Fragment, { children: s.map((g, c) => p(g, c)) })
+    }
+  );
+};
+Mt.Virtual = wt;
+const is = ({
+  children: r,
+  data: l,
+  emptyContent: e,
+  omit: t
+}) => {
+  const s = Ue(
+    () => t != null ? l == null ? void 0 : l.filter((n) => !t.includes(n.key)) : l,
+    ([n, i], [a, d]) => {
+      let u;
+      return n != null && a != null ? u = U.unorderedPrimitiveArrays(n, a) === U.EQUAL : u = n == a, i === d && u;
+    },
+    [t, l]
+  ), o = typeof e == "string" ? /* @__PURE__ */ x.jsx(oe, { level: "p", children: e }) : e;
+  return /* @__PURE__ */ x.jsx(bt, { children: /* @__PURE__ */ x.jsx(Ze, { data: s, emptyContent: o, children: r }) });
+}, Me = M([]), Oe = M(() => {
+}), Ot = 0.9, ls = ({ children: r, maxHistory: l = 500 }) => {
+  const [{ path: e }, { statuses: t }, s] = Ve({
+    type: Ge.TYPE,
+    schema: He,
+    initialState: { statuses: [] }
+  });
+  if (t.length > l) {
+    const n = Math.floor(l * Ot);
+    s((i) => ({ ...i, statuses: t.slice(0, n) }));
+  }
+  const o = T(
+    (n) => {
+      const i = { time: H.now(), key: _e.create(), ...n };
+      s((a) => ({ ...a, statuses: [i, ...a.statuses] }));
+    },
+    [s]
+  );
+  return /* @__PURE__ */ x.jsx(Me, { value: t, children: /* @__PURE__ */ x.jsx(Oe, { value: o, children: /* @__PURE__ */ x.jsx(Le, { path: e, children: r }) }) });
+}, Rt = () => _(Oe), as = () => {
+  const r = Rt();
+  return w(() => qe(r), [r]);
+}, Dt = le.seconds(7), zt = le.seconds(1), cs = ({
+  expiration: r = Dt,
+  poll: l = zt
+} = {}) => {
+  const e = _(Me), [t, s] = k(/* @__PURE__ */ new Set()), [o, n] = k(() => H.now());
+  R(() => {
+    const u = setInterval(() => n(H.now()), l.milliseconds);
+    return () => clearInterval(u);
+  }, [l.milliseconds]);
+  const i = w(() => {
+    const u = o.sub(r), m = e.filter(
+      ({ key: p, time: g }) => g.afterEq(u) && !t.has(p)
+    ).reduce((p, g) => {
+      const c = `${g.variant}:${g.message}`;
+      if (!p.has(c))
+        return p.set(c, { ...g, count: 1 }), p;
+      const f = p.get(c);
+      return p.set(c, {
+        ...f,
+        count: f.count + 1,
+        time: g.time.after(f.time) ? g.time : f.time
+      }), p;
+    }, /* @__PURE__ */ new Map());
+    return Array.from(m.values());
+  }, [e, r, t, o]), a = A(e), d = T((u) => {
+    s((h) => {
+      const m = /* @__PURE__ */ new Set(), p = a.current.find(({ key: g }) => g === u);
+      return h.has(u) || m.add(u), p != null && a.current.filter(
+        ({ message: c, variant: f }) => c === p.message && f === p.variant
+      ).forEach((c) => m.add(c.key)), m.size == 0 ? h : /* @__PURE__ */ new Set([...m, ...h]);
+    });
+  }, []);
+  return { statuses: i, silence: d };
+}, At = {
+  info: "var(--pluto-text-color)",
+  error: "var(--pluto-error-z)",
+  warning: "var(--pluto-warning-m1)",
+  success: "var(--pluto-primary-z)",
+  loading: "var(--pluto-text-color)",
+  disabled: "var(--pluto-gray-l8)",
+  secondary: "var(--pluto-secondary-z)"
+}, Re = ({
+  variant: r = "info",
+  level: l = "p",
+  hideIcon: e = !1,
+  className: t,
+  ...s
+}) => {
+  let o;
+  return e || (o = r === "loading" ? /* @__PURE__ */ x.jsx(V.Loading, {}) : /* @__PURE__ */ x.jsx(V.Circle, {})), /* @__PURE__ */ x.jsx(
+    ue,
+    {
+      color: At[r],
+      className: y(t, y.B("status-text")),
+      level: l,
+      startIcon: o,
+      ...s
+    }
+  );
+}, kt = ({ style: r, ...l }) => /* @__PURE__ */ x.jsx(Ke, { style: r, grow: !0, children: /* @__PURE__ */ x.jsx(Re, { ...l }) }), us = Object.assign(Re, { Centered: kt });
+export {
+  ls as A,
+  Mt as C,
+  Ze as D,
+  rs as H,
+  Qe as I,
+  is as L,
+  ns as S,
+  us as T,
+  At as V,
+  X as a,
+  os as b,
+  ss as c,
+  F as d,
+  fe as e,
+  be as f,
+  St as g,
+  yt as h,
+  xe as i,
+  ts as j,
+  Ye as k,
+  es as l,
+  Rt as m,
+  as as n,
+  cs as o,
+  Xe as p,
+  vt as s,
+  Y as u
+};