@synnaxlabs/pluto 0.38.2 → 0.39.0

package/dist/Text-DT2rIwXL.js

@@ -0,0 +1,1199 @@
+import { j as p } from "./jsx-runtime-CYK1ROHF.js";
+import { g as U, f as A, E as V, T as oe, d as De, h as ie } from "./Divider-C5m3c4pv.js";
+import { v as Ae, F as $, e as _e, i as le, R as ke, m as H } from "./state-w46WTrh-.js";
+import * as W from "react";
+import { useState as _, useCallback as T, use as k, createContext as w, useEffect as O, useMemo as M, useRef as j, memo as je, useContext as ae, useLayoutEffect as ce } from "react";
+import "./Pack-D50qN0Vu.js";
+import { S as q } from "./Space-DBmhvGQL.js";
+import { C as S, J as G } from "./css-rxwBYwM1.js";
+import { a as Fe, C as Ne } from "./ContextMenu-DX6j7Wwi.js";
+import { d as J } from "./dimensions-Bt1NqWz6.js";
+import { W as ue } from "./WithIcon-C6COgbZq.js";
+import { c as Ve, C as We } from "./Provider-CCZPt2M5.js";
+import "./provider-DfVWtUxZ.js";
+import { u as Le } from "./font-CD9W5Tsh.js";
+import { flushSync as Be } from "react-dom";
+import { s as Q, m as L, a as Pe } from "./hooks-CwSxEEAh.js";
+import { A as Ue, o as ee } from "./toArray-Dvn9FA_3.js";
+import { u as $e } from "./useMemoCompare-B-Y9Ft2w.js";
+import { a as He, A as Ge, c as qe } from "./aggregator-5XpEdQtr.js";
+import { C as Ke } from "./Center-DoAxDY5V.js";
+const Xe = ({
+  transforms: n = []
+}) => {
+  const [l, e] = _(n), t = T(
+    (r, i, a = 0) => e((h) => {
+      const c = h.filter((v) => v.key !== r);
+      return c.push({ key: r, transform: i, priority: a }), c.sort((v, u) => u.priority - v.priority), c;
+    }),
+    [e]
+  ), s = T(
+    (r) => e((i) => i.filter((a) => a.key !== r)),
+    [t]
+  );
+  return { transform: T(
+    (r) => l.reduce((i, a) => a.transform(i), {
+      ...r,
+      transformed: !1
+    }),
+    [l]
+  ), setTransform: t, deleteTransform: s };
+}, K = (n) => {
+  const l = k(n);
+  if (l === null) throw new Error("useRequiredContext: context value is null");
+  return l;
+}, de = w({
+  transformedData: [],
+  sourceData: [],
+  transformed: !1
+}), he = w({
+  setSourceData: () => {
+  },
+  getSourceData: () => [],
+  getTransformedData: () => [],
+  deleteTransform: () => {
+  },
+  setTransform: () => {
+  },
+  setEmptyContent: () => {
+  },
+  getEmptyContent: () => {
+  },
+  getDefaultEmptyContent: () => {
+  },
+  getTransformed: () => !1
+}), F = () => K(de), X = () => K(he), Qt = () => F().transformedData, Ye = () => F().sourceData, fe = () => X().getTransformedData, es = () => X().setSourceData, Ze = ({
+  data: n,
+  emptyContent: l,
+  children: e
+}) => {
+  const { transform: t, setTransform: s, deleteTransform: o } = Xe({}), [r, i, a] = U(() => n ?? []);
+  O(() => {
+    n != null && i(n);
+  }, [n]);
+  const h = M(
+    () => t({ data: [...r], transformed: !1 }),
+    [r, t]
+  ), c = A(h), v = A(
+    l
+  ), [u, m, g] = U(void 0);
+  O(() => {
+    l != null && m(l);
+  }, [l]);
+  const d = M(
+    () => ({
+      setSourceData: i,
+      getSourceData: () => a.current,
+      getTransformedData: () => c.current.data,
+      getTransformed: () => c.current.transformed,
+      deleteTransform: o,
+      setTransform: s,
+      setEmptyContent: m,
+      getEmptyContent: () => g.current,
+      getDefaultEmptyContent: () => v.current
+    }),
+    [i, a, c, o, s]
+  ), f = M(
+    () => ({
+      transformed: h.transformed,
+      transformedData: h.data,
+      sourceData: r,
+      emptyContent: u
+    }),
+    [h, r, u]
+  );
+  return /* @__PURE__ */ p.jsx(he, { value: d, children: /* @__PURE__ */ p.jsx(de, { value: f, children: e }) });
+}, Je = ({
+  entry: n,
+  selected: l,
+  hovered: e,
+  onSelect: t,
+  className: s,
+  draggingOver: o,
+  rightAligned: r = !1,
+  highlightHovered: i = !1,
+  allowSelect: a = !0,
+  translate: h,
+  style: c,
+  sourceIndex: v,
+  ...u
+}) => /* @__PURE__ */ p.jsx(
+  q,
+  {
+    id: n.key.toString(),
+    direction: "x",
+    onClick: () => t == null ? void 0 : t(n.key),
+    tabIndex: 0,
+    className: S(
+      s,
+      Fe,
+      l && Ne,
+      a && S.M("selectable"),
+      e && S.M("hovered"),
+      r && S.M("right-aligned"),
+      i && S.M("highlight-hover"),
+      S.BE("list", "item"),
+      S.selected(l)
+    ),
+    style: {
+      position: h != null ? "absolute" : "relative",
+      transform: `translateY(${h}px)`,
+      ...c
+    },
+    ...u
+  }
+), me = w(null), Qe = () => K(me), B = "sort", et = ({
+  hide: n = !1,
+  columns: l,
+  children: e
+}) => {
+  const t = Ye(), { setTransform: s, deleteTransform: o } = X(), r = Le("p").toString(), [i, a] = _([null, !1]), [h, c] = _({
+    columns: l
+  }), v = (u) => {
+    const [m, g] = i;
+    m === u ? g ? (a([u, !g]), s(B, te(u, !g))) : (a([null, !1]), o(B)) : (a([u, !0]), s(B, te(u, !0)));
+  };
+  return O(() => {
+    c((u) => ({
+      columns: nt(
+        u.columns.length === 0 ? l : u.columns,
+        t,
+        r
+      )
+    }));
+  }, [r, t, l]), /* @__PURE__ */ p.jsxs(me, { value: h, children: [
+    !n && /* @__PURE__ */ p.jsx(
+      q,
+      {
+        direction: "x",
+        size: "medium",
+        className: S(S.BE("list-col-header", "container"), S.visible(!n)),
+        children: h.columns.filter(({ visible: u = !0 }) => u).map(({ key: u, cWidth: m, name: g }) => {
+          const [d, f] = i;
+          let x;
+          const E = t[0];
+          return u === d && (x = f ? /* @__PURE__ */ p.jsx(V.Caret.Up, {}) : /* @__PURE__ */ p.jsx(V.Caret.Down, {})), /* @__PURE__ */ p.jsx(
+            ue,
+            {
+              className: S.BE("list-col-header", "item"),
+              justify: "spaceBetween",
+              level: "p",
+              endIcon: x,
+              style: { width: m },
+              shrink: !1,
+              onClick: () => E != null && u in E && v(u),
+              children: g
+            },
+            u.toString()
+          );
+        })
+      }
+    ),
+    e
+  ] });
+}, tt = ({
+  entry: n,
+  onSelect: l,
+  className: e,
+  ...t
+}) => {
+  const { columns: s } = Qe(), { index: o } = t;
+  return /* @__PURE__ */ p.jsx(
+    Je,
+    {
+      entry: n,
+      onSelect: l,
+      className: S(
+        e,
+        S.BE("list-col-item", "container"),
+        l != null && S.BEM("list-col-item", "container", "selectable")
+      ),
+      align: "center",
+      size: "medium",
+      ...t,
+      children: s.filter(({ visible: r = !0 }) => r).map((r) => /* @__PURE__ */ p.jsx(
+        st,
+        {
+          entry: n,
+          col: r,
+          index: o
+        },
+        r.key.toString()
+      ))
+    },
+    n.key.toString()
+  );
+}, st = ({
+  entry: n,
+  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: n, style: s, index: l });
+  let o;
+  return t.stringer != null ? o = t.stringer(n) : o = n[t.key], /* @__PURE__ */ p.jsx(
+    oe,
+    {
+      className: S.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 = (n, l, e, t = 30) => {
+  const s = rt(l, n);
+  return n.map((o) => {
+    if (o.width != null) o.cWidth = o.width;
+    else {
+      const { width: r } = J(o.name, e), { width: i } = J(s[o.key], e);
+      o.cWidth = Math.max(r, i) + t;
+    }
+    return o;
+  });
+}, rt = (n, l) => {
+  const e = {};
+  return n.forEach(
+    (t) => l.forEach(({ key: s, stringer: o }) => {
+      const r = t[s];
+      if (r == null) return;
+      const i = o != null ? o(t) : r.toString();
+      (!(s in e) || i.length > e[s].length) && (e[s] = i);
+    })
+  ), e;
+}, te = (n, l) => ({ data: e }) => e.length === 0 ? { data: e, transformed: !1 } : {
+  data: [...e].sort($.newFieldF(n, e[0], !l)),
+  transformed: !0
+}, ts = {
+  /**
+   * 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 D(n, l, e) {
+  let t = e.initialDeps ?? [], s;
+  return () => {
+    var o, r, i, a;
+    let h;
+    e.key && ((o = e.debug) != null && o.call(e)) && (h = Date.now());
+    const c = n();
+    if (!(c.length !== t.length || c.some((m, g) => t[g] !== m)))
+      return s;
+    t = c;
+    let u;
+    if (e.key && ((r = e.debug) != null && r.call(e)) && (u = Date.now()), s = l(...c), e.key && ((i = e.debug) != null && i.call(e))) {
+      const m = Math.round((Date.now() - h) * 100) / 100, g = Math.round((Date.now() - u) * 100) / 100, d = g / 16, f = (x, E) => {
+        for (x = String(x); x.length < E; )
+          x = " " + x;
+        return x;
+      };
+      console.info(
+        `%c⏱ ${f(g, 5)} /${f(m, 5)} ms`,
+        `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(
+          0,
+          Math.min(120 - 120 * d, 120)
+        )}deg 100% 31%);`,
+        e == null ? void 0 : e.key
+      );
+    }
+    return (a = e == null ? void 0 : e.onChange) == null || a.call(e, s), s;
+  };
+}
+function P(n, l) {
+  if (n === void 0)
+    throw new Error("Unexpected undefined");
+  return n;
+}
+const ot = (n, l) => Math.abs(n - l) < 1, it = (n, l, e) => {
+  let t;
+  return function(...s) {
+    n.clearTimeout(t), t = n.setTimeout(() => l.apply(this, s), e);
+  };
+}, lt = (n) => n, at = (n) => {
+  const l = Math.max(n.startIndex - n.overscan, 0), e = Math.min(n.endIndex + n.overscan, n.count - 1), t = [];
+  for (let s = l; s <= e; s++)
+    t.push(s);
+  return t;
+}, ct = (n, l) => {
+  const e = n.scrollElement;
+  if (!e)
+    return;
+  const t = n.targetWindow;
+  if (!t)
+    return;
+  const s = (r) => {
+    const { width: i, height: a } = r;
+    l({ width: Math.round(i), height: Math.round(a) });
+  };
+  if (s(e.getBoundingClientRect()), !t.ResizeObserver)
+    return () => {
+    };
+  const o = new t.ResizeObserver((r) => {
+    const i = () => {
+      const a = r[0];
+      if (a != null && a.borderBoxSize) {
+        const h = a.borderBoxSize[0];
+        if (h) {
+          s({ width: h.inlineSize, height: h.blockSize });
+          return;
+        }
+      }
+      s(e.getBoundingClientRect());
+    };
+    n.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 = (n, l) => {
+  const e = n.scrollElement;
+  if (!e)
+    return;
+  const t = n.targetWindow;
+  if (!t)
+    return;
+  let s = 0;
+  const o = n.options.useScrollendEvent && ne ? () => {
+  } : it(
+    t,
+    () => {
+      l(s, !1);
+    },
+    n.options.isScrollingResetDelay
+  ), r = (c) => () => {
+    const { horizontal: v, isRtl: u } = n.options;
+    s = v ? e.scrollLeft * (u && -1 || 1) : e.scrollTop, o(), l(s, c);
+  }, i = r(!0), a = r(!1);
+  a(), e.addEventListener("scroll", i, se);
+  const h = n.options.useScrollendEvent && ne;
+  return h && e.addEventListener("scrollend", a, se), () => {
+    e.removeEventListener("scroll", i), h && e.removeEventListener("scrollend", a);
+  };
+}, dt = (n, 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(
+    n.getBoundingClientRect()[e.options.horizontal ? "width" : "height"]
+  );
+}, ht = (n, {
+  adjustments: l = 0,
+  behavior: e
+}, t) => {
+  var s, o;
+  const r = n + l;
+  (o = (s = t.scrollElement) == null ? void 0 : s.scrollTo) == null || o.call(s, {
+    [t.options.horizontal ? "left" : "top"]: r,
+    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 r = () => {
+            this._measureElement(o.target, o);
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(r) : r();
+        });
+      }));
+      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: !0,
+        useAnimationFrameWithResizeObserver: !1,
+        ...e
+      };
+    }, this.notify = (e) => {
+      var t, s;
+      (s = (t = this.options).onChange) == null || s.call(t, this, e);
+    }, this.maybeNotify = D(
+      () => (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 r = t - 1; r >= 0; r--) {
+        const i = e[r];
+        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((r, i) => r.end === i.end ? r.index - i.index : r.end - i.end)[0] : void 0;
+    }, this.getMeasurementOptions = D(
+      () => [
+        this.options.count,
+        this.options.paddingStart,
+        this.options.scrollMargin,
+        this.options.getItemKey,
+        this.options.enabled
+      ],
+      (e, t, s, o, r) => (this.pendingMeasuredCacheIndexes = [], {
+        count: e,
+        paddingStart: t,
+        scrollMargin: s,
+        getItemKey: o,
+        enabled: r
+      }),
+      {
+        key: !1
+      }
+    ), this.getMeasurements = D(
+      () => [this.getMeasurementOptions(), this.itemSizeCache],
+      ({ count: e, paddingStart: t, scrollMargin: s, getItemKey: o, enabled: r }, i) => {
+        if (!r)
+          return this.measurementsCache = [], this.itemSizeCache.clear(), [];
+        this.measurementsCache.length === 0 && (this.measurementsCache = this.options.initialMeasurementsCache, this.measurementsCache.forEach((c) => {
+          this.itemSizeCache.set(c.key, c.size);
+        }));
+        const a = this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
+        this.pendingMeasuredCacheIndexes = [];
+        const h = this.measurementsCache.slice(0, a);
+        for (let c = a; c < e; c++) {
+          const v = o(c), u = this.options.lanes === 1 ? h[c - 1] : this.getFurthestMeasurement(h, c), m = u ? u.end + this.options.gap : t + s, g = i.get(v), d = typeof g == "number" ? g : this.options.estimateSize(c), f = m + d, x = u ? u.lane : c % this.options.lanes;
+          h[c] = {
+            index: c,
+            start: m,
+            size: d,
+            end: f,
+            key: v,
+            lane: x
+          };
+        }
+        return this.measurementsCache = h, h;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getMeasurements",
+        debug: () => this.options.debug
+      }
+    ), this.calculateRange = D(
+      () => [
+        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 = D(
+      () => {
+        let e = null, t = null;
+        const s = this.calculateRange();
+        return s && (e = s.startIndex, t = s.endIndex), [
+          this.options.rangeExtractor,
+          this.options.overscan,
+          this.options.count,
+          e,
+          t
+        ];
+      },
+      (e, t, s, o, r) => o === null || r === null ? [] : e({
+        startIndex: o,
+        endIndex: r,
+        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 r = o.key, i = this.elementsCache.get(r);
+      i !== e && (i && this.observer.unobserve(i), this.observer.observe(e), this.elementsCache.set(r, 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, r = t - o;
+      r !== 0 && ((this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(s, r, this) : s.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(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 = D(
+      () => [this.getVirtualIndexes(), this.getMeasurements()],
+      (e, t) => {
+        const s = [];
+        for (let o = 0, r = e.length; o < r; 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(), r = this.getScrollOffset();
+      t === "auto" && (t = e >= r + o ? "end" : "start"), t === "center" ? e += (s - o) / 2 : t === "end" && (e -= o);
+      const i = this.options.horizontal ? "scrollWidth" : "scrollHeight", h = (this.scrollElement ? "document" in this.scrollElement ? this.scrollElement.document.documentElement[i] : this.scrollElement[i] : 0) - o;
+      return Math.max(Math.min(h, 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(), r = this.getScrollOffset();
+      if (t === "auto")
+        if (s.end >= r + o - this.options.scrollPaddingEnd)
+          t = "end";
+        else if (s.start <= r + this.options.scrollPaddingStart)
+          t = "start";
+        else
+          return [r, 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 [r, i] = o;
+      this._scrollToOffset(r, { 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 [h] = P(
+            this.getOffsetForIndex(e, i)
+          );
+          ot(h, 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;
+      return t.length === 0 ? s = this.options.paddingStart : s = this.options.lanes === 1 ? ((e = t[t.length - 1]) == null ? void 0 : e.end) ?? 0 : Math.max(
+        ...t.slice(-this.options.lanes).map((o) => o.end)
+      ), 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 = (n, l, e, t) => {
+  for (; n <= l; ) {
+    const s = (n + l) / 2 | 0, o = e(s);
+    if (o < t)
+      n = s + 1;
+    else if (o > t)
+      l = s - 1;
+    else
+      return s;
+  }
+  return n > 0 ? n - 1 : 0;
+};
+function mt({
+  measurements: n,
+  outerSize: l,
+  scrollOffset: e,
+  lanes: t
+}) {
+  const s = n.length - 1;
+  let r = ge(
+    0,
+    s,
+    (a) => n[a].start,
+    e
+  ), i = r;
+  for (; i < s && n[i].end < e + l; )
+    i++;
+  return t > 1 && (r = Math.max(0, r - r % t), i = Math.min(s, i + (t - 1 - i % t))), { startIndex: r, endIndex: i };
+}
+const re = typeof document < "u" ? W.useLayoutEffect : W.useEffect;
+function gt(n) {
+  const l = W.useReducer(() => ({}), {})[1], e = {
+    ...n,
+    onChange: (s, o) => {
+      var r;
+      o ? Be(l) : l(), (r = n.onChange) == null || r.call(n, s, o);
+    }
+  }, [t] = W.useState(
+    () => new ft(e)
+  );
+  return t.setOptions(e), re(() => t._didMount(), []), re(() => t._willUpdate()), t;
+}
+function pt(n) {
+  return gt({
+    observeElementRect: ct,
+    observeElementOffset: ut,
+    scrollToFn: ht,
+    ...n
+  });
+}
+const vt = (n) => n == null ? !0 : Array.isArray(n) || typeof n == "string" ? n.length === 0 : !1, xt = [], Et = [], St = ({
+  data: n = xt,
+  value: l = Et,
+  allowMultiple: e,
+  allowNone: t,
+  replaceOnSingle: s = !1,
+  autoSelectOnNone: o = !1,
+  onChange: r
+}) => {
+  const i = j(null), a = Q({ triggers: [["Shift"]], loose: !0 }), h = Q({ triggers: [["Control"]], loose: !0 }), c = A(l), v = A(n), u = T(
+    (d, f) => {
+      if (c.current = d, d.length === 0 && t !== !1)
+        return r(e !== !1 ? [] : null, f);
+      if (e !== !1) return r(d, f);
+      if (d.length > 0) return r(d[0], f);
+    },
+    [r, t, e]
+  );
+  O(() => {
+    let d = v.current;
+    if (Array.isArray(d) || (d = d()), vt(l) && t === !1 && d.length > 0 && o) {
+      const f = d[0];
+      i.current = f.key, u([f.key], {
+        entries: [f],
+        clicked: f.key,
+        clickedIndex: 0
+      });
+    }
+  }, [u, v, l, t]);
+  const m = T(
+    (d) => {
+      const f = i.current;
+      let x = v.current;
+      Array.isArray(x) || (x = x());
+      let E = [];
+      const y = Ue(c.current).filter((C) => C != null);
+      if (e === !1) E = y.includes(d) ? [] : [d];
+      else if (h.current.held && s)
+        y.includes(d) ? E = y.filter((C) => C !== d) : E = [...y, d];
+      else if (a.current.held && f !== null) {
+        const [C, N] = [
+          x.findIndex((I) => I.key === d),
+          x.findIndex((I) => I.key === f)
+        ].sort((I, z) => I - z), b = x.slice(C, N + 1).map(({ key: I }) => I);
+        b.slice(1, b.length - 1).every((I) => y.includes(I)) && y.includes(d) ? E = y.filter((I) => !b.includes(I)) : E = [...y, ...b], i.current = null;
+      } else
+        i.current = d, s ? E = y.includes(d) && y.length === 1 ? [] : [d] : y.includes(d) ? E = y.filter((C) => C !== d) : E = [...y, d];
+      const R = _e.unique(E);
+      if (t === !1 && R.length === 0)
+        return u(y, {
+          entries: x.filter(({ key: C }) => y.includes(C)),
+          clicked: d,
+          clickedIndex: x.findIndex(({ key: C }) => C === d)
+        });
+      R.length === 0 && (i.current = null), u(R, {
+        entries: x.filter(({ key: C }) => E.includes(C)),
+        clicked: d,
+        clickedIndex: x.findIndex(({ key: C }) => C === d)
+      });
+    },
+    [c, v, u, e, t]
+  ), g = T(
+    () => u([], { entries: [], clicked: null, clickedIndex: 0 }),
+    [u]
+  );
+  return { onSelect: m, clear: g };
+}, pe = w({ selected: [] }), ve = w({
+  onSelect: () => {
+  },
+  clear: () => {
+  },
+  getSelected: () => []
+}), xe = () => ae(pe), yt = () => xe().selected, Y = () => ae(ve), Ee = je(
+  ({
+    value: n,
+    children: l,
+    ...e
+  }) => {
+    const t = fe(), { onSelect: s, clear: o } = St({
+      ...e,
+      value: n,
+      data: t
+    }), r = A(n), i = M(
+      () => ({ selected: ee(n) }),
+      [n]
+    ), a = M(
+      () => ({ onSelect: s, clear: o, getSelected: () => ee(r.current) }),
+      [s, o]
+    );
+    return /* @__PURE__ */ p.jsx(ve, { value: a, children: /* @__PURE__ */ p.jsx(pe, { value: i, children: l }) });
+  }
+);
+Ee.displayName = "List.Selector";
+const ss = Ee, Se = ["ArrowUp"], ye = ["ArrowDown"], Ce = ["Enter"], Ct = [Se, ye, Ce], Ie = w({
+  hover: -1,
+  setHover: () => {
+  }
+}), be = () => k(Ie), ns = ({
+  children: n,
+  initialHover: l = -1,
+  disabled: e = !1
+}) => {
+  const t = fe(), { transformedData: s } = F(), { onSelect: o } = Y(), [r, i, a] = U(l), h = j(l);
+  O(() => {
+    e && (h.current = r), i(e ? -1 : h.current);
+  }, [e]), O(() => {
+    r >= s.length && i(0);
+  }, [s.length]);
+  const c = j(null), v = T(
+    ({ triggers: m, stage: g }) => {
+      if (c.current != null && (clearInterval(c.current), c.current = null), g !== "start" || e) return;
+      const d = t();
+      if (L(m, [Ce])) {
+        if (a.current === -1) return;
+        o == null || o(d[a.current].key);
+        return;
+      }
+      const f = () => {
+        const x = t();
+        L(m, [Se], { loose: !0 }) ? i((E) => E <= 0 ? x.length - 1 : E - 1) : L(m, [ye], { loose: !0 }) && i((E) => E >= x.length - 1 ? 0 : E + 1);
+      };
+      f(), c.current = setTimeout(() => {
+        c.current = setInterval(f, 100);
+      }, 200);
+    },
+    [o, e]
+  );
+  Pe({ triggers: Ct, callback: v, loose: !0 });
+  const u = M(
+    () => ({ hover: r, setHover: i }),
+    [r, i]
+  );
+  return /* @__PURE__ */ p.jsx(Ie, { value: u, children: n });
+}, Te = w({
+  hasMore: !1,
+  onFetchMore: () => {
+  }
+}), Me = w({
+  setHasMore: () => {
+  },
+  setOnFetchMore: () => {
+  }
+}), It = () => k(Te), rs = () => k(Me), bt = ({ children: n }) => {
+  const [l, e] = _(!1), [t, s] = De(
+    () => {
+    }
+  ), o = T(() => {
+    var a;
+    (a = t.current) == null || a.call(t);
+  }, [t]), r = M(
+    () => ({ hasMore: l, onFetchMore: o }),
+    [l, o]
+  ), i = M(
+    () => ({
+      setHasMore: e,
+      setOnFetchMore: (a) => {
+        s(() => a);
+      }
+    }),
+    [e, s]
+  );
+  return /* @__PURE__ */ p.jsx(Te, { value: r, children: /* @__PURE__ */ p.jsx(Me, { value: i, children: n }) });
+}, Tt = (n, l, e) => {
+  var r;
+  const t = n > l ? 1 : -1;
+  let s;
+  const o = n + t * 2;
+  G.contains({ lower: 0, upper: e.children.length }, o) ? s = n + t * 2 : s = n, (r = e.children[s]) == null || r.scrollIntoView({
+    block: "nearest",
+    inline: "nearest",
+    behavior: "smooth"
+  });
+}, Mt = ({
+  itemHeight: n,
+  children: l,
+  overscan: e = 0,
+  className: t,
+  ...s
+}) => {
+  var N;
+  const { hasMore: o, onFetchMore: r } = It(), { hover: i, setHover: a } = be(), {
+    transformedData: h,
+    emptyContent: c,
+    transformed: v,
+    sourceData: u
+  } = F(), m = yt(), { onSelect: g } = Y(), d = j(null), f = pt({
+    count: h.length,
+    getScrollElement: () => d.current,
+    estimateSize: () => n,
+    overscan: e
+  }), x = ie(h);
+  ce(() => {
+    x == null || x.length === 0 || h.length > 0 && h[0].key !== x[0].key && (f == null || f.scrollToIndex(0), a(0));
+  }, [h]), O(() => {
+    if (d.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, n]);
+  const E = f.getVirtualItems(), y = (N = E.at(-1)) == null ? void 0 : N.index, R = h.length;
+  if (O(() => {
+    y === R - 1 && o && (r == null || r());
+  }, [y, R, o]), n <= 0) throw new Error("itemHeight must be greater than 0");
+  const C = h.length === 0;
+  return /* @__PURE__ */ p.jsx(
+    "div",
+    {
+      ref: d,
+      className: S(
+        t,
+        S.BE("list", "container"),
+        C && S.BM("list", "empty")
+      ),
+      ...s,
+      children: C ? c : /* @__PURE__ */ p.jsx(
+        "div",
+        {
+          className: S.BE("list", "virtualizer"),
+          style: { height: f.getTotalSize() },
+          children: E.map(({ index: b, start: I }) => {
+            const z = h[b];
+            let Z = b;
+            return v && (Z = u.findIndex((ze) => ze.key === z.key)), l({
+              key: z.key,
+              sourceIndex: Z,
+              index: b,
+              onSelect: g,
+              entry: z,
+              selected: m.includes(z.key),
+              hovered: b === i,
+              translate: I
+            });
+          })
+        }
+      )
+    }
+  );
+}, wt = ({
+  itemHeight: n = 50,
+  className: l,
+  ...e
+}) => {
+  const {
+    transformedData: t,
+    transformed: s,
+    emptyContent: o,
+    sourceData: r
+  } = F(), { hover: i } = be(), { selected: a } = xe(), { onSelect: h } = Y(), c = j(null), v = ie(i) ?? 0;
+  return ce(() => {
+    c.current != null && Tt(i, v, c.current);
+  }, [i, n]), /* @__PURE__ */ p.jsx(
+    q,
+    {
+      className: S(l, S.BE("list", "container")),
+      ref: c,
+      size: 0,
+      ...e,
+      children: t.length === 0 ? o : /* @__PURE__ */ p.jsx(p.Fragment, { children: t.map((u, m) => {
+        let g = m;
+        return s && (g = r.findIndex((d) => d.key === u.key)), e.children({
+          key: u.key,
+          index: m,
+          sourceIndex: g,
+          onSelect: h,
+          entry: u,
+          selected: a.includes(u.key),
+          hovered: m === i
+        });
+      }) })
+    }
+  );
+};
+wt.Virtual = Mt;
+const os = ({
+  children: n,
+  data: l,
+  emptyContent: e,
+  omit: t
+}) => {
+  const s = $e(
+    () => t != null ? l == null ? void 0 : l.filter((r) => !t.includes(r.key)) : l,
+    ([r, i], [a, h]) => {
+      let c;
+      return r != null && a != null ? c = $.unorderedPrimitiveArrays(r, a) === $.EQUAL : c = r == a, i === h && c;
+    },
+    [t, l]
+  ), o = typeof e == "string" ? /* @__PURE__ */ p.jsx(oe, { level: "p", children: e }) : e;
+  return /* @__PURE__ */ p.jsx(bt, { children: /* @__PURE__ */ p.jsx(Ze, { data: s, emptyContent: o, children: n }) });
+}, we = w([]), Oe = w(() => {
+}), Ot = 0.9, is = ({ children: n, maxHistory: l = 500 }) => {
+  const [{ path: e }, { statuses: t }, s] = Ve({
+    type: Ge.TYPE,
+    schema: He,
+    initialState: { statuses: [] }
+  });
+  if (t.length > l) {
+    const r = Math.floor(l * Ot);
+    s((i) => ({ ...i, statuses: t.slice(0, r) }));
+  }
+  const o = T(
+    (r) => {
+      const i = { time: H.now(), key: ke.create(), ...r };
+      s((a) => ({ ...a, statuses: [i, ...a.statuses] }));
+    },
+    [s]
+  );
+  return /* @__PURE__ */ p.jsx(we, { value: t, children: /* @__PURE__ */ p.jsx(Oe, { value: o, children: /* @__PURE__ */ p.jsx(We, { path: e, children: n }) }) });
+}, Rt = () => k(Oe), ls = () => {
+  const n = Rt();
+  return M(() => qe(n), [n]);
+}, zt = le.seconds(7), Dt = le.seconds(1), as = ({
+  expiration: n = zt,
+  poll: l = Dt
+} = {}) => {
+  const e = k(we), [t, s] = _(/* @__PURE__ */ new Set()), [o, r] = _(() => H.now());
+  O(() => {
+    const c = setInterval(() => r(H.now()), l.milliseconds);
+    return () => clearInterval(c);
+  }, [l.milliseconds]);
+  const i = M(() => {
+    const c = o.sub(n), u = e.filter(
+      ({ key: m, time: g }) => g.afterEq(c) && !t.has(m)
+    ).reduce((m, g) => {
+      const d = `${g.variant}:${g.message}`;
+      if (!m.has(d))
+        return m.set(d, { ...g, count: 1 }), m;
+      const f = m.get(d);
+      return m.set(d, {
+        ...f,
+        count: f.count + 1,
+        time: g.time.after(f.time) ? g.time : f.time
+      }), m;
+    }, /* @__PURE__ */ new Map());
+    return Array.from(u.values());
+  }, [e, n, t, o]), a = A(e), h = T((c) => {
+    s((v) => {
+      const u = /* @__PURE__ */ new Set(), m = a.current.find(({ key: g }) => g === c);
+      return v.has(c) || u.add(c), m != null && a.current.filter(
+        ({ message: d, variant: f }) => d === m.message && f === m.variant
+      ).forEach((d) => u.add(d.key)), u.size == 0 ? v : /* @__PURE__ */ new Set([...u, ...v]);
+    });
+  }, []);
+  return { statuses: i, silence: h };
+}, 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-l6)",
+  secondary: "var(--pluto-secondary-z)"
+}, Re = ({
+  variant: n = "info",
+  level: l = "p",
+  hideIcon: e = !1,
+  className: t,
+  ...s
+}) => {
+  let o;
+  return e || (o = n === "loading" ? /* @__PURE__ */ p.jsx(V.Loading, {}) : /* @__PURE__ */ p.jsx(V.Circle, {})), /* @__PURE__ */ p.jsx(
+    ue,
+    {
+      color: At[n],
+      className: S(t, S.B("status-text")),
+      level: l,
+      startIcon: o,
+      ...s
+    }
+  );
+}, _t = ({ style: n, ...l }) => /* @__PURE__ */ p.jsx(Ke, { style: n, grow: !0, children: /* @__PURE__ */ p.jsx(Re, { ...l }) }), cs = Object.assign(Re, { Centered: _t });
+export {
+  is as A,
+  wt as C,
+  Ze as D,
+  ns as H,
+  Je as I,
+  os as L,
+  ss as S,
+  cs as T,
+  X as a,
+  rs as b,
+  ts as c,
+  F as d,
+  fe as e,
+  be as f,
+  St as g,
+  yt as h,
+  xe as i,
+  es as j,
+  Ye as k,
+  Qt as l,
+  Rt as m,
+  ls as n,
+  as as o,
+  Xe as p,
+  vt as s,
+  Y as u,
+  At as v
+};