react-semaphor 0.1.524 → 0.1.526

package/dist/chunks/pre-block-Cq1RqhZX.js

@@ -0,0 +1,3987 @@
+var ms = Object.defineProperty;
+var Sn = (t) => {
+  throw TypeError(t);
+};
+var vs = (t, e, n) => e in t ? ms(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var At = (t, e, n) => vs(t, typeof e != "symbol" ? e + "" : e, n), Bt = (t, e, n) => e.has(t) || Sn("Cannot " + n);
+var c = (t, e, n) => (Bt(t, e, "read from private field"), n ? n.call(t) : e.get(t)), k = (t, e, n) => e.has(t) ? Sn("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, n), P = (t, e, n, r) => (Bt(t, e, "write to private field"), r ? r.call(t, n) : e.set(t, n), n), V = (t, e, n) => (Bt(t, e, "access private method"), n);
+var Et = (t, e, n, r) => ({
+  set _(s) {
+    P(t, e, s, n);
+  },
+  get _() {
+    return c(t, e, r);
+  }
+});
+import { jsx as p, Fragment as It, jsxs as qe } from "react/jsx-runtime";
+import * as w from "react";
+import bs, { useId as xs, useState as ve, useContext as ln, createContext as cn, useMemo as St, forwardRef as Zn, createElement as at, useRef as te, useLayoutEffect as ws, useImperativeHandle as er, useEffect as He, useCallback as ee } from "react";
+import { E as Ss, aT as Cs, Q as tr, aC as un, aD as Ps, J as Ct, K as We, aU as Ds, U as Pt, aV as As, aW as Es, aX as zs, aF as Rs, aY as Ns, I as Is, aB as Ut, c as se, aL as Cn, aZ as nr, a_ as Ms, B as Pn } from "./code-highlight-994tgM9v.js";
+import { j as Os, c as ue } from "./x-CXDkqdur.js";
+import { S as Dn } from "./validators-CsdOtZI6.js";
+import { a5 as ks, Y as Ts } from "./matrix-operation-contract-D32U2CSw.js";
+import { d as _s } from "./card-config-utils-9sv4e-Vb.js";
+import "../value-format-preferences/index.js";
+var Ft = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(t) {
+    return this.listeners.add(t), this.onSubscribe(), () => {
+      this.listeners.delete(t), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, Fs = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (t, e) => setTimeout(t, e),
+  clearTimeout: (t) => clearTimeout(t),
+  setInterval: (t, e) => setInterval(t, e),
+  clearInterval: (t) => clearInterval(t)
+}, pe, Oe, Gn, Ls = (Gn = class {
+  constructor() {
+    // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+    // type at app boot; and if we leave that type, then any new timer provider
+    // would need to support ReturnType<typeof setTimeout>, which is infeasible.
+    //
+    // We settle for type safety for the TimeoutProvider type, and accept that
+    // this class is unsafe internally to allow for extension.
+    k(this, pe, Fs);
+    k(this, Oe, !1);
+  }
+  setTimeoutProvider(t) {
+    process.env.NODE_ENV !== "production" && c(this, Oe) && t !== c(this, pe) && console.error(
+      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
+      { previous: c(this, pe), provider: t }
+    ), P(this, pe, t), process.env.NODE_ENV !== "production" && P(this, Oe, !1);
+  }
+  setTimeout(t, e) {
+    return process.env.NODE_ENV !== "production" && P(this, Oe, !0), c(this, pe).setTimeout(t, e);
+  }
+  clearTimeout(t) {
+    c(this, pe).clearTimeout(t);
+  }
+  setInterval(t, e) {
+    return process.env.NODE_ENV !== "production" && P(this, Oe, !0), c(this, pe).setInterval(t, e);
+  }
+  clearInterval(t) {
+    c(this, pe).clearInterval(t);
+  }
+}, pe = new WeakMap(), Oe = new WeakMap(), Gn), Zt = new Ls();
+function $s(t) {
+  setTimeout(t, 0);
+}
+var Lt = typeof window > "u" || "Deno" in globalThis;
+function ae() {
+}
+function qs(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function Hs(t) {
+  return typeof t == "number" && t >= 0 && t !== 1 / 0;
+}
+function Qs(t, e) {
+  return Math.max(t + (e || 0) - Date.now(), 0);
+}
+function en(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function js(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function An(t, e) {
+  const {
+    type: n = "all",
+    exact: r,
+    fetchStatus: s,
+    predicate: i,
+    queryKey: o,
+    stale: a
+  } = t;
+  if (o) {
+    if (r) {
+      if (e.queryHash !== dn(o, e.options))
+        return !1;
+    } else if (!gt(e.queryKey, o))
+      return !1;
+  }
+  if (n !== "all") {
+    const l = e.isActive();
+    if (n === "active" && !l || n === "inactive" && l)
+      return !1;
+  }
+  return !(typeof a == "boolean" && e.isStale() !== a || s && s !== e.state.fetchStatus || i && !i(e));
+}
+function En(t, e) {
+  const { exact: n, status: r, predicate: s, mutationKey: i } = t;
+  if (i) {
+    if (!e.options.mutationKey)
+      return !1;
+    if (n) {
+      if (yt(e.options.mutationKey) !== yt(i))
+        return !1;
+    } else if (!gt(e.options.mutationKey, i))
+      return !1;
+  }
+  return !(r && e.state.status !== r || s && !s(e));
+}
+function dn(t, e) {
+  return ((e == null ? void 0 : e.queryKeyHashFn) || yt)(t);
+}
+function yt(t) {
+  return JSON.stringify(
+    t,
+    (e, n) => nn(n) ? Object.keys(n).sort().reduce((r, s) => (r[s] = n[s], r), {}) : n
+  );
+}
+function gt(t, e) {
+  return t === e ? !0 : typeof t != typeof e ? !1 : t && e && typeof t == "object" && typeof e == "object" ? Object.keys(e).every((n) => gt(t[n], e[n])) : !1;
+}
+var Gs = Object.prototype.hasOwnProperty;
+function tn(t, e) {
+  if (t === e)
+    return t;
+  const n = zn(t) && zn(e);
+  if (!n && !(nn(t) && nn(e))) return e;
+  const s = (n ? t : Object.keys(t)).length, i = n ? e : Object.keys(e), o = i.length, a = n ? new Array(o) : {};
+  let l = 0;
+  for (let d = 0; d < o; d++) {
+    const h = n ? d : i[d], f = t[h], u = e[h];
+    if (f === u) {
+      a[h] = f, (n ? d < s : Gs.call(t, h)) && l++;
+      continue;
+    }
+    if (f === null || u === null || typeof f != "object" || typeof u != "object") {
+      a[h] = u;
+      continue;
+    }
+    const v = tn(f, u);
+    a[h] = v, v === f && l++;
+  }
+  return s === o && l === s ? t : a;
+}
+function eo(t, e) {
+  if (!e || Object.keys(t).length !== Object.keys(e).length)
+    return !1;
+  for (const n in t)
+    if (t[n] !== e[n])
+      return !1;
+  return !0;
+}
+function zn(t) {
+  return Array.isArray(t) && t.length === Object.keys(t).length;
+}
+function nn(t) {
+  if (!Rn(t))
+    return !1;
+  const e = t.constructor;
+  if (e === void 0)
+    return !0;
+  const n = e.prototype;
+  return !(!Rn(n) || !n.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(t) !== Object.prototype);
+}
+function Rn(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function Ks(t) {
+  return new Promise((e) => {
+    Zt.setTimeout(e, t);
+  });
+}
+function Bs(t, e, n) {
+  if (typeof n.structuralSharing == "function")
+    return n.structuralSharing(t, e);
+  if (n.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return tn(t, e);
+      } catch (r) {
+        throw console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${n.queryHash}]: ${r}`
+        ), r;
+      }
+    return tn(t, e);
+  }
+  return e;
+}
+function to(t) {
+  return t;
+}
+function Us(t, e, n = 0) {
+  const r = [...t, e];
+  return n && r.length > n ? r.slice(1) : r;
+}
+function Vs(t, e, n = 0) {
+  const r = [e, ...t];
+  return n && r.length > n ? r.slice(0, -1) : r;
+}
+var Mt = Symbol();
+function rr(t, e) {
+  return process.env.NODE_ENV !== "production" && t.queryFn === Mt && console.error(
+    `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${t.queryHash}'`
+  ), !t.queryFn && (e != null && e.initialPromise) ? () => e.initialPromise : !t.queryFn || t.queryFn === Mt ? () => Promise.reject(new Error(`Missing queryFn: '${t.queryHash}'`)) : t.queryFn;
+}
+function no(t, e) {
+  return typeof t == "function" ? t(...e) : !!t;
+}
+var ke, De, Ye, Kn, Ws = (Kn = class extends Ft {
+  constructor() {
+    super();
+    k(this, ke);
+    k(this, De);
+    k(this, Ye);
+    P(this, Ye, (e) => {
+      if (!Lt && window.addEventListener) {
+        const n = () => e();
+        return window.addEventListener("visibilitychange", n, !1), () => {
+          window.removeEventListener("visibilitychange", n);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    c(this, De) || this.setEventListener(c(this, Ye));
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || ((e = c(this, De)) == null || e.call(this), P(this, De, void 0));
+  }
+  setEventListener(e) {
+    var n;
+    P(this, Ye, e), (n = c(this, De)) == null || n.call(this), P(this, De, e((r) => {
+      typeof r == "boolean" ? this.setFocused(r) : this.onFocus();
+    }));
+  }
+  setFocused(e) {
+    c(this, ke) !== e && (P(this, ke, e), this.onFocus());
+  }
+  onFocus() {
+    const e = this.isFocused();
+    this.listeners.forEach((n) => {
+      n(e);
+    });
+  }
+  isFocused() {
+    var e;
+    return typeof c(this, ke) == "boolean" ? c(this, ke) : ((e = globalThis.document) == null ? void 0 : e.visibilityState) !== "hidden";
+  }
+}, ke = new WeakMap(), De = new WeakMap(), Ye = new WeakMap(), Kn), sr = new Ws();
+function Xs() {
+  let t, e;
+  const n = new Promise((s, i) => {
+    t = s, e = i;
+  });
+  n.status = "pending", n.catch(() => {
+  });
+  function r(s) {
+    Object.assign(n, s), delete n.resolve, delete n.reject;
+  }
+  return n.resolve = (s) => {
+    r({
+      status: "fulfilled",
+      value: s
+    }), t(s);
+  }, n.reject = (s) => {
+    r({
+      status: "rejected",
+      reason: s
+    }), e(s);
+  }, n;
+}
+var Js = $s;
+function Ys() {
+  let t = [], e = 0, n = (a) => {
+    a();
+  }, r = (a) => {
+    a();
+  }, s = Js;
+  const i = (a) => {
+    e ? t.push(a) : s(() => {
+      n(a);
+    });
+  }, o = () => {
+    const a = t;
+    t = [], a.length && s(() => {
+      r(() => {
+        a.forEach((l) => {
+          n(l);
+        });
+      });
+    });
+  };
+  return {
+    batch: (a) => {
+      let l;
+      e++;
+      try {
+        l = a();
+      } finally {
+        e--, e || o();
+      }
+      return l;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (a) => (...l) => {
+      i(() => {
+        a(...l);
+      });
+    },
+    schedule: i,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (a) => {
+      n = a;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (a) => {
+      r = a;
+    },
+    setScheduler: (a) => {
+      s = a;
+    }
+  };
+}
+var Y = Ys(), Ze, Ae, et, Bn, Zs = (Bn = class extends Ft {
+  constructor() {
+    super();
+    k(this, Ze, !0);
+    k(this, Ae);
+    k(this, et);
+    P(this, et, (e) => {
+      if (!Lt && window.addEventListener) {
+        const n = () => e(!0), r = () => e(!1);
+        return window.addEventListener("online", n, !1), window.addEventListener("offline", r, !1), () => {
+          window.removeEventListener("online", n), window.removeEventListener("offline", r);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    c(this, Ae) || this.setEventListener(c(this, et));
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || ((e = c(this, Ae)) == null || e.call(this), P(this, Ae, void 0));
+  }
+  setEventListener(e) {
+    var n;
+    P(this, et, e), (n = c(this, Ae)) == null || n.call(this), P(this, Ae, e(this.setOnline.bind(this)));
+  }
+  setOnline(e) {
+    c(this, Ze) !== e && (P(this, Ze, e), this.listeners.forEach((r) => {
+      r(e);
+    }));
+  }
+  isOnline() {
+    return c(this, Ze);
+  }
+}, Ze = new WeakMap(), Ae = new WeakMap(), et = new WeakMap(), Bn), Ot = new Zs();
+function ei(t) {
+  return Math.min(1e3 * 2 ** t, 3e4);
+}
+function ir(t) {
+  return (t ?? "online") === "online" ? Ot.isOnline() : !0;
+}
+var rn = class extends Error {
+  constructor(t) {
+    super("CancelledError"), this.revert = t == null ? void 0 : t.revert, this.silent = t == null ? void 0 : t.silent;
+  }
+};
+function ar(t) {
+  let e = !1, n = 0, r;
+  const s = Xs(), i = () => s.status !== "pending", o = (g) => {
+    var C;
+    if (!i()) {
+      const x = new rn(g);
+      u(x), (C = t.onCancel) == null || C.call(t, x);
+    }
+  }, a = () => {
+    e = !0;
+  }, l = () => {
+    e = !1;
+  }, d = () => sr.isFocused() && (t.networkMode === "always" || Ot.isOnline()) && t.canRun(), h = () => ir(t.networkMode) && t.canRun(), f = (g) => {
+    i() || (r == null || r(), s.resolve(g));
+  }, u = (g) => {
+    i() || (r == null || r(), s.reject(g));
+  }, v = () => new Promise((g) => {
+    var C;
+    r = (x) => {
+      (i() || d()) && g(x);
+    }, (C = t.onPause) == null || C.call(t);
+  }).then(() => {
+    var g;
+    r = void 0, i() || (g = t.onContinue) == null || g.call(t);
+  }), b = () => {
+    if (i())
+      return;
+    let g;
+    const C = n === 0 ? t.initialPromise : void 0;
+    try {
+      g = C ?? t.fn();
+    } catch (x) {
+      g = Promise.reject(x);
+    }
+    Promise.resolve(g).then(f).catch((x) => {
+      var O;
+      if (i())
+        return;
+      const I = t.retry ?? (Lt ? 0 : 3), z = t.retryDelay ?? ei, y = typeof z == "function" ? z(n, x) : z, F = I === !0 || typeof I == "number" && n < I || typeof I == "function" && I(n, x);
+      if (e || !F) {
+        u(x);
+        return;
+      }
+      n++, (O = t.onFail) == null || O.call(t, n, x), Ks(y).then(() => d() ? void 0 : v()).then(() => {
+        e ? u(x) : b();
+      });
+    });
+  };
+  return {
+    promise: s,
+    status: () => s.status,
+    cancel: o,
+    continue: () => (r == null || r(), s),
+    cancelRetry: a,
+    continueRetry: l,
+    canStart: h,
+    start: () => (h() ? b() : v().then(b), s)
+  };
+}
+var Te, Un, or = (Un = class {
+  constructor() {
+    k(this, Te);
+  }
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout(), Hs(this.gcTime) && P(this, Te, Zt.setTimeout(() => {
+      this.optionalRemove();
+    }, this.gcTime));
+  }
+  updateGcTime(t) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      t ?? (Lt ? 1 / 0 : 5 * 60 * 1e3)
+    );
+  }
+  clearGcTimeout() {
+    c(this, Te) && (Zt.clearTimeout(c(this, Te)), P(this, Te, void 0));
+  }
+}, Te = new WeakMap(), Un), _e, tt, re, Fe, K, bt, Le, oe, be, Vn, ti = (Vn = class extends or {
+  constructor(e) {
+    super();
+    k(this, oe);
+    k(this, _e);
+    k(this, tt);
+    k(this, re);
+    k(this, Fe);
+    k(this, K);
+    k(this, bt);
+    k(this, Le);
+    P(this, Le, !1), P(this, bt, e.defaultOptions), this.setOptions(e.options), this.observers = [], P(this, Fe, e.client), P(this, re, c(this, Fe).getQueryCache()), this.queryKey = e.queryKey, this.queryHash = e.queryHash, P(this, _e, In(this.options)), this.state = e.state ?? c(this, _e), this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  get promise() {
+    var e;
+    return (e = c(this, K)) == null ? void 0 : e.promise;
+  }
+  setOptions(e) {
+    if (this.options = { ...c(this, bt), ...e }, this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
+      const n = In(this.options);
+      n.data !== void 0 && (this.setState(
+        Nn(n.data, n.dataUpdatedAt)
+      ), P(this, _e, n));
+    }
+  }
+  optionalRemove() {
+    !this.observers.length && this.state.fetchStatus === "idle" && c(this, re).remove(this);
+  }
+  setData(e, n) {
+    const r = Bs(this.state.data, e, this.options);
+    return V(this, oe, be).call(this, {
+      data: r,
+      type: "success",
+      dataUpdatedAt: n == null ? void 0 : n.updatedAt,
+      manual: n == null ? void 0 : n.manual
+    }), r;
+  }
+  setState(e, n) {
+    V(this, oe, be).call(this, { type: "setState", state: e, setStateOptions: n });
+  }
+  cancel(e) {
+    var r, s;
+    const n = (r = c(this, K)) == null ? void 0 : r.promise;
+    return (s = c(this, K)) == null || s.cancel(e), n ? n.then(ae).catch(ae) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy(), this.cancel({ silent: !0 });
+  }
+  reset() {
+    this.destroy(), this.setState(c(this, _e));
+  }
+  isActive() {
+    return this.observers.some(
+      (e) => js(e.options.enabled, this) !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === Mt || this.state.dataUpdateCount + this.state.errorUpdateCount === 0;
+  }
+  isStatic() {
+    return this.getObserversCount() > 0 ? this.observers.some(
+      (e) => en(e.options.staleTime, this) === "static"
+    ) : !1;
+  }
+  isStale() {
+    return this.getObserversCount() > 0 ? this.observers.some(
+      (e) => e.getCurrentResult().isStale
+    ) : this.state.data === void 0 || this.state.isInvalidated;
+  }
+  isStaleByTime(e = 0) {
+    return this.state.data === void 0 ? !0 : e === "static" ? !1 : this.state.isInvalidated ? !0 : !Qs(this.state.dataUpdatedAt, e);
+  }
+  onFocus() {
+    var n;
+    const e = this.observers.find((r) => r.shouldFetchOnWindowFocus());
+    e == null || e.refetch({ cancelRefetch: !1 }), (n = c(this, K)) == null || n.continue();
+  }
+  onOnline() {
+    var n;
+    const e = this.observers.find((r) => r.shouldFetchOnReconnect());
+    e == null || e.refetch({ cancelRefetch: !1 }), (n = c(this, K)) == null || n.continue();
+  }
+  addObserver(e) {
+    this.observers.includes(e) || (this.observers.push(e), this.clearGcTimeout(), c(this, re).notify({ type: "observerAdded", query: this, observer: e }));
+  }
+  removeObserver(e) {
+    this.observers.includes(e) && (this.observers = this.observers.filter((n) => n !== e), this.observers.length || (c(this, K) && (c(this, Le) ? c(this, K).cancel({ revert: !0 }) : c(this, K).cancelRetry()), this.scheduleGc()), c(this, re).notify({ type: "observerRemoved", query: this, observer: e }));
+  }
+  getObserversCount() {
+    return this.observers.length;
+  }
+  invalidate() {
+    this.state.isInvalidated || V(this, oe, be).call(this, { type: "invalidate" });
+  }
+  async fetch(e, n) {
+    var l, d, h, f, u, v, b, g, C, x, I, z;
+    if (this.state.fetchStatus !== "idle" && // If the promise in the retyer is already rejected, we have to definitely
+    // re-start the fetch; there is a chance that the query is still in a
+    // pending state when that happens
+    ((l = c(this, K)) == null ? void 0 : l.status()) !== "rejected") {
+      if (this.state.data !== void 0 && (n != null && n.cancelRefetch))
+        this.cancel({ silent: !0 });
+      else if (c(this, K))
+        return c(this, K).continueRetry(), c(this, K).promise;
+    }
+    if (e && this.setOptions(e), !this.options.queryFn) {
+      const y = this.observers.find((F) => F.options.queryFn);
+      y && this.setOptions(y.options);
+    }
+    process.env.NODE_ENV !== "production" && (Array.isArray(this.options.queryKey) || console.error(
+      "As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']"
+    ));
+    const r = new AbortController(), s = (y) => {
+      Object.defineProperty(y, "signal", {
+        enumerable: !0,
+        get: () => (P(this, Le, !0), r.signal)
+      });
+    }, i = () => {
+      const y = rr(this.options, n), O = (() => {
+        const D = {
+          client: c(this, Fe),
+          queryKey: this.queryKey,
+          meta: this.meta
+        };
+        return s(D), D;
+      })();
+      return P(this, Le, !1), this.options.persister ? this.options.persister(
+        y,
+        O,
+        this
+      ) : y(O);
+    }, a = (() => {
+      const y = {
+        fetchOptions: n,
+        options: this.options,
+        queryKey: this.queryKey,
+        client: c(this, Fe),
+        state: this.state,
+        fetchFn: i
+      };
+      return s(y), y;
+    })();
+    (d = this.options.behavior) == null || d.onFetch(a, this), P(this, tt, this.state), (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((h = a.fetchOptions) == null ? void 0 : h.meta)) && V(this, oe, be).call(this, { type: "fetch", meta: (f = a.fetchOptions) == null ? void 0 : f.meta }), P(this, K, ar({
+      initialPromise: n == null ? void 0 : n.initialPromise,
+      fn: a.fetchFn,
+      onCancel: (y) => {
+        y instanceof rn && y.revert && this.setState({
+          ...c(this, tt),
+          fetchStatus: "idle"
+        }), r.abort();
+      },
+      onFail: (y, F) => {
+        V(this, oe, be).call(this, { type: "failed", failureCount: y, error: F });
+      },
+      onPause: () => {
+        V(this, oe, be).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        V(this, oe, be).call(this, { type: "continue" });
+      },
+      retry: a.options.retry,
+      retryDelay: a.options.retryDelay,
+      networkMode: a.options.networkMode,
+      canRun: () => !0
+    }));
+    try {
+      const y = await c(this, K).start();
+      if (y === void 0)
+        throw process.env.NODE_ENV !== "production" && console.error(
+          `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
+        ), new Error(`${this.queryHash} data is undefined`);
+      return this.setData(y), (v = (u = c(this, re).config).onSuccess) == null || v.call(u, y, this), (g = (b = c(this, re).config).onSettled) == null || g.call(
+        b,
+        y,
+        this.state.error,
+        this
+      ), y;
+    } catch (y) {
+      if (y instanceof rn) {
+        if (y.silent)
+          return c(this, K).promise;
+        if (y.revert) {
+          if (this.state.data === void 0)
+            throw y;
+          return this.state.data;
+        }
+      }
+      throw V(this, oe, be).call(this, {
+        type: "error",
+        error: y
+      }), (x = (C = c(this, re).config).onError) == null || x.call(
+        C,
+        y,
+        this
+      ), (z = (I = c(this, re).config).onSettled) == null || z.call(
+        I,
+        this.state.data,
+        y,
+        this
+      ), y;
+    } finally {
+      this.scheduleGc();
+    }
+  }
+}, _e = new WeakMap(), tt = new WeakMap(), re = new WeakMap(), Fe = new WeakMap(), K = new WeakMap(), bt = new WeakMap(), Le = new WeakMap(), oe = new WeakSet(), be = function(e) {
+  const n = (r) => {
+    switch (e.type) {
+      case "failed":
+        return {
+          ...r,
+          fetchFailureCount: e.failureCount,
+          fetchFailureReason: e.error
+        };
+      case "pause":
+        return {
+          ...r,
+          fetchStatus: "paused"
+        };
+      case "continue":
+        return {
+          ...r,
+          fetchStatus: "fetching"
+        };
+      case "fetch":
+        return {
+          ...r,
+          ...ni(r.data, this.options),
+          fetchMeta: e.meta ?? null
+        };
+      case "success":
+        const s = {
+          ...r,
+          ...Nn(e.data, e.dataUpdatedAt),
+          dataUpdateCount: r.dataUpdateCount + 1,
+          ...!e.manual && {
+            fetchStatus: "idle",
+            fetchFailureCount: 0,
+            fetchFailureReason: null
+          }
+        };
+        return P(this, tt, e.manual ? s : void 0), s;
+      case "error":
+        const i = e.error;
+        return {
+          ...r,
+          error: i,
+          errorUpdateCount: r.errorUpdateCount + 1,
+          errorUpdatedAt: Date.now(),
+          fetchFailureCount: r.fetchFailureCount + 1,
+          fetchFailureReason: i,
+          fetchStatus: "idle",
+          status: "error"
+        };
+      case "invalidate":
+        return {
+          ...r,
+          isInvalidated: !0
+        };
+      case "setState":
+        return {
+          ...r,
+          ...e.state
+        };
+    }
+  };
+  this.state = n(this.state), Y.batch(() => {
+    this.observers.forEach((r) => {
+      r.onQueryUpdate();
+    }), c(this, re).notify({ query: this, type: "updated", action: e });
+  });
+}, Vn);
+function ni(t, e) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: ir(e.networkMode) ? "fetching" : "paused",
+    ...t === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+function Nn(t, e) {
+  return {
+    data: t,
+    dataUpdatedAt: e ?? Date.now(),
+    error: null,
+    isInvalidated: !1,
+    status: "success"
+  };
+}
+function In(t) {
+  const e = typeof t.initialData == "function" ? t.initialData() : t.initialData, n = e !== void 0, r = n ? typeof t.initialDataUpdatedAt == "function" ? t.initialDataUpdatedAt() : t.initialDataUpdatedAt : 0;
+  return {
+    data: e,
+    dataUpdateCount: 0,
+    dataUpdatedAt: n ? r ?? Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: !1,
+    status: n ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+function Mn(t) {
+  return {
+    onFetch: (e, n) => {
+      var h, f, u, v, b;
+      const r = e.options, s = (u = (f = (h = e.fetchOptions) == null ? void 0 : h.meta) == null ? void 0 : f.fetchMore) == null ? void 0 : u.direction, i = ((v = e.state.data) == null ? void 0 : v.pages) || [], o = ((b = e.state.data) == null ? void 0 : b.pageParams) || [];
+      let a = { pages: [], pageParams: [] }, l = 0;
+      const d = async () => {
+        let g = !1;
+        const C = (z) => {
+          Object.defineProperty(z, "signal", {
+            enumerable: !0,
+            get: () => (e.signal.aborted ? g = !0 : e.signal.addEventListener("abort", () => {
+              g = !0;
+            }), e.signal)
+          });
+        }, x = rr(e.options, e.fetchOptions), I = async (z, y, F) => {
+          if (g)
+            return Promise.reject();
+          if (y == null && z.pages.length)
+            return Promise.resolve(z);
+          const D = (() => {
+            const L = {
+              client: e.client,
+              queryKey: e.queryKey,
+              pageParam: y,
+              direction: F ? "backward" : "forward",
+              meta: e.options.meta
+            };
+            return C(L), L;
+          })(), B = await x(D), { maxPages: W } = e.options, T = F ? Vs : Us;
+          return {
+            pages: T(z.pages, B, W),
+            pageParams: T(z.pageParams, y, W)
+          };
+        };
+        if (s && i.length) {
+          const z = s === "backward", y = z ? lr : sn, F = {
+            pages: i,
+            pageParams: o
+          }, O = y(r, F);
+          a = await I(F, O, z);
+        } else {
+          const z = t ?? i.length;
+          do {
+            const y = l === 0 ? o[0] ?? r.initialPageParam : sn(r, a);
+            if (l > 0 && y == null)
+              break;
+            a = await I(a, y), l++;
+          } while (l < z);
+        }
+        return a;
+      };
+      e.options.persister ? e.fetchFn = () => {
+        var g, C;
+        return (C = (g = e.options).persister) == null ? void 0 : C.call(
+          g,
+          d,
+          {
+            client: e.client,
+            queryKey: e.queryKey,
+            meta: e.options.meta,
+            signal: e.signal
+          },
+          n
+        );
+      } : e.fetchFn = d;
+    }
+  };
+}
+function sn(t, { pages: e, pageParams: n }) {
+  const r = e.length - 1;
+  return e.length > 0 ? t.getNextPageParam(
+    e[r],
+    e,
+    n[r],
+    n
+  ) : void 0;
+}
+function lr(t, { pages: e, pageParams: n }) {
+  var r;
+  return e.length > 0 ? (r = t.getPreviousPageParam) == null ? void 0 : r.call(t, e[0], e, n[0], n) : void 0;
+}
+function ro(t, e) {
+  return e ? sn(t, e) != null : !1;
+}
+function so(t, e) {
+  return !e || !t.getPreviousPageParam ? !1 : lr(t, e) != null;
+}
+var xt, ye, J, $e, ge, Ce, Wn, ri = (Wn = class extends or {
+  constructor(e) {
+    super();
+    k(this, ge);
+    k(this, xt);
+    k(this, ye);
+    k(this, J);
+    k(this, $e);
+    P(this, xt, e.client), this.mutationId = e.mutationId, P(this, J, e.mutationCache), P(this, ye, []), this.state = e.state || si(), this.setOptions(e.options), this.scheduleGc();
+  }
+  setOptions(e) {
+    this.options = e, this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(e) {
+    c(this, ye).includes(e) || (c(this, ye).push(e), this.clearGcTimeout(), c(this, J).notify({
+      type: "observerAdded",
+      mutation: this,
+      observer: e
+    }));
+  }
+  removeObserver(e) {
+    P(this, ye, c(this, ye).filter((n) => n !== e)), this.scheduleGc(), c(this, J).notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer: e
+    });
+  }
+  optionalRemove() {
+    c(this, ye).length || (this.state.status === "pending" ? this.scheduleGc() : c(this, J).remove(this));
+  }
+  continue() {
+    var e;
+    return ((e = c(this, $e)) == null ? void 0 : e.continue()) ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+    this.execute(this.state.variables);
+  }
+  async execute(e) {
+    var o, a, l, d, h, f, u, v, b, g, C, x, I, z, y, F, O, D, B, W;
+    const n = () => {
+      V(this, ge, Ce).call(this, { type: "continue" });
+    }, r = {
+      client: c(this, xt),
+      meta: this.options.meta,
+      mutationKey: this.options.mutationKey
+    };
+    P(this, $e, ar({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(e, r) : Promise.reject(new Error("No mutationFn found")),
+      onFail: (T, L) => {
+        V(this, ge, Ce).call(this, { type: "failed", failureCount: T, error: L });
+      },
+      onPause: () => {
+        V(this, ge, Ce).call(this, { type: "pause" });
+      },
+      onContinue: n,
+      retry: this.options.retry ?? 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode,
+      canRun: () => c(this, J).canRun(this)
+    }));
+    const s = this.state.status === "pending", i = !c(this, $e).canStart();
+    try {
+      if (s)
+        n();
+      else {
+        V(this, ge, Ce).call(this, { type: "pending", variables: e, isPaused: i }), await ((a = (o = c(this, J).config).onMutate) == null ? void 0 : a.call(
+          o,
+          e,
+          this,
+          r
+        ));
+        const L = await ((d = (l = this.options).onMutate) == null ? void 0 : d.call(
+          l,
+          e,
+          r
+        ));
+        L !== this.state.context && V(this, ge, Ce).call(this, {
+          type: "pending",
+          context: L,
+          variables: e,
+          isPaused: i
+        });
+      }
+      const T = await c(this, $e).start();
+      return await ((f = (h = c(this, J).config).onSuccess) == null ? void 0 : f.call(
+        h,
+        T,
+        e,
+        this.state.context,
+        this,
+        r
+      )), await ((v = (u = this.options).onSuccess) == null ? void 0 : v.call(
+        u,
+        T,
+        e,
+        this.state.context,
+        r
+      )), await ((g = (b = c(this, J).config).onSettled) == null ? void 0 : g.call(
+        b,
+        T,
+        null,
+        this.state.variables,
+        this.state.context,
+        this,
+        r
+      )), await ((x = (C = this.options).onSettled) == null ? void 0 : x.call(
+        C,
+        T,
+        null,
+        e,
+        this.state.context,
+        r
+      )), V(this, ge, Ce).call(this, { type: "success", data: T }), T;
+    } catch (T) {
+      try {
+        throw await ((z = (I = c(this, J).config).onError) == null ? void 0 : z.call(
+          I,
+          T,
+          e,
+          this.state.context,
+          this,
+          r
+        )), await ((F = (y = this.options).onError) == null ? void 0 : F.call(
+          y,
+          T,
+          e,
+          this.state.context,
+          r
+        )), await ((D = (O = c(this, J).config).onSettled) == null ? void 0 : D.call(
+          O,
+          void 0,
+          T,
+          this.state.variables,
+          this.state.context,
+          this,
+          r
+        )), await ((W = (B = this.options).onSettled) == null ? void 0 : W.call(
+          B,
+          void 0,
+          T,
+          e,
+          this.state.context,
+          r
+        )), T;
+      } finally {
+        V(this, ge, Ce).call(this, { type: "error", error: T });
+      }
+    } finally {
+      c(this, J).runNext(this);
+    }
+  }
+}, xt = new WeakMap(), ye = new WeakMap(), J = new WeakMap(), $e = new WeakMap(), ge = new WeakSet(), Ce = function(e) {
+  const n = (r) => {
+    switch (e.type) {
+      case "failed":
+        return {
+          ...r,
+          failureCount: e.failureCount,
+          failureReason: e.error
+        };
+      case "pause":
+        return {
+          ...r,
+          isPaused: !0
+        };
+      case "continue":
+        return {
+          ...r,
+          isPaused: !1
+        };
+      case "pending":
+        return {
+          ...r,
+          context: e.context,
+          data: void 0,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          isPaused: e.isPaused,
+          status: "pending",
+          variables: e.variables,
+          submittedAt: Date.now()
+        };
+      case "success":
+        return {
+          ...r,
+          data: e.data,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          status: "success",
+          isPaused: !1
+        };
+      case "error":
+        return {
+          ...r,
+          data: void 0,
+          error: e.error,
+          failureCount: r.failureCount + 1,
+          failureReason: e.error,
+          isPaused: !1,
+          status: "error"
+        };
+    }
+  };
+  this.state = n(this.state), Y.batch(() => {
+    c(this, ye).forEach((r) => {
+      r.onMutationUpdate(e);
+    }), c(this, J).notify({
+      mutation: this,
+      type: "updated",
+      action: e
+    });
+  });
+}, Wn);
+function si() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var xe, le, wt, Xn, ii = (Xn = class extends Ft {
+  constructor(e = {}) {
+    super();
+    k(this, xe);
+    k(this, le);
+    k(this, wt);
+    this.config = e, P(this, xe, /* @__PURE__ */ new Set()), P(this, le, /* @__PURE__ */ new Map()), P(this, wt, 0);
+  }
+  build(e, n, r) {
+    const s = new ri({
+      client: e,
+      mutationCache: this,
+      mutationId: ++Et(this, wt)._,
+      options: e.defaultMutationOptions(n),
+      state: r
+    });
+    return this.add(s), s;
+  }
+  add(e) {
+    c(this, xe).add(e);
+    const n = zt(e);
+    if (typeof n == "string") {
+      const r = c(this, le).get(n);
+      r ? r.push(e) : c(this, le).set(n, [e]);
+    }
+    this.notify({ type: "added", mutation: e });
+  }
+  remove(e) {
+    if (c(this, xe).delete(e)) {
+      const n = zt(e);
+      if (typeof n == "string") {
+        const r = c(this, le).get(n);
+        if (r)
+          if (r.length > 1) {
+            const s = r.indexOf(e);
+            s !== -1 && r.splice(s, 1);
+          } else r[0] === e && c(this, le).delete(n);
+      }
+    }
+    this.notify({ type: "removed", mutation: e });
+  }
+  canRun(e) {
+    const n = zt(e);
+    if (typeof n == "string") {
+      const r = c(this, le).get(n), s = r == null ? void 0 : r.find(
+        (i) => i.state.status === "pending"
+      );
+      return !s || s === e;
+    } else
+      return !0;
+  }
+  runNext(e) {
+    var r;
+    const n = zt(e);
+    if (typeof n == "string") {
+      const s = (r = c(this, le).get(n)) == null ? void 0 : r.find((i) => i !== e && i.state.isPaused);
+      return (s == null ? void 0 : s.continue()) ?? Promise.resolve();
+    } else
+      return Promise.resolve();
+  }
+  clear() {
+    Y.batch(() => {
+      c(this, xe).forEach((e) => {
+        this.notify({ type: "removed", mutation: e });
+      }), c(this, xe).clear(), c(this, le).clear();
+    });
+  }
+  getAll() {
+    return Array.from(c(this, xe));
+  }
+  find(e) {
+    const n = { exact: !0, ...e };
+    return this.getAll().find(
+      (r) => En(n, r)
+    );
+  }
+  findAll(e = {}) {
+    return this.getAll().filter((n) => En(e, n));
+  }
+  notify(e) {
+    Y.batch(() => {
+      this.listeners.forEach((n) => {
+        n(e);
+      });
+    });
+  }
+  resumePausedMutations() {
+    const e = this.getAll().filter((n) => n.state.isPaused);
+    return Y.batch(
+      () => Promise.all(
+        e.map((n) => n.continue().catch(ae))
+      )
+    );
+  }
+}, xe = new WeakMap(), le = new WeakMap(), wt = new WeakMap(), Xn);
+function zt(t) {
+  var e;
+  return (e = t.options.scope) == null ? void 0 : e.id;
+}
+var me, Jn, cr = (Jn = class extends Ft {
+  constructor(e = {}) {
+    super();
+    k(this, me);
+    this.config = e, P(this, me, /* @__PURE__ */ new Map());
+  }
+  build(e, n, r) {
+    const s = n.queryKey, i = n.queryHash ?? dn(s, n);
+    let o = this.get(i);
+    return o || (o = new ti({
+      client: e,
+      queryKey: s,
+      queryHash: i,
+      options: e.defaultQueryOptions(n),
+      state: r,
+      defaultOptions: e.getQueryDefaults(s)
+    }), this.add(o)), o;
+  }
+  add(e) {
+    c(this, me).has(e.queryHash) || (c(this, me).set(e.queryHash, e), this.notify({
+      type: "added",
+      query: e
+    }));
+  }
+  remove(e) {
+    const n = c(this, me).get(e.queryHash);
+    n && (e.destroy(), n === e && c(this, me).delete(e.queryHash), this.notify({ type: "removed", query: e }));
+  }
+  clear() {
+    Y.batch(() => {
+      this.getAll().forEach((e) => {
+        this.remove(e);
+      });
+    });
+  }
+  get(e) {
+    return c(this, me).get(e);
+  }
+  getAll() {
+    return [...c(this, me).values()];
+  }
+  find(e) {
+    const n = { exact: !0, ...e };
+    return this.getAll().find(
+      (r) => An(n, r)
+    );
+  }
+  findAll(e = {}) {
+    const n = this.getAll();
+    return Object.keys(e).length > 0 ? n.filter((r) => An(e, r)) : n;
+  }
+  notify(e) {
+    Y.batch(() => {
+      this.listeners.forEach((n) => {
+        n(e);
+      });
+    });
+  }
+  onFocus() {
+    Y.batch(() => {
+      this.getAll().forEach((e) => {
+        e.onFocus();
+      });
+    });
+  }
+  onOnline() {
+    Y.batch(() => {
+      this.getAll().forEach((e) => {
+        e.onOnline();
+      });
+    });
+  }
+}, me = new WeakMap(), Jn), q, Ee, ze, nt, rt, Re, st, it, Yn, ai = (Yn = class {
+  constructor(t = {}) {
+    k(this, q);
+    k(this, Ee);
+    k(this, ze);
+    k(this, nt);
+    k(this, rt);
+    k(this, Re);
+    k(this, st);
+    k(this, it);
+    P(this, q, t.queryCache || new cr()), P(this, Ee, t.mutationCache || new ii()), P(this, ze, t.defaultOptions || {}), P(this, nt, /* @__PURE__ */ new Map()), P(this, rt, /* @__PURE__ */ new Map()), P(this, Re, 0);
+  }
+  mount() {
+    Et(this, Re)._++, c(this, Re) === 1 && (P(this, st, sr.subscribe(async (t) => {
+      t && (await this.resumePausedMutations(), c(this, q).onFocus());
+    })), P(this, it, Ot.subscribe(async (t) => {
+      t && (await this.resumePausedMutations(), c(this, q).onOnline());
+    })));
+  }
+  unmount() {
+    var t, e;
+    Et(this, Re)._--, c(this, Re) === 0 && ((t = c(this, st)) == null || t.call(this), P(this, st, void 0), (e = c(this, it)) == null || e.call(this), P(this, it, void 0));
+  }
+  isFetching(t) {
+    return c(this, q).findAll({ ...t, fetchStatus: "fetching" }).length;
+  }
+  isMutating(t) {
+    return c(this, Ee).findAll({ ...t, status: "pending" }).length;
+  }
+  /**
+   * Imperative (non-reactive) way to retrieve data for a QueryKey.
+   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+   *
+   * Hint: Do not use this function inside a component, because it won't receive updates.
+   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+   */
+  getQueryData(t) {
+    var n;
+    const e = this.defaultQueryOptions({ queryKey: t });
+    return (n = c(this, q).get(e.queryHash)) == null ? void 0 : n.state.data;
+  }
+  ensureQueryData(t) {
+    const e = this.defaultQueryOptions(t), n = c(this, q).build(this, e), r = n.state.data;
+    return r === void 0 ? this.fetchQuery(t) : (t.revalidateIfStale && n.isStaleByTime(en(e.staleTime, n)) && this.prefetchQuery(e), Promise.resolve(r));
+  }
+  getQueriesData(t) {
+    return c(this, q).findAll(t).map(({ queryKey: e, state: n }) => {
+      const r = n.data;
+      return [e, r];
+    });
+  }
+  setQueryData(t, e, n) {
+    const r = this.defaultQueryOptions({ queryKey: t }), s = c(this, q).get(
+      r.queryHash
+    ), i = s == null ? void 0 : s.state.data, o = qs(e, i);
+    if (o !== void 0)
+      return c(this, q).build(this, r).setData(o, { ...n, manual: !0 });
+  }
+  setQueriesData(t, e, n) {
+    return Y.batch(
+      () => c(this, q).findAll(t).map(({ queryKey: r }) => [
+        r,
+        this.setQueryData(r, e, n)
+      ])
+    );
+  }
+  getQueryState(t) {
+    var n;
+    const e = this.defaultQueryOptions({ queryKey: t });
+    return (n = c(this, q).get(
+      e.queryHash
+    )) == null ? void 0 : n.state;
+  }
+  removeQueries(t) {
+    const e = c(this, q);
+    Y.batch(() => {
+      e.findAll(t).forEach((n) => {
+        e.remove(n);
+      });
+    });
+  }
+  resetQueries(t, e) {
+    const n = c(this, q);
+    return Y.batch(() => (n.findAll(t).forEach((r) => {
+      r.reset();
+    }), this.refetchQueries(
+      {
+        type: "active",
+        ...t
+      },
+      e
+    )));
+  }
+  cancelQueries(t, e = {}) {
+    const n = { revert: !0, ...e }, r = Y.batch(
+      () => c(this, q).findAll(t).map((s) => s.cancel(n))
+    );
+    return Promise.all(r).then(ae).catch(ae);
+  }
+  invalidateQueries(t, e = {}) {
+    return Y.batch(() => (c(this, q).findAll(t).forEach((n) => {
+      n.invalidate();
+    }), (t == null ? void 0 : t.refetchType) === "none" ? Promise.resolve() : this.refetchQueries(
+      {
+        ...t,
+        type: (t == null ? void 0 : t.refetchType) ?? (t == null ? void 0 : t.type) ?? "active"
+      },
+      e
+    )));
+  }
+  refetchQueries(t, e = {}) {
+    const n = {
+      ...e,
+      cancelRefetch: e.cancelRefetch ?? !0
+    }, r = Y.batch(
+      () => c(this, q).findAll(t).filter((s) => !s.isDisabled() && !s.isStatic()).map((s) => {
+        let i = s.fetch(void 0, n);
+        return n.throwOnError || (i = i.catch(ae)), s.state.fetchStatus === "paused" ? Promise.resolve() : i;
+      })
+    );
+    return Promise.all(r).then(ae);
+  }
+  fetchQuery(t) {
+    const e = this.defaultQueryOptions(t);
+    e.retry === void 0 && (e.retry = !1);
+    const n = c(this, q).build(this, e);
+    return n.isStaleByTime(
+      en(e.staleTime, n)
+    ) ? n.fetch(e) : Promise.resolve(n.state.data);
+  }
+  prefetchQuery(t) {
+    return this.fetchQuery(t).then(ae).catch(ae);
+  }
+  fetchInfiniteQuery(t) {
+    return t.behavior = Mn(t.pages), this.fetchQuery(t);
+  }
+  prefetchInfiniteQuery(t) {
+    return this.fetchInfiniteQuery(t).then(ae).catch(ae);
+  }
+  ensureInfiniteQueryData(t) {
+    return t.behavior = Mn(t.pages), this.ensureQueryData(t);
+  }
+  resumePausedMutations() {
+    return Ot.isOnline() ? c(this, Ee).resumePausedMutations() : Promise.resolve();
+  }
+  getQueryCache() {
+    return c(this, q);
+  }
+  getMutationCache() {
+    return c(this, Ee);
+  }
+  getDefaultOptions() {
+    return c(this, ze);
+  }
+  setDefaultOptions(t) {
+    P(this, ze, t);
+  }
+  setQueryDefaults(t, e) {
+    c(this, nt).set(yt(t), {
+      queryKey: t,
+      defaultOptions: e
+    });
+  }
+  getQueryDefaults(t) {
+    const e = [...c(this, nt).values()], n = {};
+    return e.forEach((r) => {
+      gt(t, r.queryKey) && Object.assign(n, r.defaultOptions);
+    }), n;
+  }
+  setMutationDefaults(t, e) {
+    c(this, rt).set(yt(t), {
+      mutationKey: t,
+      defaultOptions: e
+    });
+  }
+  getMutationDefaults(t) {
+    const e = [...c(this, rt).values()], n = {};
+    return e.forEach((r) => {
+      gt(t, r.mutationKey) && Object.assign(n, r.defaultOptions);
+    }), n;
+  }
+  defaultQueryOptions(t) {
+    if (t._defaulted)
+      return t;
+    const e = {
+      ...c(this, ze).queries,
+      ...this.getQueryDefaults(t.queryKey),
+      ...t,
+      _defaulted: !0
+    };
+    return e.queryHash || (e.queryHash = dn(
+      e.queryKey,
+      e
+    )), e.refetchOnReconnect === void 0 && (e.refetchOnReconnect = e.networkMode !== "always"), e.throwOnError === void 0 && (e.throwOnError = !!e.suspense), !e.networkMode && e.persister && (e.networkMode = "offlineFirst"), e.queryFn === Mt && (e.enabled = !1), e;
+  }
+  defaultMutationOptions(t) {
+    return t != null && t._defaulted ? t : {
+      ...c(this, ze).mutations,
+      ...(t == null ? void 0 : t.mutationKey) && this.getMutationDefaults(t.mutationKey),
+      ...t,
+      _defaulted: !0
+    };
+  }
+  clear() {
+    c(this, q).clear(), c(this, Ee).clear();
+  }
+}, q = new WeakMap(), Ee = new WeakMap(), ze = new WeakMap(), nt = new WeakMap(), rt = new WeakMap(), Re = new WeakMap(), st = new WeakMap(), it = new WeakMap(), Yn), fn = w.createContext(
+  void 0
+), io = (t) => {
+  const e = w.useContext(fn);
+  if (!e)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return e;
+}, oi = ({
+  client: t,
+  children: e
+}) => (w.useEffect(() => (t.mount(), () => {
+  t.unmount();
+}), [t]), /* @__PURE__ */ p(fn.Provider, { value: t, children: e }));
+function li(t) {
+  const e = xs(), [n, r] = ve({ token: t, revision: 0 });
+  return n.token !== t && r({ token: t, revision: n.revision + 1 }), `${e}:${n.revision}`;
+}
+function ci() {
+  const t = ln(fn);
+  if (t && t.isSemaphorClient)
+    return t;
+}
+function ui({
+  children: t
+}) {
+  const { setIsSessionExpired: e } = Ss(), n = ci(), [r] = ve(() => {
+    const s = new ai({
+      queryCache: new cr({
+        onError: (i) => {
+          i instanceof Error ? (console.error(`Something went wrong: ${i.message}`), i.message === "invalid token" && e(!0)) : console.error("Something went wrong:", i);
+        }
+      }),
+      defaultOptions: {
+        queries: {
+          gcTime: 36e5,
+          // 1 hour
+          staleTime: 3e5,
+          // 5 minutes
+          refetchOnWindowFocus: !1,
+          // retry: 1, // retry once
+          retry: !1
+        }
+      }
+    });
+    return s.isSemaphorClient = !0, s;
+  });
+  return n ? /* @__PURE__ */ p(It, { children: t }) : /* @__PURE__ */ p(oi, { client: r, children: t });
+}
+const di = cn(null);
+function ao(t) {
+  return fi({
+    rowKey: Dn(t.rowPath),
+    columnKey: Dn(t.columnPath),
+    measureId: t.measureId
+  });
+}
+function fi(t) {
+  return JSON.stringify([t.rowKey, t.columnKey, t.measureId]);
+}
+const On = Object.freeze({
+  rowPageSize: 100,
+  columnPageSize: 20,
+  operations: 2,
+  dashboardOperations: 4,
+  pages: 32,
+  blocks: 64,
+  cells: 1e5,
+  bytes: 32 * 1024 * 1024,
+  checkpoints: 64,
+  overrides: 2e3,
+  mountedCells: 5e3
+});
+class hi {
+  constructor() {
+    At(this, "pending", /* @__PURE__ */ new Map());
+    At(this, "activeByCard", /* @__PURE__ */ new Map());
+    At(this, "active", 0);
+  }
+  run(e, n, r) {
+    const s = () => new DOMException("Matrix acquisition was cancelled.", "AbortError");
+    return n.aborted ? Promise.reject(s()) : new Promise((i, o) => {
+      let a = !1;
+      const l = () => {
+        var f;
+        if (!a) {
+          const u = (f = this.pending.get(e)) == null ? void 0 : f.filter((v) => v !== d);
+          u != null && u.length ? this.pending.set(e, u) : this.pending.delete(e), n.removeEventListener("abort", l);
+        }
+        o(s());
+      }, d = {
+        start: () => {
+          a = !0, this.active++, this.activeByCard.set(
+            e,
+            (this.activeByCard.get(e) ?? 0) + 1
+          ), Promise.resolve().then(() => {
+            if (n.aborted) throw s();
+            return r();
+          }).then(i, o).finally(() => {
+            n.removeEventListener("abort", l), this.active--;
+            const f = this.activeByCard.get(e) - 1;
+            f ? this.activeByCard.set(e, f) : this.activeByCard.delete(e), this.pump();
+          });
+        }
+      }, h = this.pending.get(e) ?? [];
+      h.push(d), this.pending.set(e, h), n.addEventListener("abort", l, { once: !0 }), this.pump();
+    });
+  }
+  pump() {
+    for (; this.active < On.dashboardOperations; ) {
+      const e = Array.from(this.pending).find(
+        ([i]) => (this.activeByCard.get(i) ?? 0) < On.operations
+      );
+      if (!e) return;
+      const [n, r] = e, s = r.shift();
+      this.pending.delete(n), r.length && this.pending.set(n, r), s.start();
+    }
+  }
+}
+function pi({
+  value: t,
+  children: e
+}) {
+  const [n] = ve(() => new hi()), r = St(() => ({ ...t, queue: n }), [t, n]);
+  return /* @__PURE__ */ p(di.Provider, { value: r, children: e });
+}
+function yi(t, e) {
+  return async (n) => {
+    var o;
+    const r = await fetch(t, {
+      method: "POST",
+      signal: n.signal,
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${e}` },
+      body: JSON.stringify(_s(n))
+    });
+    if (r.status === 401 || r.status === 403)
+      return { status: "failed", failure: {
+        code: "forbidden",
+        message: "Matrix query access was denied.",
+        retryable: !1,
+        scope: { kind: "operation" }
+      } };
+    const s = await r.json().catch(() => null);
+    if (!s || typeof s != "object")
+      return { status: "failed", failure: {
+        code: "execution_failed",
+        message: "Matrix query returned an invalid response.",
+        retryable: r.ok || r.status >= 500,
+        scope: { kind: "operation" }
+      } };
+    if (!r.ok || s.error) {
+      const a = ks.safeParse(s.executionResult);
+      if (a.success && a.data.metadata.matrixFailure)
+        return { status: "failed", failure: a.data.metadata.matrixFailure };
+      const l = a.success ? a.data.validation.errors[0] : void 0;
+      return { status: "failed", failure: {
+        code: "execution_failed",
+        message: (l == null ? void 0 : l.message) ?? "Matrix query failed.",
+        retryable: r.status >= 500,
+        scope: { kind: "operation" }
+      } };
+    }
+    const i = Ts.parse((o = s.data) == null ? void 0 : o.matrixWindow);
+    return { status: i.failures.length ? "partial" : "success", window: i };
+  };
+}
+function gi({ children: t, authToken: e, apiServiceUrl: n, dashboardId: r }) {
+  const s = (e == null ? void 0 : e.accessToken) ?? "", i = St(() => ({
+    ready: !!(s && n),
+    identity: JSON.stringify([r, n]),
+    execute: yi(`${n ?? ""}/v1/query`, s)
+  }), [r, n, s]);
+  return /* @__PURE__ */ p(pi, { value: i, children: t });
+}
+const mi = {
+  id: "",
+  authToken: void 0,
+  tokenProps: {},
+  authorizationScope: "unconfigured"
+}, vi = cn(mi), oo = ({
+  children: t,
+  dashboardProps: e
+}) => {
+  var s;
+  const n = li((s = e.authToken) == null ? void 0 : s.accessToken), r = St(() => {
+    let i = {};
+    const o = e.authToken;
+    return o && (i = Os(o.accessToken)), {
+      ...e,
+      tokenProps: i,
+      authorizationScope: n
+    };
+  }, [e, n]);
+  return /* @__PURE__ */ p(ui, { children: /* @__PURE__ */ p(vi.Provider, { value: r, children: /* @__PURE__ */ p(gi, { dashboardId: r.id, authToken: r.authToken, apiServiceUrl: r.tokenProps.apiServiceUrl, children: t }) }) });
+};
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const lo = ue("Circle", [
+  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const co = ue("CodeXml", [
+  ["path", { d: "m18 16 4-4-4-4", key: "1inbqp" }],
+  ["path", { d: "m6 8-4 4 4 4", key: "15zrgr" }],
+  ["path", { d: "m14.5 4-5 16", key: "e7oirm" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const uo = ue("Copy", [
+  ["rect", { width: "14", height: "14", x: "8", y: "8", rx: "2", ry: "2", key: "17jyea" }],
+  ["path", { d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2", key: "zix9uf" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const fo = ue("Database", [
+  ["ellipse", { cx: "12", cy: "5", rx: "9", ry: "3", key: "msslwz" }],
+  ["path", { d: "M3 5V19A9 3 0 0 0 21 19V5", key: "1wlel7" }],
+  ["path", { d: "M3 12A9 3 0 0 0 21 12", key: "mv7ke4" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const ho = ue("FileCode", [
+  ["path", { d: "M10 12.5 8 15l2 2.5", key: "1tg20x" }],
+  ["path", { d: "m14 12.5 2 2.5-2 2.5", key: "yinavb" }],
+  ["path", { d: "M14 2v4a2 2 0 0 0 2 2h4", key: "tnqrlb" }],
+  ["path", { d: "M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z", key: "1mlx9k" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const bi = ue("GripVertical", [
+  ["circle", { cx: "9", cy: "12", r: "1", key: "1vctgf" }],
+  ["circle", { cx: "9", cy: "5", r: "1", key: "hp0tcf" }],
+  ["circle", { cx: "9", cy: "19", r: "1", key: "fkjjf6" }],
+  ["circle", { cx: "15", cy: "12", r: "1", key: "1tmaij" }],
+  ["circle", { cx: "15", cy: "5", r: "1", key: "19l28e" }],
+  ["circle", { cx: "15", cy: "19", r: "1", key: "f4zoj3" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const po = ue("Plus", [
+  ["path", { d: "M5 12h14", key: "1ays0h" }],
+  ["path", { d: "M12 5v14", key: "s699le" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const yo = ue("RefreshCw", [
+  ["path", { d: "M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8", key: "v9h5vc" }],
+  ["path", { d: "M21 3v5h-5", key: "1q7to0" }],
+  ["path", { d: "M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16", key: "3uifl3" }],
+  ["path", { d: "M8 16H3v5", key: "1cv678" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const go = ue("Send", [
+  [
+    "path",
+    {
+      d: "M14.536 21.686a.5.5 0 0 0 .937-.024l6.5-19a.496.496 0 0 0-.635-.635l-19 6.5a.5.5 0 0 0-.024.937l7.93 3.18a2 2 0 0 1 1.112 1.11z",
+      key: "1ffxy3"
+    }
+  ],
+  ["path", { d: "m21.854 2.147-10.94 10.939", key: "12cjpa" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const mo = ue("Settings2", [
+  ["path", { d: "M20 7h-9", key: "3s1dr2" }],
+  ["path", { d: "M14 17H5", key: "gfn3mx" }],
+  ["circle", { cx: "17", cy: "17", r: "3", key: "18b49y" }],
+  ["circle", { cx: "7", cy: "7", r: "3", key: "dfmy0x" }]
+]);
+/**
+ * @license lucide-react v0.453.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const vo = ue("SquarePen", [
+  ["path", { d: "M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7", key: "1m0v6g" }],
+  [
+    "path",
+    {
+      d: "M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z",
+      key: "ohrbg2"
+    }
+  ]
+]);
+// @__NO_SIDE_EFFECTS__
+function xi(t) {
+  const e = /* @__PURE__ */ wi(t), n = w.forwardRef((r, s) => {
+    const { children: i, ...o } = r, a = w.Children.toArray(i), l = a.find(Ci);
+    if (l) {
+      const d = l.props.children, h = a.map((f) => f === l ? w.Children.count(d) > 1 ? w.Children.only(null) : w.isValidElement(d) ? d.props.children : null : f);
+      return /* @__PURE__ */ p(e, { ...o, ref: s, children: w.isValidElement(d) ? w.cloneElement(d, void 0, h) : null });
+    }
+    return /* @__PURE__ */ p(e, { ...o, ref: s, children: i });
+  });
+  return n.displayName = `${t}.Slot`, n;
+}
+// @__NO_SIDE_EFFECTS__
+function wi(t) {
+  const e = w.forwardRef((n, r) => {
+    const { children: s, ...i } = n;
+    if (w.isValidElement(s)) {
+      const o = Di(s), a = Pi(i, s.props);
+      return s.type !== w.Fragment && (a.ref = r ? Cs(r, o) : o), w.cloneElement(s, a);
+    }
+    return w.Children.count(s) > 1 ? w.Children.only(null) : null;
+  });
+  return e.displayName = `${t}.SlotClone`, e;
+}
+var Si = Symbol("radix.slottable");
+function Ci(t) {
+  return w.isValidElement(t) && typeof t.type == "function" && "__radixId" in t.type && t.type.__radixId === Si;
+}
+function Pi(t, e) {
+  const n = { ...e };
+  for (const r in e) {
+    const s = t[r], i = e[r];
+    /^on[A-Z]/.test(r) ? s && i ? n[r] = (...a) => {
+      const l = i(...a);
+      return s(...a), l;
+    } : s && (n[r] = s) : r === "style" ? n[r] = { ...s, ...i } : r === "className" && (n[r] = [s, i].filter(Boolean).join(" "));
+  }
+  return { ...t, ...n };
+}
+function Di(t) {
+  var r, s;
+  let e = (r = Object.getOwnPropertyDescriptor(t.props, "ref")) == null ? void 0 : r.get, n = e && "isReactWarning" in e && e.isReactWarning;
+  return n ? t.ref : (e = (s = Object.getOwnPropertyDescriptor(t, "ref")) == null ? void 0 : s.get, n = e && "isReactWarning" in e && e.isReactWarning, n ? t.props.ref : t.props.ref || t.ref);
+}
+var $t = "Dialog", [ur, dr] = tr($t), [Ai, de] = ur($t), fr = (t) => {
+  const {
+    __scopeDialog: e,
+    children: n,
+    open: r,
+    defaultOpen: s,
+    onOpenChange: i,
+    modal: o = !0
+  } = t, a = w.useRef(null), l = w.useRef(null), [d, h] = Is({
+    prop: r,
+    defaultProp: s ?? !1,
+    onChange: i,
+    caller: $t
+  });
+  return /* @__PURE__ */ p(
+    Ai,
+    {
+      scope: e,
+      triggerRef: a,
+      contentRef: l,
+      contentId: Ut(),
+      titleId: Ut(),
+      descriptionId: Ut(),
+      open: d,
+      onOpenChange: h,
+      onOpenToggle: w.useCallback(() => h((f) => !f), [h]),
+      modal: o,
+      children: n
+    }
+  );
+};
+fr.displayName = $t;
+var hr = "DialogTrigger", pr = w.forwardRef(
+  (t, e) => {
+    const { __scopeDialog: n, ...r } = t, s = de(hr, n), i = Pt(e, s.triggerRef);
+    return /* @__PURE__ */ p(
+      Ct.button,
+      {
+        type: "button",
+        "aria-haspopup": "dialog",
+        "aria-expanded": s.open,
+        "aria-controls": s.contentId,
+        "data-state": yn(s.open),
+        ...r,
+        ref: i,
+        onClick: We(t.onClick, s.onOpenToggle)
+      }
+    );
+  }
+);
+pr.displayName = hr;
+var hn = "DialogPortal", [Ei, yr] = ur(hn, {
+  forceMount: void 0
+}), gr = (t) => {
+  const { __scopeDialog: e, forceMount: n, children: r, container: s } = t, i = de(hn, e);
+  return /* @__PURE__ */ p(Ei, { scope: e, forceMount: n, children: w.Children.map(r, (o) => /* @__PURE__ */ p(un, { present: n || i.open, children: /* @__PURE__ */ p(Ps, { asChild: !0, container: s, children: o }) })) });
+};
+gr.displayName = hn;
+var kt = "DialogOverlay", mr = w.forwardRef(
+  (t, e) => {
+    const n = yr(kt, t.__scopeDialog), { forceMount: r = n.forceMount, ...s } = t, i = de(kt, t.__scopeDialog);
+    return i.modal ? /* @__PURE__ */ p(un, { present: r || i.open, children: /* @__PURE__ */ p(Ri, { ...s, ref: e }) }) : null;
+  }
+);
+mr.displayName = kt;
+var zi = /* @__PURE__ */ xi("DialogOverlay.RemoveScroll"), Ri = w.forwardRef(
+  (t, e) => {
+    const { __scopeDialog: n, ...r } = t, s = de(kt, n);
+    return (
+      // Make sure `Content` is scrollable even when it doesn't live inside `RemoveScroll`
+      // ie. when `Overlay` and `Content` are siblings
+      /* @__PURE__ */ p(Ds, { as: zi, allowPinchZoom: !0, shards: [s.contentRef], children: /* @__PURE__ */ p(
+        Ct.div,
+        {
+          "data-state": yn(s.open),
+          ...r,
+          ref: e,
+          style: { pointerEvents: "auto", ...r.style }
+        }
+      ) })
+    );
+  }
+), je = "DialogContent", vr = w.forwardRef(
+  (t, e) => {
+    const n = yr(je, t.__scopeDialog), { forceMount: r = n.forceMount, ...s } = t, i = de(je, t.__scopeDialog);
+    return /* @__PURE__ */ p(un, { present: r || i.open, children: i.modal ? /* @__PURE__ */ p(Ni, { ...s, ref: e }) : /* @__PURE__ */ p(Ii, { ...s, ref: e }) });
+  }
+);
+vr.displayName = je;
+var Ni = w.forwardRef(
+  (t, e) => {
+    const n = de(je, t.__scopeDialog), r = w.useRef(null), s = Pt(e, n.contentRef, r);
+    return w.useEffect(() => {
+      const i = r.current;
+      if (i) return As(i);
+    }, []), /* @__PURE__ */ p(
+      br,
+      {
+        ...t,
+        ref: s,
+        trapFocus: n.open,
+        disableOutsidePointerEvents: !0,
+        onCloseAutoFocus: We(t.onCloseAutoFocus, (i) => {
+          var o;
+          i.preventDefault(), (o = n.triggerRef.current) == null || o.focus();
+        }),
+        onPointerDownOutside: We(t.onPointerDownOutside, (i) => {
+          const o = i.detail.originalEvent, a = o.button === 0 && o.ctrlKey === !0;
+          (o.button === 2 || a) && i.preventDefault();
+        }),
+        onFocusOutside: We(
+          t.onFocusOutside,
+          (i) => i.preventDefault()
+        )
+      }
+    );
+  }
+), Ii = w.forwardRef(
+  (t, e) => {
+    const n = de(je, t.__scopeDialog), r = w.useRef(!1), s = w.useRef(!1);
+    return /* @__PURE__ */ p(
+      br,
+      {
+        ...t,
+        ref: e,
+        trapFocus: !1,
+        disableOutsidePointerEvents: !1,
+        onCloseAutoFocus: (i) => {
+          var o, a;
+          (o = t.onCloseAutoFocus) == null || o.call(t, i), i.defaultPrevented || (r.current || (a = n.triggerRef.current) == null || a.focus(), i.preventDefault()), r.current = !1, s.current = !1;
+        },
+        onInteractOutside: (i) => {
+          var l, d;
+          (l = t.onInteractOutside) == null || l.call(t, i), i.defaultPrevented || (r.current = !0, i.detail.originalEvent.type === "pointerdown" && (s.current = !0));
+          const o = i.target;
+          ((d = n.triggerRef.current) == null ? void 0 : d.contains(o)) && i.preventDefault(), i.detail.originalEvent.type === "focusin" && s.current && i.preventDefault();
+        }
+      }
+    );
+  }
+), br = w.forwardRef(
+  (t, e) => {
+    const { __scopeDialog: n, trapFocus: r, onOpenAutoFocus: s, onCloseAutoFocus: i, ...o } = t, a = de(je, n), l = w.useRef(null), d = Pt(e, l);
+    return Es(), /* @__PURE__ */ qe(It, { children: [
+      /* @__PURE__ */ p(
+        zs,
+        {
+          asChild: !0,
+          loop: !0,
+          trapped: r,
+          onMountAutoFocus: s,
+          onUnmountAutoFocus: i,
+          children: /* @__PURE__ */ p(
+            Rs,
+            {
+              role: "dialog",
+              id: a.contentId,
+              "aria-describedby": a.descriptionId,
+              "aria-labelledby": a.titleId,
+              "data-state": yn(a.open),
+              ...o,
+              ref: d,
+              onDismiss: () => a.onOpenChange(!1)
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ qe(It, { children: [
+        /* @__PURE__ */ p(Oi, { titleId: a.titleId }),
+        /* @__PURE__ */ p(Ti, { contentRef: l, descriptionId: a.descriptionId })
+      ] })
+    ] });
+  }
+), pn = "DialogTitle", xr = w.forwardRef(
+  (t, e) => {
+    const { __scopeDialog: n, ...r } = t, s = de(pn, n);
+    return /* @__PURE__ */ p(Ct.h2, { id: s.titleId, ...r, ref: e });
+  }
+);
+xr.displayName = pn;
+var wr = "DialogDescription", Sr = w.forwardRef(
+  (t, e) => {
+    const { __scopeDialog: n, ...r } = t, s = de(wr, n);
+    return /* @__PURE__ */ p(Ct.p, { id: s.descriptionId, ...r, ref: e });
+  }
+);
+Sr.displayName = wr;
+var Cr = "DialogClose", Pr = w.forwardRef(
+  (t, e) => {
+    const { __scopeDialog: n, ...r } = t, s = de(Cr, n);
+    return /* @__PURE__ */ p(
+      Ct.button,
+      {
+        type: "button",
+        ...r,
+        ref: e,
+        onClick: We(t.onClick, () => s.onOpenChange(!1))
+      }
+    );
+  }
+);
+Pr.displayName = Cr;
+function yn(t) {
+  return t ? "open" : "closed";
+}
+var Dr = "DialogTitleWarning", [Mi, Ar] = Ns(Dr, {
+  contentName: je,
+  titleName: pn,
+  docsSlug: "dialog"
+}), Oi = ({ titleId: t }) => {
+  const e = Ar(Dr), n = `\`${e.contentName}\` requires a \`${e.titleName}\` for the component to be accessible for screen reader users.
+
+If you want to hide the \`${e.titleName}\`, you can wrap it with our VisuallyHidden component.
+
+For more information, see https://radix-ui.com/primitives/docs/components/${e.docsSlug}`;
+  return w.useEffect(() => {
+    t && (document.getElementById(t) || console.error(n));
+  }, [n, t]), null;
+}, ki = "DialogDescriptionWarning", Ti = ({ contentRef: t, descriptionId: e }) => {
+  const r = `Warning: Missing \`Description\` or \`aria-describedby={undefined}\` for {${Ar(ki).contentName}}.`;
+  return w.useEffect(() => {
+    var i;
+    const s = (i = t.current) == null ? void 0 : i.getAttribute("aria-describedby");
+    e && s && (document.getElementById(e) || console.warn(r));
+  }, [r, t, e]), null;
+}, _i = fr, Fi = pr, Li = gr, $i = mr, qi = vr, Hi = xr, Qi = Sr, Er = Pr, ji = Symbol("radix.slottable");
+// @__NO_SIDE_EFFECTS__
+function Gi(t) {
+  const e = ({ children: n }) => /* @__PURE__ */ p(It, { children: n });
+  return e.displayName = `${t}.Slottable`, e.__radixId = ji, e;
+}
+var zr = "AlertDialog", [Ki] = tr(zr, [
+  dr
+]), Se = dr(), Rr = (t) => {
+  const { __scopeAlertDialog: e, ...n } = t, r = Se(e);
+  return /* @__PURE__ */ p(_i, { ...r, ...n, modal: !0 });
+};
+Rr.displayName = zr;
+var Bi = "AlertDialogTrigger", Nr = w.forwardRef(
+  (t, e) => {
+    const { __scopeAlertDialog: n, ...r } = t, s = Se(n);
+    return /* @__PURE__ */ p(Fi, { ...s, ...r, ref: e });
+  }
+);
+Nr.displayName = Bi;
+var Ui = "AlertDialogPortal", Ir = (t) => {
+  const { __scopeAlertDialog: e, ...n } = t, r = Se(e);
+  return /* @__PURE__ */ p(Li, { ...r, ...n });
+};
+Ir.displayName = Ui;
+var Vi = "AlertDialogOverlay", Mr = w.forwardRef(
+  (t, e) => {
+    const { __scopeAlertDialog: n, ...r } = t, s = Se(n);
+    return /* @__PURE__ */ p($i, { ...s, ...r, ref: e });
+  }
+);
+Mr.displayName = Vi;
+var Xe = "AlertDialogContent", [Wi, Xi] = Ki(Xe), Ji = /* @__PURE__ */ Gi("AlertDialogContent"), Or = w.forwardRef(
+  (t, e) => {
+    const { __scopeAlertDialog: n, children: r, ...s } = t, i = Se(n), o = w.useRef(null), a = Pt(e, o), l = w.useRef(null);
+    return /* @__PURE__ */ p(
+      Mi,
+      {
+        contentName: Xe,
+        titleName: kr,
+        docsSlug: "alert-dialog",
+        children: /* @__PURE__ */ p(Wi, { scope: n, cancelRef: l, children: /* @__PURE__ */ qe(
+          qi,
+          {
+            role: "alertdialog",
+            ...i,
+            ...s,
+            ref: a,
+            onOpenAutoFocus: We(s.onOpenAutoFocus, (d) => {
+              var h;
+              d.preventDefault(), (h = l.current) == null || h.focus({ preventScroll: !0 });
+            }),
+            onPointerDownOutside: (d) => d.preventDefault(),
+            onInteractOutside: (d) => d.preventDefault(),
+            children: [
+              /* @__PURE__ */ p(Ji, { children: r }),
+              /* @__PURE__ */ p(Zi, { contentRef: o })
+            ]
+          }
+        ) })
+      }
+    );
+  }
+);
+Or.displayName = Xe;
+var kr = "AlertDialogTitle", Tr = w.forwardRef(
+  (t, e) => {
+    const { __scopeAlertDialog: n, ...r } = t, s = Se(n);
+    return /* @__PURE__ */ p(Hi, { ...s, ...r, ref: e });
+  }
+);
+Tr.displayName = kr;
+var _r = "AlertDialogDescription", Fr = w.forwardRef((t, e) => {
+  const { __scopeAlertDialog: n, ...r } = t, s = Se(n);
+  return /* @__PURE__ */ p(Qi, { ...s, ...r, ref: e });
+});
+Fr.displayName = _r;
+var Yi = "AlertDialogAction", Lr = w.forwardRef(
+  (t, e) => {
+    const { __scopeAlertDialog: n, ...r } = t, s = Se(n);
+    return /* @__PURE__ */ p(Er, { ...s, ...r, ref: e });
+  }
+);
+Lr.displayName = Yi;
+var $r = "AlertDialogCancel", qr = w.forwardRef(
+  (t, e) => {
+    const { __scopeAlertDialog: n, ...r } = t, { cancelRef: s } = Xi($r, n), i = Se(n), o = Pt(e, s);
+    return /* @__PURE__ */ p(Er, { ...i, ...r, ref: o });
+  }
+);
+qr.displayName = $r;
+var Zi = ({ contentRef: t }) => {
+  const e = `\`${Xe}\` requires a description for the component to be accessible for screen reader users.
+
+You can add a description to the \`${Xe}\` by passing a \`${_r}\` component as a child, which also benefits sighted users by adding visible context to the dialog.
+
+Alternatively, you can use your own component as a description by assigning it an \`id\` and passing the same value to the \`aria-describedby\` prop in \`${Xe}\`. If the description is confusing or duplicative for sighted users, you can use the \`@radix-ui/react-visually-hidden\` primitive as a wrapper around your description component.
+
+For more information, see https://radix-ui.com/primitives/docs/components/alert-dialog`;
+  return w.useEffect(() => {
+    var r;
+    document.getElementById(
+      (r = t.current) == null ? void 0 : r.getAttribute("aria-describedby")
+    ) || console.warn(e);
+  }, [e, t]), null;
+}, ea = Rr, ta = Nr, na = Ir, Hr = Mr, Qr = Or, jr = Lr, Gr = qr, Kr = Tr, Br = Fr;
+const bo = ea, xo = ta, ra = na, Ur = w.forwardRef(({ className: t, ...e }, n) => /* @__PURE__ */ p(
+  Hr,
+  {
+    className: se(
+      "fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      t
+    ),
+    ...e,
+    ref: n
+  }
+));
+Ur.displayName = Hr.displayName;
+const sa = w.forwardRef(({ className: t, ...e }, n) => /* @__PURE__ */ qe(ra, { children: [
+  /* @__PURE__ */ p(Cn, { children: /* @__PURE__ */ p(Ur, {}) }),
+  /* @__PURE__ */ p(Cn, { children: /* @__PURE__ */ p(
+    Qr,
+    {
+      ref: n,
+      className: se(
+        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        t
+      ),
+      ...e
+    }
+  ) })
+] }));
+sa.displayName = Qr.displayName;
+const ia = ({
+  className: t,
+  ...e
+}) => /* @__PURE__ */ p(
+  "div",
+  {
+    className: se(
+      "flex flex-col space-y-1 text-center sm:text-left",
+      t
+    ),
+    ...e
+  }
+);
+ia.displayName = "AlertDialogHeader";
+const aa = ({
+  className: t,
+  ...e
+}) => /* @__PURE__ */ p(
+  "div",
+  {
+    className: se(
+      "flex flex-col-reverse gap-1.5 sm:flex-row sm:justify-end sm:space-x-0",
+      t
+    ),
+    ...e
+  }
+);
+aa.displayName = "AlertDialogFooter";
+const oa = w.forwardRef(({ className: t, ...e }, n) => /* @__PURE__ */ p(
+  Kr,
+  {
+    ref: n,
+    className: se("text-[15px] font-semibold", t),
+    ...e
+  }
+));
+oa.displayName = Kr.displayName;
+const la = w.forwardRef(({ className: t, ...e }, n) => /* @__PURE__ */ p(
+  Br,
+  {
+    ref: n,
+    className: se("text-[13px] leading-5 text-muted-foreground", t),
+    ...e
+  }
+));
+la.displayName = Br.displayName;
+const ca = w.forwardRef(({ className: t, ...e }, n) => /* @__PURE__ */ p(
+  jr,
+  {
+    ref: n,
+    className: se(nr({ size: "xs" }), t),
+    ...e
+  }
+));
+ca.displayName = jr.displayName;
+const ua = w.forwardRef(({ className: t, ...e }, n) => /* @__PURE__ */ p(
+  Gr,
+  {
+    ref: n,
+    className: se(
+      nr({ variant: "outline", size: "xs" }),
+      t
+    ),
+    ...e
+  }
+));
+ua.displayName = Gr.displayName;
+const qt = cn(null);
+qt.displayName = "PanelGroupContext";
+const H = {
+  group: "data-panel-group",
+  groupDirection: "data-panel-group-direction",
+  groupId: "data-panel-group-id",
+  panel: "data-panel",
+  panelCollapsible: "data-panel-collapsible",
+  panelId: "data-panel-id",
+  panelSize: "data-panel-size",
+  resizeHandle: "data-resize-handle",
+  resizeHandleActive: "data-resize-handle-active",
+  resizeHandleEnabled: "data-panel-resize-handle-enabled",
+  resizeHandleId: "data-panel-resize-handle-id",
+  resizeHandleState: "data-resize-handle-state"
+}, gn = 10, Qe = ws, kn = w.useId, da = typeof kn == "function" ? kn : () => null;
+let fa = 0;
+function mn(t = null) {
+  const e = da(), n = te(t || e || null);
+  return n.current === null && (n.current = "" + fa++), t ?? n.current;
+}
+function Vr({
+  children: t,
+  className: e = "",
+  collapsedSize: n,
+  collapsible: r,
+  defaultSize: s,
+  forwardedRef: i,
+  id: o,
+  maxSize: a,
+  minSize: l,
+  onCollapse: d,
+  onExpand: h,
+  onResize: f,
+  order: u,
+  style: v,
+  tagName: b = "div",
+  ...g
+}) {
+  const C = ln(qt);
+  if (C === null)
+    throw Error("Panel components must be rendered within a PanelGroup container");
+  const {
+    collapsePanel: x,
+    expandPanel: I,
+    getPanelSize: z,
+    getPanelStyle: y,
+    groupId: F,
+    isPanelCollapsed: O,
+    reevaluatePanelConstraints: D,
+    registerPanel: B,
+    resizePanel: W,
+    unregisterPanel: T
+  } = C, L = mn(o), Q = te({
+    callbacks: {
+      onCollapse: d,
+      onExpand: h,
+      onResize: f
+    },
+    constraints: {
+      collapsedSize: n,
+      collapsible: r,
+      defaultSize: s,
+      maxSize: a,
+      minSize: l
+    },
+    id: L,
+    idIsFromProps: o !== void 0,
+    order: u
+  });
+  te({
+    didLogMissingDefaultSizeWarning: !1
+  }), Qe(() => {
+    const {
+      callbacks: U,
+      constraints: G
+    } = Q.current, X = {
+      ...G
+    };
+    Q.current.id = L, Q.current.idIsFromProps = o !== void 0, Q.current.order = u, U.onCollapse = d, U.onExpand = h, U.onResize = f, G.collapsedSize = n, G.collapsible = r, G.defaultSize = s, G.maxSize = a, G.minSize = l, (X.collapsedSize !== G.collapsedSize || X.collapsible !== G.collapsible || X.maxSize !== G.maxSize || X.minSize !== G.minSize) && D(Q.current, X);
+  }), Qe(() => {
+    const U = Q.current;
+    return B(U), () => {
+      T(U);
+    };
+  }, [u, L, B, T]), er(i, () => ({
+    collapse: () => {
+      x(Q.current);
+    },
+    expand: (U) => {
+      I(Q.current, U);
+    },
+    getId() {
+      return L;
+    },
+    getSize() {
+      return z(Q.current);
+    },
+    isCollapsed() {
+      return O(Q.current);
+    },
+    isExpanded() {
+      return !O(Q.current);
+    },
+    resize: (U) => {
+      W(Q.current, U);
+    }
+  }), [x, I, z, O, L, W]);
+  const Ne = y(Q.current, s);
+  return at(b, {
+    ...g,
+    children: t,
+    className: e,
+    id: L,
+    style: {
+      ...Ne,
+      ...v
+    },
+    // CSS selectors
+    [H.groupId]: F,
+    [H.panel]: "",
+    [H.panelCollapsible]: r || void 0,
+    [H.panelId]: L,
+    [H.panelSize]: parseFloat("" + Ne.flexGrow).toFixed(1)
+  });
+}
+const Wr = Zn((t, e) => at(Vr, {
+  ...t,
+  forwardedRef: e
+}));
+Vr.displayName = "Panel";
+Wr.displayName = "forwardRef(Panel)";
+let an = null, Nt = -1, Pe = null;
+function ha(t, e) {
+  if (e) {
+    const n = (e & es) !== 0, r = (e & ts) !== 0, s = (e & ns) !== 0, i = (e & rs) !== 0;
+    if (n)
+      return s ? "se-resize" : i ? "ne-resize" : "e-resize";
+    if (r)
+      return s ? "sw-resize" : i ? "nw-resize" : "w-resize";
+    if (s)
+      return "s-resize";
+    if (i)
+      return "n-resize";
+  }
+  switch (t) {
+    case "horizontal":
+      return "ew-resize";
+    case "intersection":
+      return "move";
+    case "vertical":
+      return "ns-resize";
+  }
+}
+function pa() {
+  Pe !== null && (document.head.removeChild(Pe), an = null, Pe = null, Nt = -1);
+}
+function Vt(t, e) {
+  var n, r;
+  const s = ha(t, e);
+  if (an !== s) {
+    if (an = s, Pe === null && (Pe = document.createElement("style"), document.head.appendChild(Pe)), Nt >= 0) {
+      var i;
+      (i = Pe.sheet) === null || i === void 0 || i.removeRule(Nt);
+    }
+    Nt = (n = (r = Pe.sheet) === null || r === void 0 ? void 0 : r.insertRule(`*{cursor: ${s} !important;}`)) !== null && n !== void 0 ? n : -1;
+  }
+}
+function Xr(t) {
+  return t.type === "keydown";
+}
+function Jr(t) {
+  return t.type.startsWith("pointer");
+}
+function Yr(t) {
+  return t.type.startsWith("mouse");
+}
+function Ht(t) {
+  if (Jr(t)) {
+    if (t.isPrimary)
+      return {
+        x: t.clientX,
+        y: t.clientY
+      };
+  } else if (Yr(t))
+    return {
+      x: t.clientX,
+      y: t.clientY
+    };
+  return {
+    x: 1 / 0,
+    y: 1 / 0
+  };
+}
+function ya() {
+  if (typeof matchMedia == "function")
+    return matchMedia("(pointer:coarse)").matches ? "coarse" : "fine";
+}
+function ga(t, e, n) {
+  return t.x < e.x + e.width && t.x + t.width > e.x && t.y < e.y + e.height && t.y + t.height > e.y;
+}
+function ma(t, e) {
+  if (t === e) throw new Error("Cannot compare node with itself");
+  const n = {
+    a: Fn(t),
+    b: Fn(e)
+  };
+  let r;
+  for (; n.a.at(-1) === n.b.at(-1); )
+    t = n.a.pop(), e = n.b.pop(), r = t;
+  N(r, "Stacking order can only be calculated for elements with a common ancestor");
+  const s = {
+    a: _n(Tn(n.a)),
+    b: _n(Tn(n.b))
+  };
+  if (s.a === s.b) {
+    const i = r.childNodes, o = {
+      a: n.a.at(-1),
+      b: n.b.at(-1)
+    };
+    let a = i.length;
+    for (; a--; ) {
+      const l = i[a];
+      if (l === o.a) return 1;
+      if (l === o.b) return -1;
+    }
+  }
+  return Math.sign(s.a - s.b);
+}
+const va = /\b(?:position|zIndex|opacity|transform|webkitTransform|mixBlendMode|filter|webkitFilter|isolation)\b/;
+function ba(t) {
+  var e;
+  const n = getComputedStyle((e = Zr(t)) !== null && e !== void 0 ? e : t).display;
+  return n === "flex" || n === "inline-flex";
+}
+function xa(t) {
+  const e = getComputedStyle(t);
+  return !!(e.position === "fixed" || e.zIndex !== "auto" && (e.position !== "static" || ba(t)) || +e.opacity < 1 || "transform" in e && e.transform !== "none" || "webkitTransform" in e && e.webkitTransform !== "none" || "mixBlendMode" in e && e.mixBlendMode !== "normal" || "filter" in e && e.filter !== "none" || "webkitFilter" in e && e.webkitFilter !== "none" || "isolation" in e && e.isolation === "isolate" || va.test(e.willChange) || e.webkitOverflowScrolling === "touch");
+}
+function Tn(t) {
+  let e = t.length;
+  for (; e--; ) {
+    const n = t[e];
+    if (N(n, "Missing node"), xa(n)) return n;
+  }
+  return null;
+}
+function _n(t) {
+  return t && Number(getComputedStyle(t).zIndex) || 0;
+}
+function Fn(t) {
+  const e = [];
+  for (; t; )
+    e.push(t), t = Zr(t);
+  return e;
+}
+function Zr(t) {
+  const {
+    parentNode: e
+  } = t;
+  return e && e instanceof ShadowRoot ? e.host : e;
+}
+const es = 1, ts = 2, ns = 4, rs = 8, wa = ya() === "coarse";
+let ce = [], Je = !1, Me = /* @__PURE__ */ new Map(), Qt = /* @__PURE__ */ new Map();
+const mt = /* @__PURE__ */ new Set();
+function Sa(t, e, n, r, s) {
+  var i;
+  const {
+    ownerDocument: o
+  } = e, a = {
+    direction: n,
+    element: e,
+    hitAreaMargins: r,
+    setResizeHandlerState: s
+  }, l = (i = Me.get(o)) !== null && i !== void 0 ? i : 0;
+  return Me.set(o, l + 1), mt.add(a), Tt(), function() {
+    var h;
+    Qt.delete(t), mt.delete(a);
+    const f = (h = Me.get(o)) !== null && h !== void 0 ? h : 1;
+    if (Me.set(o, f - 1), Tt(), f === 1 && Me.delete(o), ce.includes(a)) {
+      const u = ce.indexOf(a);
+      u >= 0 && ce.splice(u, 1), bn(), s("up", !0, null);
+    }
+  };
+}
+function Ca(t) {
+  const {
+    target: e
+  } = t, {
+    x: n,
+    y: r
+  } = Ht(t);
+  Je = !0, vn({
+    target: e,
+    x: n,
+    y: r
+  }), Tt(), ce.length > 0 && (_t("down", t), t.preventDefault(), ss(e) || t.stopImmediatePropagation());
+}
+function Wt(t) {
+  const {
+    x: e,
+    y: n
+  } = Ht(t);
+  if (Je && t.buttons === 0 && (Je = !1, _t("up", t)), !Je) {
+    const {
+      target: r
+    } = t;
+    vn({
+      target: r,
+      x: e,
+      y: n
+    });
+  }
+  _t("move", t), bn(), ce.length > 0 && t.preventDefault();
+}
+function Xt(t) {
+  const {
+    target: e
+  } = t, {
+    x: n,
+    y: r
+  } = Ht(t);
+  Qt.clear(), Je = !1, ce.length > 0 && (t.preventDefault(), ss(e) || t.stopImmediatePropagation()), _t("up", t), vn({
+    target: e,
+    x: n,
+    y: r
+  }), bn(), Tt();
+}
+function ss(t) {
+  let e = t;
+  for (; e; ) {
+    if (e.hasAttribute(H.resizeHandle))
+      return !0;
+    e = e.parentElement;
+  }
+  return !1;
+}
+function vn({
+  target: t,
+  x: e,
+  y: n
+}) {
+  ce.splice(0);
+  let r = null;
+  (t instanceof HTMLElement || t instanceof SVGElement) && (r = t), mt.forEach((s) => {
+    const {
+      element: i,
+      hitAreaMargins: o
+    } = s, a = i.getBoundingClientRect(), {
+      bottom: l,
+      left: d,
+      right: h,
+      top: f
+    } = a, u = wa ? o.coarse : o.fine;
+    if (e >= d - u && e <= h + u && n >= f - u && n <= l + u) {
+      if (r !== null && document.contains(r) && i !== r && !i.contains(r) && !r.contains(i) && // Calculating stacking order has a cost, so we should avoid it if possible
+      // That is why we only check potentially intersecting handles,
+      // and why we skip if the event target is within the handle's DOM
+      ma(r, i) > 0) {
+        let b = r, g = !1;
+        for (; b && !b.contains(i); ) {
+          if (ga(b.getBoundingClientRect(), a)) {
+            g = !0;
+            break;
+          }
+          b = b.parentElement;
+        }
+        if (g)
+          return;
+      }
+      ce.push(s);
+    }
+  });
+}
+function Jt(t, e) {
+  Qt.set(t, e);
+}
+function bn() {
+  let t = !1, e = !1;
+  ce.forEach((r) => {
+    const {
+      direction: s
+    } = r;
+    s === "horizontal" ? t = !0 : e = !0;
+  });
+  let n = 0;
+  Qt.forEach((r) => {
+    n |= r;
+  }), t && e ? Vt("intersection", n) : t ? Vt("horizontal", n) : e ? Vt("vertical", n) : pa();
+}
+let Yt = new AbortController();
+function Tt() {
+  Yt.abort(), Yt = new AbortController();
+  const t = {
+    capture: !0,
+    signal: Yt.signal
+  };
+  mt.size && (Je ? (ce.length > 0 && Me.forEach((e, n) => {
+    const {
+      body: r
+    } = n;
+    e > 0 && (r.addEventListener("contextmenu", Xt, t), r.addEventListener("pointerleave", Wt, t), r.addEventListener("pointermove", Wt, t));
+  }), window.addEventListener("pointerup", Xt, t), window.addEventListener("pointercancel", Xt, t)) : Me.forEach((e, n) => {
+    const {
+      body: r
+    } = n;
+    e > 0 && (r.addEventListener("pointerdown", Ca, t), r.addEventListener("pointermove", Wt, t));
+  }));
+}
+function _t(t, e) {
+  mt.forEach((n) => {
+    const {
+      setResizeHandlerState: r
+    } = n, s = ce.includes(n);
+    r(t, s, e);
+  });
+}
+function Pa() {
+  const [t, e] = ve(0);
+  return ee(() => e((n) => n + 1), []);
+}
+function N(t, e) {
+  if (!t)
+    throw console.error(e), Error(e);
+}
+function Ge(t, e, n = gn) {
+  return t.toFixed(n) === e.toFixed(n) ? 0 : t > e ? 1 : -1;
+}
+function we(t, e, n = gn) {
+  return Ge(t, e, n) === 0;
+}
+function ne(t, e, n) {
+  return Ge(t, e, n) === 0;
+}
+function Da(t, e, n) {
+  if (t.length !== e.length)
+    return !1;
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r], i = e[r];
+    if (!ne(s, i, n))
+      return !1;
+  }
+  return !0;
+}
+function Ve({
+  panelConstraints: t,
+  panelIndex: e,
+  size: n
+}) {
+  const r = t[e];
+  N(r != null, `Panel constraints not found for index ${e}`);
+  let {
+    collapsedSize: s = 0,
+    collapsible: i,
+    maxSize: o = 100,
+    minSize: a = 0
+  } = r;
+  if (Ge(n, a) < 0)
+    if (i) {
+      const l = (s + a) / 2;
+      Ge(n, l) < 0 ? n = s : n = a;
+    } else
+      n = a;
+  return n = Math.min(o, n), n = parseFloat(n.toFixed(gn)), n;
+}
+function ht({
+  delta: t,
+  initialLayout: e,
+  panelConstraints: n,
+  pivotIndices: r,
+  prevLayout: s,
+  trigger: i
+}) {
+  if (ne(t, 0))
+    return e;
+  const o = [...e], [a, l] = r;
+  N(a != null, "Invalid first pivot index"), N(l != null, "Invalid second pivot index");
+  let d = 0;
+  if (i === "keyboard") {
+    {
+      const f = t < 0 ? l : a, u = n[f];
+      N(u, `Panel constraints not found for index ${f}`);
+      const {
+        collapsedSize: v = 0,
+        collapsible: b,
+        minSize: g = 0
+      } = u;
+      if (b) {
+        const C = e[f];
+        if (N(C != null, `Previous layout not found for panel index ${f}`), ne(C, v)) {
+          const x = g - C;
+          Ge(x, Math.abs(t)) > 0 && (t = t < 0 ? 0 - x : x);
+        }
+      }
+    }
+    {
+      const f = t < 0 ? a : l, u = n[f];
+      N(u, `No panel constraints found for index ${f}`);
+      const {
+        collapsedSize: v = 0,
+        collapsible: b,
+        minSize: g = 0
+      } = u;
+      if (b) {
+        const C = e[f];
+        if (N(C != null, `Previous layout not found for panel index ${f}`), ne(C, g)) {
+          const x = C - v;
+          Ge(x, Math.abs(t)) > 0 && (t = t < 0 ? 0 - x : x);
+        }
+      }
+    }
+  }
+  {
+    const f = t < 0 ? 1 : -1;
+    let u = t < 0 ? l : a, v = 0;
+    for (; ; ) {
+      const g = e[u];
+      N(g != null, `Previous layout not found for panel index ${u}`);
+      const x = Ve({
+        panelConstraints: n,
+        panelIndex: u,
+        size: 100
+      }) - g;
+      if (v += x, u += f, u < 0 || u >= n.length)
+        break;
+    }
+    const b = Math.min(Math.abs(t), Math.abs(v));
+    t = t < 0 ? 0 - b : b;
+  }
+  {
+    let u = t < 0 ? a : l;
+    for (; u >= 0 && u < n.length; ) {
+      const v = Math.abs(t) - Math.abs(d), b = e[u];
+      N(b != null, `Previous layout not found for panel index ${u}`);
+      const g = b - v, C = Ve({
+        panelConstraints: n,
+        panelIndex: u,
+        size: g
+      });
+      if (!ne(b, C) && (d += b - C, o[u] = C, d.toPrecision(3).localeCompare(Math.abs(t).toPrecision(3), void 0, {
+        numeric: !0
+      }) >= 0))
+        break;
+      t < 0 ? u-- : u++;
+    }
+  }
+  if (Da(s, o))
+    return s;
+  {
+    const f = t < 0 ? l : a, u = e[f];
+    N(u != null, `Previous layout not found for panel index ${f}`);
+    const v = u + d, b = Ve({
+      panelConstraints: n,
+      panelIndex: f,
+      size: v
+    });
+    if (o[f] = b, !ne(b, v)) {
+      let g = v - b, x = t < 0 ? l : a;
+      for (; x >= 0 && x < n.length; ) {
+        const I = o[x];
+        N(I != null, `Previous layout not found for panel index ${x}`);
+        const z = I + g, y = Ve({
+          panelConstraints: n,
+          panelIndex: x,
+          size: z
+        });
+        if (ne(I, y) || (g -= y - I, o[x] = y), ne(g, 0))
+          break;
+        t > 0 ? x-- : x++;
+      }
+    }
+  }
+  const h = o.reduce((f, u) => u + f, 0);
+  return ne(h, 100) ? o : s;
+}
+function Aa({
+  layout: t,
+  panelsArray: e,
+  pivotIndices: n
+}) {
+  let r = 0, s = 100, i = 0, o = 0;
+  const a = n[0];
+  N(a != null, "No pivot index found"), e.forEach((f, u) => {
+    const {
+      constraints: v
+    } = f, {
+      maxSize: b = 100,
+      minSize: g = 0
+    } = v;
+    u === a ? (r = g, s = b) : (i += g, o += b);
+  });
+  const l = Math.min(s, 100 - i), d = Math.max(r, 100 - o), h = t[a];
+  return {
+    valueMax: l,
+    valueMin: d,
+    valueNow: h
+  };
+}
+function vt(t, e = document) {
+  return Array.from(e.querySelectorAll(`[${H.resizeHandleId}][data-panel-group-id="${t}"]`));
+}
+function is(t, e, n = document) {
+  const s = vt(t, n).findIndex((i) => i.getAttribute(H.resizeHandleId) === e);
+  return s ?? null;
+}
+function as(t, e, n) {
+  const r = is(t, e, n);
+  return r != null ? [r, r + 1] : [-1, -1];
+}
+function os(t, e = document) {
+  var n;
+  if (e instanceof HTMLElement && (e == null || (n = e.dataset) === null || n === void 0 ? void 0 : n.panelGroupId) == t)
+    return e;
+  const r = e.querySelector(`[data-panel-group][data-panel-group-id="${t}"]`);
+  return r || null;
+}
+function jt(t, e = document) {
+  const n = e.querySelector(`[${H.resizeHandleId}="${t}"]`);
+  return n || null;
+}
+function Ea(t, e, n, r = document) {
+  var s, i, o, a;
+  const l = jt(e, r), d = vt(t, r), h = l ? d.indexOf(l) : -1, f = (s = (i = n[h]) === null || i === void 0 ? void 0 : i.id) !== null && s !== void 0 ? s : null, u = (o = (a = n[h + 1]) === null || a === void 0 ? void 0 : a.id) !== null && o !== void 0 ? o : null;
+  return [f, u];
+}
+function za({
+  committedValuesRef: t,
+  eagerValuesRef: e,
+  groupId: n,
+  layout: r,
+  panelDataArray: s,
+  panelGroupElement: i,
+  setLayout: o
+}) {
+  te({
+    didWarnAboutMissingResizeHandle: !1
+  }), Qe(() => {
+    if (!i)
+      return;
+    const a = vt(n, i);
+    for (let l = 0; l < s.length - 1; l++) {
+      const {
+        valueMax: d,
+        valueMin: h,
+        valueNow: f
+      } = Aa({
+        layout: r,
+        panelsArray: s,
+        pivotIndices: [l, l + 1]
+      }), u = a[l];
+      if (u != null) {
+        const v = s[l];
+        N(v, `No panel data found for index "${l}"`), u.setAttribute("aria-controls", v.id), u.setAttribute("aria-valuemax", "" + Math.round(d)), u.setAttribute("aria-valuemin", "" + Math.round(h)), u.setAttribute("aria-valuenow", f != null ? "" + Math.round(f) : "");
+      }
+    }
+    return () => {
+      a.forEach((l, d) => {
+        l.removeAttribute("aria-controls"), l.removeAttribute("aria-valuemax"), l.removeAttribute("aria-valuemin"), l.removeAttribute("aria-valuenow");
+      });
+    };
+  }, [n, r, s, i]), He(() => {
+    if (!i)
+      return;
+    const a = e.current;
+    N(a, "Eager values not found");
+    const {
+      panelDataArray: l
+    } = a, d = os(n, i);
+    N(d != null, `No group found for id "${n}"`);
+    const h = vt(n, i);
+    N(h, `No resize handles found for group id "${n}"`);
+    const f = h.map((u) => {
+      const v = u.getAttribute(H.resizeHandleId);
+      N(v, "Resize handle element has no handle id attribute");
+      const [b, g] = Ea(n, v, l, i);
+      if (b == null || g == null)
+        return () => {
+        };
+      const C = (x) => {
+        if (!x.defaultPrevented)
+          switch (x.key) {
+            case "Enter": {
+              x.preventDefault();
+              const I = l.findIndex((z) => z.id === b);
+              if (I >= 0) {
+                const z = l[I];
+                N(z, `No panel data found for index ${I}`);
+                const y = r[I], {
+                  collapsedSize: F = 0,
+                  collapsible: O,
+                  minSize: D = 0
+                } = z.constraints;
+                if (y != null && O) {
+                  const B = ht({
+                    delta: ne(y, F) ? D - F : F - y,
+                    initialLayout: r,
+                    panelConstraints: l.map((W) => W.constraints),
+                    pivotIndices: as(n, v, i),
+                    prevLayout: r,
+                    trigger: "keyboard"
+                  });
+                  r !== B && o(B);
+                }
+              }
+              break;
+            }
+          }
+      };
+      return u.addEventListener("keydown", C), () => {
+        u.removeEventListener("keydown", C);
+      };
+    });
+    return () => {
+      f.forEach((u) => u());
+    };
+  }, [i, t, e, n, r, s, o]);
+}
+function Ln(t, e) {
+  if (t.length !== e.length)
+    return !1;
+  for (let n = 0; n < t.length; n++)
+    if (t[n] !== e[n])
+      return !1;
+  return !0;
+}
+function ls(t, e) {
+  const n = t === "horizontal", {
+    x: r,
+    y: s
+  } = Ht(e);
+  return n ? r : s;
+}
+function Ra(t, e, n, r, s) {
+  const i = n === "horizontal", o = jt(e, s);
+  N(o, `No resize handle element found for id "${e}"`);
+  const a = o.getAttribute(H.groupId);
+  N(a, "Resize handle element has no group id attribute");
+  let {
+    initialCursorPosition: l
+  } = r;
+  const d = ls(n, t), h = os(a, s);
+  N(h, `No group element found for id "${a}"`);
+  const f = h.getBoundingClientRect(), u = i ? f.width : f.height;
+  return (d - l) / u * 100;
+}
+function Na(t, e, n, r, s, i) {
+  if (Xr(t)) {
+    const o = n === "horizontal";
+    let a = 0;
+    t.shiftKey ? a = 100 : s != null ? a = s : a = 10;
+    let l = 0;
+    switch (t.key) {
+      case "ArrowDown":
+        l = o ? 0 : a;
+        break;
+      case "ArrowLeft":
+        l = o ? -a : 0;
+        break;
+      case "ArrowRight":
+        l = o ? a : 0;
+        break;
+      case "ArrowUp":
+        l = o ? 0 : -a;
+        break;
+      case "End":
+        l = 100;
+        break;
+      case "Home":
+        l = -100;
+        break;
+    }
+    return l;
+  } else
+    return r == null ? 0 : Ra(t, e, n, r, i);
+}
+function Ia({
+  panelDataArray: t
+}) {
+  const e = Array(t.length), n = t.map((i) => i.constraints);
+  let r = 0, s = 100;
+  for (let i = 0; i < t.length; i++) {
+    const o = n[i];
+    N(o, `Panel constraints not found for index ${i}`);
+    const {
+      defaultSize: a
+    } = o;
+    a != null && (r++, e[i] = a, s -= a);
+  }
+  for (let i = 0; i < t.length; i++) {
+    const o = n[i];
+    N(o, `Panel constraints not found for index ${i}`);
+    const {
+      defaultSize: a
+    } = o;
+    if (a != null)
+      continue;
+    const l = t.length - r, d = s / l;
+    r++, e[i] = d, s -= d;
+  }
+  return e;
+}
+function Be(t, e, n) {
+  e.forEach((r, s) => {
+    const i = t[s];
+    N(i, `Panel data not found for index ${s}`);
+    const {
+      callbacks: o,
+      constraints: a,
+      id: l
+    } = i, {
+      collapsedSize: d = 0,
+      collapsible: h
+    } = a, f = n[l];
+    if (f == null || r !== f) {
+      n[l] = r;
+      const {
+        onCollapse: u,
+        onExpand: v,
+        onResize: b
+      } = o;
+      b && b(r, f), h && (u || v) && (v && (f == null || we(f, d)) && !we(r, d) && v(), u && (f == null || !we(f, d)) && we(r, d) && u());
+    }
+  });
+}
+function Rt(t, e) {
+  if (t.length !== e.length)
+    return !1;
+  for (let n = 0; n < t.length; n++)
+    if (t[n] != e[n])
+      return !1;
+  return !0;
+}
+function Ma({
+  defaultSize: t,
+  dragState: e,
+  layout: n,
+  panelData: r,
+  panelIndex: s,
+  precision: i = 3
+}) {
+  const o = n[s];
+  let a;
+  return o == null ? a = t != null ? t.toPrecision(i) : "1" : r.length === 1 ? a = "1" : a = o.toPrecision(i), {
+    flexBasis: 0,
+    flexGrow: a,
+    flexShrink: 1,
+    // Without this, Panel sizes may be unintentionally overridden by their content
+    overflow: "hidden",
+    // Disable pointer events inside of a panel during resize
+    // This avoid edge cases like nested iframes
+    pointerEvents: e !== null ? "none" : void 0
+  };
+}
+function Oa(t, e = 10) {
+  let n = null;
+  return (...s) => {
+    n !== null && clearTimeout(n), n = setTimeout(() => {
+      t(...s);
+    }, e);
+  };
+}
+function $n(t) {
+  try {
+    if (typeof localStorage < "u")
+      t.getItem = (e) => localStorage.getItem(e), t.setItem = (e, n) => {
+        localStorage.setItem(e, n);
+      };
+    else
+      throw new Error("localStorage not supported in this environment");
+  } catch (e) {
+    console.error(e), t.getItem = () => null, t.setItem = () => {
+    };
+  }
+}
+function cs(t) {
+  return `react-resizable-panels:${t}`;
+}
+function us(t) {
+  return t.map((e) => {
+    const {
+      constraints: n,
+      id: r,
+      idIsFromProps: s,
+      order: i
+    } = e;
+    return s ? r : i ? `${i}:${JSON.stringify(n)}` : JSON.stringify(n);
+  }).sort((e, n) => e.localeCompare(n)).join(",");
+}
+function ds(t, e) {
+  try {
+    const n = cs(t), r = e.getItem(n);
+    if (r) {
+      const s = JSON.parse(r);
+      if (typeof s == "object" && s != null)
+        return s;
+    }
+  } catch {
+  }
+  return null;
+}
+function ka(t, e, n) {
+  var r, s;
+  const i = (r = ds(t, n)) !== null && r !== void 0 ? r : {}, o = us(e);
+  return (s = i[o]) !== null && s !== void 0 ? s : null;
+}
+function Ta(t, e, n, r, s) {
+  var i;
+  const o = cs(t), a = us(e), l = (i = ds(t, s)) !== null && i !== void 0 ? i : {};
+  l[a] = {
+    expandToSizes: Object.fromEntries(n.entries()),
+    layout: r
+  };
+  try {
+    s.setItem(o, JSON.stringify(l));
+  } catch (d) {
+    console.error(d);
+  }
+}
+function qn({
+  layout: t,
+  panelConstraints: e
+}) {
+  const n = [...t], r = n.reduce((i, o) => i + o, 0);
+  if (n.length !== e.length)
+    throw Error(`Invalid ${e.length} panel layout: ${n.map((i) => `${i}%`).join(", ")}`);
+  if (!ne(r, 100) && n.length > 0)
+    for (let i = 0; i < e.length; i++) {
+      const o = n[i];
+      N(o != null, `No layout data found for index ${i}`);
+      const a = 100 / r * o;
+      n[i] = a;
+    }
+  let s = 0;
+  for (let i = 0; i < e.length; i++) {
+    const o = n[i];
+    N(o != null, `No layout data found for index ${i}`);
+    const a = Ve({
+      panelConstraints: e,
+      panelIndex: i,
+      size: o
+    });
+    o != a && (s += o - a, n[i] = a);
+  }
+  if (!ne(s, 0))
+    for (let i = 0; i < e.length; i++) {
+      const o = n[i];
+      N(o != null, `No layout data found for index ${i}`);
+      const a = o + s, l = Ve({
+        panelConstraints: e,
+        panelIndex: i,
+        size: a
+      });
+      if (o !== l && (s -= l - o, n[i] = l, ne(s, 0)))
+        break;
+    }
+  return n;
+}
+const _a = 100, pt = {
+  getItem: (t) => ($n(pt), pt.getItem(t)),
+  setItem: (t, e) => {
+    $n(pt), pt.setItem(t, e);
+  }
+}, Hn = {};
+function fs({
+  autoSaveId: t = null,
+  children: e,
+  className: n = "",
+  direction: r,
+  forwardedRef: s,
+  id: i = null,
+  onLayout: o = null,
+  keyboardResizeBy: a = null,
+  storage: l = pt,
+  style: d,
+  tagName: h = "div",
+  ...f
+}) {
+  const u = mn(i), v = te(null), [b, g] = ve(null), [C, x] = ve([]), I = Pa(), z = te({}), y = te(/* @__PURE__ */ new Map()), F = te(0), O = te({
+    autoSaveId: t,
+    direction: r,
+    dragState: b,
+    id: u,
+    keyboardResizeBy: a,
+    onLayout: o,
+    storage: l
+  }), D = te({
+    layout: C,
+    panelDataArray: [],
+    panelDataArrayChanged: !1
+  });
+  te({
+    didLogIdAndOrderWarning: !1,
+    didLogPanelConstraintsWarning: !1,
+    prevPanelIds: []
+  }), er(s, () => ({
+    getId: () => O.current.id,
+    getLayout: () => {
+      const {
+        layout: m
+      } = D.current;
+      return m;
+    },
+    setLayout: (m) => {
+      const {
+        onLayout: E
+      } = O.current, {
+        layout: M,
+        panelDataArray: A
+      } = D.current, S = qn({
+        layout: m,
+        panelConstraints: A.map((R) => R.constraints)
+      });
+      Ln(M, S) || (x(S), D.current.layout = S, E && E(S), Be(A, S, z.current));
+    }
+  }), []), Qe(() => {
+    O.current.autoSaveId = t, O.current.direction = r, O.current.dragState = b, O.current.id = u, O.current.onLayout = o, O.current.storage = l;
+  }), za({
+    committedValuesRef: O,
+    eagerValuesRef: D,
+    groupId: u,
+    layout: C,
+    panelDataArray: D.current.panelDataArray,
+    setLayout: x,
+    panelGroupElement: v.current
+  }), He(() => {
+    const {
+      panelDataArray: m
+    } = D.current;
+    if (t) {
+      if (C.length === 0 || C.length !== m.length)
+        return;
+      let E = Hn[t];
+      E == null && (E = Oa(Ta, _a), Hn[t] = E);
+      const M = [...m], A = new Map(y.current);
+      E(t, M, A, C, l);
+    }
+  }, [t, C, l]), He(() => {
+  });
+  const B = ee((m) => {
+    const {
+      onLayout: E
+    } = O.current, {
+      layout: M,
+      panelDataArray: A
+    } = D.current;
+    if (m.constraints.collapsible) {
+      const S = A.map((fe) => fe.constraints), {
+        collapsedSize: R = 0,
+        panelSize: _,
+        pivotIndices: j
+      } = Ie(A, m, M);
+      if (N(_ != null, `Panel size not found for panel "${m.id}"`), !we(_, R)) {
+        y.current.set(m.id, _);
+        const he = Ue(A, m) === A.length - 1 ? _ - R : R - _, $ = ht({
+          delta: he,
+          initialLayout: M,
+          panelConstraints: S,
+          pivotIndices: j,
+          prevLayout: M,
+          trigger: "imperative-api"
+        });
+        Rt(M, $) || (x($), D.current.layout = $, E && E($), Be(A, $, z.current));
+      }
+    }
+  }, []), W = ee((m, E) => {
+    const {
+      onLayout: M
+    } = O.current, {
+      layout: A,
+      panelDataArray: S
+    } = D.current;
+    if (m.constraints.collapsible) {
+      const R = S.map((ie) => ie.constraints), {
+        collapsedSize: _ = 0,
+        panelSize: j = 0,
+        minSize: fe = 0,
+        pivotIndices: he
+      } = Ie(S, m, A), $ = E ?? fe;
+      if (we(j, _)) {
+        const ie = y.current.get(m.id), dt = ie != null && ie >= $ ? ie : $, Kt = Ue(S, m) === S.length - 1 ? j - dt : dt - j, Z = ht({
+          delta: Kt,
+          initialLayout: A,
+          panelConstraints: R,
+          pivotIndices: he,
+          prevLayout: A,
+          trigger: "imperative-api"
+        });
+        Rt(A, Z) || (x(Z), D.current.layout = Z, M && M(Z), Be(S, Z, z.current));
+      }
+    }
+  }, []), T = ee((m) => {
+    const {
+      layout: E,
+      panelDataArray: M
+    } = D.current, {
+      panelSize: A
+    } = Ie(M, m, E);
+    return N(A != null, `Panel size not found for panel "${m.id}"`), A;
+  }, []), L = ee((m, E) => {
+    const {
+      panelDataArray: M
+    } = D.current, A = Ue(M, m);
+    return Ma({
+      defaultSize: E,
+      dragState: b,
+      layout: C,
+      panelData: M,
+      panelIndex: A
+    });
+  }, [b, C]), Q = ee((m) => {
+    const {
+      layout: E,
+      panelDataArray: M
+    } = D.current, {
+      collapsedSize: A = 0,
+      collapsible: S,
+      panelSize: R
+    } = Ie(M, m, E);
+    return N(R != null, `Panel size not found for panel "${m.id}"`), S === !0 && we(R, A);
+  }, []), Ne = ee((m) => {
+    const {
+      layout: E,
+      panelDataArray: M
+    } = D.current, {
+      collapsedSize: A = 0,
+      collapsible: S,
+      panelSize: R
+    } = Ie(M, m, E);
+    return N(R != null, `Panel size not found for panel "${m.id}"`), !S || Ge(R, A) > 0;
+  }, []), U = ee((m) => {
+    const {
+      panelDataArray: E
+    } = D.current;
+    E.push(m), E.sort((M, A) => {
+      const S = M.order, R = A.order;
+      return S == null && R == null ? 0 : S == null ? -1 : R == null ? 1 : S - R;
+    }), D.current.panelDataArrayChanged = !0, I();
+  }, [I]);
+  Qe(() => {
+    if (D.current.panelDataArrayChanged) {
+      D.current.panelDataArrayChanged = !1;
+      const {
+        autoSaveId: m,
+        onLayout: E,
+        storage: M
+      } = O.current, {
+        layout: A,
+        panelDataArray: S
+      } = D.current;
+      let R = null;
+      if (m) {
+        const j = ka(m, S, M);
+        j && (y.current = new Map(Object.entries(j.expandToSizes)), R = j.layout);
+      }
+      R == null && (R = Ia({
+        panelDataArray: S
+      }));
+      const _ = qn({
+        layout: R,
+        panelConstraints: S.map((j) => j.constraints)
+      });
+      Ln(A, _) || (x(_), D.current.layout = _, E && E(_), Be(S, _, z.current));
+    }
+  }), Qe(() => {
+    const m = D.current;
+    return () => {
+      m.layout = [];
+    };
+  }, []);
+  const G = ee((m) => {
+    let E = !1;
+    const M = v.current;
+    return M && window.getComputedStyle(M, null).getPropertyValue("direction") === "rtl" && (E = !0), function(S) {
+      S.preventDefault();
+      const R = v.current;
+      if (!R)
+        return () => null;
+      const {
+        direction: _,
+        dragState: j,
+        id: fe,
+        keyboardResizeBy: he,
+        onLayout: $
+      } = O.current, {
+        layout: ie,
+        panelDataArray: dt
+      } = D.current, {
+        initialLayout: Dt
+      } = j ?? {}, Kt = as(fe, m, R);
+      let Z = Na(S, m, _, j, he, R);
+      const xn = _ === "horizontal";
+      xn && E && (Z = -Z);
+      const ys = dt.map((gs) => gs.constraints), ft = ht({
+        delta: Z,
+        initialLayout: Dt ?? ie,
+        panelConstraints: ys,
+        pivotIndices: Kt,
+        prevLayout: ie,
+        trigger: Xr(S) ? "keyboard" : "mouse-or-touch"
+      }), wn = !Rt(ie, ft);
+      (Jr(S) || Yr(S)) && F.current != Z && (F.current = Z, !wn && Z !== 0 ? xn ? Jt(m, Z < 0 ? es : ts) : Jt(m, Z < 0 ? ns : rs) : Jt(m, 0)), wn && (x(ft), D.current.layout = ft, $ && $(ft), Be(dt, ft, z.current));
+    };
+  }, []), X = ee((m, E) => {
+    const {
+      onLayout: M
+    } = O.current, {
+      layout: A,
+      panelDataArray: S
+    } = D.current, R = S.map((ie) => ie.constraints), {
+      panelSize: _,
+      pivotIndices: j
+    } = Ie(S, m, A);
+    N(_ != null, `Panel size not found for panel "${m.id}"`);
+    const he = Ue(S, m) === S.length - 1 ? _ - E : E - _, $ = ht({
+      delta: he,
+      initialLayout: A,
+      panelConstraints: R,
+      pivotIndices: j,
+      prevLayout: A,
+      trigger: "imperative-api"
+    });
+    Rt(A, $) || (x($), D.current.layout = $, M && M($), Be(S, $, z.current));
+  }, []), ot = ee((m, E) => {
+    const {
+      layout: M,
+      panelDataArray: A
+    } = D.current, {
+      collapsedSize: S = 0,
+      collapsible: R
+    } = E, {
+      collapsedSize: _ = 0,
+      collapsible: j,
+      maxSize: fe = 100,
+      minSize: he = 0
+    } = m.constraints, {
+      panelSize: $
+    } = Ie(A, m, M);
+    $ != null && (R && j && we($, S) ? we(S, _) || X(m, _) : $ < he ? X(m, he) : $ > fe && X(m, fe));
+  }, [X]), lt = ee((m, E) => {
+    const {
+      direction: M
+    } = O.current, {
+      layout: A
+    } = D.current;
+    if (!v.current)
+      return;
+    const S = jt(m, v.current);
+    N(S, `Drag handle element not found for id "${m}"`);
+    const R = ls(M, E);
+    g({
+      dragHandleId: m,
+      dragHandleRect: S.getBoundingClientRect(),
+      initialCursorPosition: R,
+      initialLayout: A
+    });
+  }, []), ct = ee(() => {
+    g(null);
+  }, []), Gt = ee((m) => {
+    const {
+      panelDataArray: E
+    } = D.current, M = Ue(E, m);
+    M >= 0 && (E.splice(M, 1), delete z.current[m.id], D.current.panelDataArrayChanged = !0, I());
+  }, [I]), Ke = St(() => ({
+    collapsePanel: B,
+    direction: r,
+    dragState: b,
+    expandPanel: W,
+    getPanelSize: T,
+    getPanelStyle: L,
+    groupId: u,
+    isPanelCollapsed: Q,
+    isPanelExpanded: Ne,
+    reevaluatePanelConstraints: ot,
+    registerPanel: U,
+    registerResizeHandle: G,
+    resizePanel: X,
+    startDragging: lt,
+    stopDragging: ct,
+    unregisterPanel: Gt,
+    panelGroupElement: v.current
+  }), [B, b, r, W, T, L, u, Q, Ne, ot, U, G, X, lt, ct, Gt]), ut = {
+    display: "flex",
+    flexDirection: r === "horizontal" ? "row" : "column",
+    height: "100%",
+    overflow: "hidden",
+    width: "100%"
+  };
+  return at(qt.Provider, {
+    value: Ke
+  }, at(h, {
+    ...f,
+    children: e,
+    className: n,
+    id: i,
+    ref: v,
+    style: {
+      ...ut,
+      ...d
+    },
+    // CSS selectors
+    [H.group]: "",
+    [H.groupDirection]: r,
+    [H.groupId]: u
+  }));
+}
+const hs = Zn((t, e) => at(fs, {
+  ...t,
+  forwardedRef: e
+}));
+fs.displayName = "PanelGroup";
+hs.displayName = "forwardRef(PanelGroup)";
+function Ue(t, e) {
+  return t.findIndex((n) => n === e || n.id === e.id);
+}
+function Ie(t, e, n) {
+  const r = Ue(t, e), i = r === t.length - 1 ? [r - 1, r] : [r, r + 1], o = n[r];
+  return {
+    ...e.constraints,
+    panelSize: o,
+    pivotIndices: i
+  };
+}
+function Fa({
+  disabled: t,
+  handleId: e,
+  resizeHandler: n,
+  panelGroupElement: r
+}) {
+  He(() => {
+    if (t || n == null || r == null)
+      return;
+    const s = jt(e, r);
+    if (s == null)
+      return;
+    const i = (o) => {
+      if (!o.defaultPrevented)
+        switch (o.key) {
+          case "ArrowDown":
+          case "ArrowLeft":
+          case "ArrowRight":
+          case "ArrowUp":
+          case "End":
+          case "Home": {
+            o.preventDefault(), n(o);
+            break;
+          }
+          case "F6": {
+            o.preventDefault();
+            const a = s.getAttribute(H.groupId);
+            N(a, `No group element found for id "${a}"`);
+            const l = vt(a, r), d = is(a, e, r);
+            N(d !== null, `No resize element found for id "${e}"`);
+            const h = o.shiftKey ? d > 0 ? d - 1 : l.length - 1 : d + 1 < l.length ? d + 1 : 0;
+            l[h].focus();
+            break;
+          }
+        }
+    };
+    return s.addEventListener("keydown", i), () => {
+      s.removeEventListener("keydown", i);
+    };
+  }, [r, t, e, n]);
+}
+function ps({
+  children: t = null,
+  className: e = "",
+  disabled: n = !1,
+  hitAreaMargins: r,
+  id: s,
+  onBlur: i,
+  onClick: o,
+  onDragging: a,
+  onFocus: l,
+  onPointerDown: d,
+  onPointerUp: h,
+  style: f = {},
+  tabIndex: u = 0,
+  tagName: v = "div",
+  ...b
+}) {
+  var g, C;
+  const x = te(null), I = te({
+    onClick: o,
+    onDragging: a,
+    onPointerDown: d,
+    onPointerUp: h
+  });
+  He(() => {
+    I.current.onClick = o, I.current.onDragging = a, I.current.onPointerDown = d, I.current.onPointerUp = h;
+  });
+  const z = ln(qt);
+  if (z === null)
+    throw Error("PanelResizeHandle components must be rendered within a PanelGroup container");
+  const {
+    direction: y,
+    groupId: F,
+    registerResizeHandle: O,
+    startDragging: D,
+    stopDragging: B,
+    panelGroupElement: W
+  } = z, T = mn(s), [L, Q] = ve("inactive"), [Ne, U] = ve(!1), [G, X] = ve(null), ot = te({
+    state: L
+  });
+  Qe(() => {
+    ot.current.state = L;
+  }), He(() => {
+    if (n)
+      X(null);
+    else {
+      const Ke = O(T);
+      X(() => Ke);
+    }
+  }, [n, T, O]);
+  const lt = (g = r == null ? void 0 : r.coarse) !== null && g !== void 0 ? g : 15, ct = (C = r == null ? void 0 : r.fine) !== null && C !== void 0 ? C : 5;
+  return He(() => {
+    if (n || G == null)
+      return;
+    const Ke = x.current;
+    N(Ke, "Element ref not attached");
+    let ut = !1;
+    return Sa(T, Ke, y, {
+      coarse: lt,
+      fine: ct
+    }, (E, M, A) => {
+      if (!M) {
+        Q("inactive");
+        return;
+      }
+      switch (E) {
+        case "down": {
+          Q("drag"), ut = !1, N(A, 'Expected event to be defined for "down" action'), D(T, A);
+          const {
+            onDragging: S,
+            onPointerDown: R
+          } = I.current;
+          S == null || S(!0), R == null || R();
+          break;
+        }
+        case "move": {
+          const {
+            state: S
+          } = ot.current;
+          ut = !0, S !== "drag" && Q("hover"), N(A, 'Expected event to be defined for "move" action'), G(A);
+          break;
+        }
+        case "up": {
+          Q("hover"), B();
+          const {
+            onClick: S,
+            onDragging: R,
+            onPointerUp: _
+          } = I.current;
+          R == null || R(!1), _ == null || _(), ut || S == null || S();
+          break;
+        }
+      }
+    });
+  }, [lt, y, n, ct, O, T, G, D, B]), Fa({
+    disabled: n,
+    handleId: T,
+    resizeHandler: G,
+    panelGroupElement: W
+  }), at(v, {
+    ...b,
+    children: t,
+    className: e,
+    id: s,
+    onBlur: () => {
+      U(!1), i == null || i();
+    },
+    onFocus: () => {
+      U(!0), l == null || l();
+    },
+    ref: x,
+    role: "separator",
+    style: {
+      ...{
+        touchAction: "none",
+        userSelect: "none"
+      },
+      ...f
+    },
+    tabIndex: u,
+    // CSS selectors
+    [H.groupDirection]: y,
+    [H.groupId]: F,
+    [H.resizeHandle]: "",
+    [H.resizeHandleActive]: L === "drag" ? "pointer" : Ne ? "keyboard" : void 0,
+    [H.resizeHandleEnabled]: !n,
+    [H.resizeHandleId]: T,
+    [H.resizeHandleState]: L
+  });
+}
+ps.displayName = "PanelResizeHandle";
+const wo = ({
+  className: t,
+  ...e
+}) => /* @__PURE__ */ p(
+  hs,
+  {
+    className: se(
+      "flex h-full w-full data-[panel-group-direction=vertical]:flex-col",
+      t
+    ),
+    ...e
+  }
+), So = Wr, Co = ({
+  withHandle: t,
+  className: e,
+  ...n
+}) => /* @__PURE__ */ p(
+  ps,
+  {
+    className: se(
+      "relative flex w-px items-center justify-center bg-border after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring focus-visible:ring-offset-1 data-[panel-group-direction=vertical]:h-px data-[panel-group-direction=vertical]:w-full data-[panel-group-direction=vertical]:after:left-0 data-[panel-group-direction=vertical]:after:h-1 data-[panel-group-direction=vertical]:after:w-full data-[panel-group-direction=vertical]:after:-translate-y-1/2 data-[panel-group-direction=vertical]:after:translate-x-0 [&[data-panel-group-direction=vertical]>div]:rotate-90",
+      e
+    ),
+    ...n,
+    children: t && /* @__PURE__ */ p("div", { className: "z-10 flex h-4 w-3 items-center justify-center rounded-sm border bg-border", children: /* @__PURE__ */ p(bi, { className: "h-2.5 w-2.5" }) })
+  }
+);
+function La({
+  code: t,
+  language: e,
+  wrapLongLines: n = !1,
+  className: r,
+  ariaLabel: s
+}) {
+  const i = St(() => Ms(t, e), [t, e]);
+  return (
+    // `.code-editor` scopes the token colors — see code-editor.css.
+    /* @__PURE__ */ p("div", { className: se("code-editor", r), children: /* @__PURE__ */ p(
+      "pre",
+      {
+        "aria-label": s,
+        className: se(
+          // Matches CodeEditor exactly (text-[12px] leading-[1.55]) so code
+          // reads at one size whether it's in an editor or the assistant.
+          "w-full min-w-0 max-w-full bg-transparent px-3 py-2.5 font-mono text-[12px] leading-[1.55] [font-variant-numeric:tabular-nums]",
+          n ? "overflow-x-hidden whitespace-pre-wrap break-words" : "overflow-x-auto whitespace-pre"
+        ),
+        children: i === null ? (
+          // `.code-editor` sets a muted base colour that tokens normally lift
+          // to foreground. With no tokens at all, every character would stay
+          // muted — so an unsupported language would render as one faint grey
+          // block. Pin it to foreground instead.
+          /* @__PURE__ */ p("code", { className: "text-foreground", children: t })
+        ) : (
+          // Prism output, not user HTML: the input is escaped by Prism before
+          // any tokens are wrapped.
+          /* @__PURE__ */ p("code", { dangerouslySetInnerHTML: { __html: i } })
+        )
+      }
+    ) })
+  );
+}
+const Qn = "h-6 px-2 text-[11px]", $a = {
+  "c++": "cpp",
+  "c#": "csharp"
+}, qa = /^(?:select|with|insert|update|delete|create|alter|drop|truncate|explain|show|describe|desc|call|merge|grant|revoke)\b/i, Ha = /^(?:import|from|def|class|async|await|with|for|while|if|try|print|return|yield|raise|assert|del|@)\b/, Qa = /^[A-Za-z_][\w.[\]'"]*\s*(?:\/\/|\*\*|>>|<<|[-+*/@|&^%])?=(?!=)/;
+function ja(t, e) {
+  const n = t.trim();
+  return n ? e.includes("sql") ? qa.test(n) : e.includes("python") ? n.includes(`
+`) ? !0 : Ha.test(n) || Qa.test(n) : !1 : !1;
+}
+function Ga(t, e) {
+  if (e) return !0;
+  const n = t.trim();
+  return n.includes(`
+`) || n.length > 60;
+}
+function Po({ children: t, handleRun: e }) {
+  var g;
+  const [n, r] = ve(!1), s = (g = t == null ? void 0 : t.props) == null ? void 0 : g.className, i = typeof s == "string" ? s.split(/\s+/).find((C) => C.startsWith("language-")) : "", o = i ? i.slice(9).trim().toLowerCase() : "", a = $a[o] ?? o, l = a === "" ? "sql" : a, d = (o || l).toUpperCase(), h = on(t), f = ja(h, l), u = !!e && f, v = Ga(h, f), b = () => {
+    navigator.clipboard.writeText(h).then(() => {
+      r(!0), setTimeout(() => r(!1), 2e3);
+    });
+  };
+  return v ? /* @__PURE__ */ qe("div", { className: "my-4 w-full min-w-0 max-w-full overflow-hidden rounded-md border border-border/70 bg-card/90 shadow-sm", children: [
+    /* @__PURE__ */ qe("div", { className: "flex min-h-9 items-center justify-between gap-3 border-b border-border/60 bg-muted/30 px-3 py-1.5", children: [
+      /* @__PURE__ */ p("span", { className: "font-mono text-[10px] font-medium uppercase tracking-[0.08em] text-muted-foreground", children: d }),
+      /* @__PURE__ */ qe("div", { className: "flex shrink-0 items-center gap-1.5", children: [
+        /* @__PURE__ */ p(
+          Pn,
+          {
+            type: "button",
+            variant: "outline",
+            size: "xs",
+            "aria-label": n ? "Copied code" : "Copy code",
+            className: Qn,
+            onClick: b,
+            children: n ? "Copied" : "Copy"
+          }
+        ),
+        u && /* @__PURE__ */ p(
+          Pn,
+          {
+            type: "button",
+            variant: "outline",
+            size: "xs",
+            "aria-label": `Run ${l} code`,
+            className: Qn,
+            onClick: () => e == null ? void 0 : e(h, l),
+            children: "Run"
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ p(jn, { code: h, language: l })
+  ] }) : /* @__PURE__ */ p("div", { className: "my-2 w-full min-w-0 max-w-full overflow-hidden rounded-control border border-border/60 bg-muted/20", children: /* @__PURE__ */ p(jn, { code: h, language: l }) });
+}
+function on(t) {
+  if (typeof t == "string")
+    return t;
+  if (Array.isArray(t))
+    return t.map(on).join("");
+  if (bs.isValidElement(t)) {
+    const e = t.props;
+    return on(e.children);
+  }
+  return "";
+}
+const jn = ({
+  code: t,
+  language: e = "sql",
+  wrapLongLines: n = !1
+}) => /* @__PURE__ */ p(La, { code: t, language: e, wrapLongLines: n });
+export {
+  Er as $,
+  bo as A,
+  ae as B,
+  uo as C,
+  fo as D,
+  Lt as E,
+  ho as F,
+  bi as G,
+  Hs as H,
+  Qs as I,
+  Zt as J,
+  sr as K,
+  ni as L,
+  Bs as M,
+  Y as N,
+  Mn as O,
+  po as P,
+  so as Q,
+  yo as R,
+  oo as S,
+  ro as T,
+  yt as U,
+  si as V,
+  tn as W,
+  no as X,
+  $i as Y,
+  Li as Z,
+  qi as _,
+  ui as a,
+  Hi as a0,
+  Qi as a1,
+  _i as a2,
+  Fi as a3,
+  to as a4,
+  ao as a5,
+  On as a6,
+  fi as a7,
+  di as a8,
+  Ot as a9,
+  li as aa,
+  Po as ab,
+  vi as b,
+  wo as c,
+  So as d,
+  xo as e,
+  vo as f,
+  sa as g,
+  ia as h,
+  oa as i,
+  la as j,
+  aa as k,
+  ua as l,
+  ca as m,
+  go as n,
+  Co as o,
+  mo as p,
+  co as q,
+  jn as r,
+  lo as s,
+  ps as t,
+  io as u,
+  Ft as v,
+  Xs as w,
+  js as x,
+  eo as y,
+  en as z
+};