@chaibuilder/sdk 1.2.24 → 1.2.25

package/dist/index-hElOGcFr.js

@@ -0,0 +1,2200 @@
+var lt = (t, e, s) => {
+  if (!e.has(t))
+    throw TypeError("Cannot " + s);
+};
+var i = (t, e, s) => (lt(t, e, "read from private field"), s ? s.call(t) : e.get(t)), h = (t, e, s) => {
+  if (e.has(t))
+    throw TypeError("Cannot add the same private member more than once");
+  e instanceof WeakSet ? e.add(t) : e.set(t, s);
+}, o = (t, e, s, r) => (lt(t, e, "write to private field"), r ? r.call(t, s) : e.set(t, s), s);
+var rt = (t, e, s, r) => ({
+  set _(n) {
+    o(t, e, n, s);
+  },
+  get _() {
+    return i(t, e, r);
+  }
+}), y = (t, e, s) => (lt(t, e, "access private method"), s);
+import { j as u } from "./jsx-runtime-Sp0orL4X.js";
+import * as M from "react";
+import ps, { lazy as Ft, useCallback as dt, useState as ft, Suspense as ms, useEffect as gs } from "react";
+import { c as bs, C as vs } from "./ChaiBuilderEditor-vP4at00I.js";
+import { useTranslation as xs } from "react-i18next";
+import { B as Xt, u as ws } from "./skeleton-lu8e7q2y.js";
+import { FileTextIcon as Cs, GearIcon as Ps, EyeClosedIcon as Os, EyeOpenIcon as Ss } from "@radix-ui/react-icons";
+import { toast as se, Toaster as js } from "sonner";
+import { sortBy as Es, filter as Fs, has as Rs, set as As, capitalize as Ms, get as Mt, omit as qs, size as qt } from "lodash-es";
+import { g as Us } from "./html-to-json-2xtb7520.js";
+import { Loader as ks, LogOutIcon as Ds, Loader2 as Qs } from "lucide-react";
+import { G as Zt } from "./iconBase-h4DuR_XT.js";
+import { A as Ns, a as Ts, b as Is, c as Ls, e as Ks, f as Bs, d as _s, h as $s } from "./alert-dialog-rypfO5ly.js";
+var Ie = 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() {
+  }
+}, Te = typeof window > "u" || "Deno" in window;
+function H() {
+}
+function Hs(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function pt(t) {
+  return typeof t == "number" && t >= 0 && t !== 1 / 0;
+}
+function es(t, e) {
+  return Math.max(t + (e || 0) - Date.now(), 0);
+}
+function Ut(t, e) {
+  const {
+    type: s = "all",
+    exact: r,
+    fetchStatus: n,
+    predicate: a,
+    queryKey: c,
+    stale: d
+  } = t;
+  if (c) {
+    if (r) {
+      if (e.queryHash !== Rt(c, e.options))
+        return !1;
+    } else if (!Be(e.queryKey, c))
+      return !1;
+  }
+  if (s !== "all") {
+    const g = e.isActive();
+    if (s === "active" && !g || s === "inactive" && g)
+      return !1;
+  }
+  return !(typeof d == "boolean" && e.isStale() !== d || typeof n < "u" && n !== e.state.fetchStatus || a && !a(e));
+}
+function kt(t, e) {
+  const { exact: s, status: r, predicate: n, mutationKey: a } = t;
+  if (a) {
+    if (!e.options.mutationKey)
+      return !1;
+    if (s) {
+      if (Ke(e.options.mutationKey) !== Ke(a))
+        return !1;
+    } else if (!Be(e.options.mutationKey, a))
+      return !1;
+  }
+  return !(r && e.state.status !== r || n && !n(e));
+}
+function Rt(t, e) {
+  return ((e == null ? void 0 : e.queryKeyHashFn) || Ke)(t);
+}
+function Ke(t) {
+  return JSON.stringify(
+    t,
+    (e, s) => mt(s) ? Object.keys(s).sort().reduce((r, n) => (r[n] = s[n], r), {}) : s
+  );
+}
+function Be(t, e) {
+  return t === e ? !0 : typeof t != typeof e ? !1 : t && e && typeof t == "object" && typeof e == "object" ? !Object.keys(e).some((s) => !Be(t[s], e[s])) : !1;
+}
+function ts(t, e) {
+  if (t === e)
+    return t;
+  const s = Dt(t) && Dt(e);
+  if (s || mt(t) && mt(e)) {
+    const r = s ? t.length : Object.keys(t).length, n = s ? e : Object.keys(e), a = n.length, c = s ? [] : {};
+    let d = 0;
+    for (let g = 0; g < a; g++) {
+      const b = s ? g : n[g];
+      c[b] = ts(t[b], e[b]), c[b] === t[b] && d++;
+    }
+    return r === a && d === r ? t : c;
+  }
+  return e;
+}
+function at(t, e) {
+  if (t && !e || e && !t)
+    return !1;
+  for (const s in t)
+    if (t[s] !== e[s])
+      return !1;
+  return !0;
+}
+function Dt(t) {
+  return Array.isArray(t) && t.length === Object.keys(t).length;
+}
+function mt(t) {
+  if (!Qt(t))
+    return !1;
+  const e = t.constructor;
+  if (typeof e > "u")
+    return !0;
+  const s = e.prototype;
+  return !(!Qt(s) || !s.hasOwnProperty("isPrototypeOf"));
+}
+function Qt(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function ss(t) {
+  return new Promise((e) => {
+    setTimeout(e, t);
+  });
+}
+function Nt(t) {
+  ss(0).then(t);
+}
+function gt(t, e, s) {
+  return typeof s.structuralSharing == "function" ? s.structuralSharing(t, e) : s.structuralSharing !== !1 ? ts(t, e) : e;
+}
+function Gs(t, e, s = 0) {
+  const r = [...t, e];
+  return s && r.length > s ? r.slice(1) : r;
+}
+function zs(t, e, s = 0) {
+  const r = [e, ...t];
+  return s && r.length > s ? r.slice(0, -1) : r;
+}
+var de, ie, Ce, Bt, Vs = (Bt = class extends Ie {
+  constructor() {
+    super();
+    h(this, de, void 0);
+    h(this, ie, void 0);
+    h(this, Ce, void 0);
+    o(this, Ce, (e) => {
+      if (!Te && window.addEventListener) {
+        const s = () => e();
+        return window.addEventListener("visibilitychange", s, !1), () => {
+          window.removeEventListener("visibilitychange", s);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    i(this, ie) || this.setEventListener(i(this, Ce));
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || ((e = i(this, ie)) == null || e.call(this), o(this, ie, void 0));
+  }
+  setEventListener(e) {
+    var s;
+    o(this, Ce, e), (s = i(this, ie)) == null || s.call(this), o(this, ie, e((r) => {
+      typeof r == "boolean" ? this.setFocused(r) : this.onFocus();
+    }));
+  }
+  setFocused(e) {
+    i(this, de) !== e && (o(this, de, e), this.onFocus());
+  }
+  onFocus() {
+    this.listeners.forEach((e) => {
+      e();
+    });
+  }
+  isFocused() {
+    var e;
+    return typeof i(this, de) == "boolean" ? i(this, de) : ((e = globalThis.document) == null ? void 0 : e.visibilityState) !== "hidden";
+  }
+}, de = new WeakMap(), ie = new WeakMap(), Ce = new WeakMap(), Bt), ot = new Vs(), Pe, ne, Oe, _t, Js = (_t = class extends Ie {
+  constructor() {
+    super();
+    h(this, Pe, !0);
+    h(this, ne, void 0);
+    h(this, Oe, void 0);
+    o(this, Oe, (e) => {
+      if (!Te && window.addEventListener) {
+        const s = () => e(!0), r = () => e(!1);
+        return window.addEventListener("online", s, !1), window.addEventListener("offline", r, !1), () => {
+          window.removeEventListener("online", s), window.removeEventListener("offline", r);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    i(this, ne) || this.setEventListener(i(this, Oe));
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || ((e = i(this, ne)) == null || e.call(this), o(this, ne, void 0));
+  }
+  setEventListener(e) {
+    var s;
+    o(this, Oe, e), (s = i(this, ne)) == null || s.call(this), o(this, ne, e(this.setOnline.bind(this)));
+  }
+  setOnline(e) {
+    i(this, Pe) !== e && (o(this, Pe, e), this.listeners.forEach((r) => {
+      r(e);
+    }));
+  }
+  isOnline() {
+    return i(this, Pe);
+  }
+}, Pe = new WeakMap(), ne = new WeakMap(), Oe = new WeakMap(), _t), ut = new Js();
+function Ws(t) {
+  return Math.min(1e3 * 2 ** t, 3e4);
+}
+function ht(t) {
+  return (t ?? "online") === "online" ? ut.isOnline() : !0;
+}
+var rs = class {
+  constructor(t) {
+    this.revert = t == null ? void 0 : t.revert, this.silent = t == null ? void 0 : t.silent;
+  }
+};
+function yt(t) {
+  return t instanceof rs;
+}
+function is(t) {
+  let e = !1, s = 0, r = !1, n, a, c;
+  const d = new Promise((f, m) => {
+    a = f, c = m;
+  }), g = (f) => {
+    var m;
+    r || (p(new rs(f)), (m = t.abort) == null || m.call(t));
+  }, b = () => {
+    e = !0;
+  }, l = () => {
+    e = !1;
+  }, P = () => !ot.isFocused() || t.networkMode !== "always" && !ut.isOnline(), U = (f) => {
+    var m;
+    r || (r = !0, (m = t.onSuccess) == null || m.call(t, f), n == null || n(), a(f));
+  }, p = (f) => {
+    var m;
+    r || (r = !0, (m = t.onError) == null || m.call(t, f), n == null || n(), c(f));
+  }, v = () => new Promise((f) => {
+    var m;
+    n = (E) => {
+      const x = r || !P();
+      return x && f(E), x;
+    }, (m = t.onPause) == null || m.call(t);
+  }).then(() => {
+    var f;
+    n = void 0, r || (f = t.onContinue) == null || f.call(t);
+  }), S = () => {
+    if (r)
+      return;
+    let f;
+    try {
+      f = t.fn();
+    } catch (m) {
+      f = Promise.reject(m);
+    }
+    Promise.resolve(f).then(U).catch((m) => {
+      var Q;
+      if (r)
+        return;
+      const E = t.retry ?? (Te ? 0 : 3), x = t.retryDelay ?? Ws, w = typeof x == "function" ? x(s, m) : x, q = E === !0 || typeof E == "number" && s < E || typeof E == "function" && E(s, m);
+      if (e || !q) {
+        p(m);
+        return;
+      }
+      s++, (Q = t.onFail) == null || Q.call(t, s, m), ss(w).then(() => {
+        if (P())
+          return v();
+      }).then(() => {
+        e ? p(m) : S();
+      });
+    });
+  };
+  return ht(t.networkMode) ? S() : v().then(S), {
+    promise: d,
+    cancel: g,
+    continue: () => (n == null ? void 0 : n()) ? d : Promise.resolve(),
+    cancelRetry: b,
+    continueRetry: l
+  };
+}
+function Ys() {
+  let t = [], e = 0, s = (l) => {
+    l();
+  }, r = (l) => {
+    l();
+  };
+  const n = (l) => {
+    let P;
+    e++;
+    try {
+      P = l();
+    } finally {
+      e--, e || d();
+    }
+    return P;
+  }, a = (l) => {
+    e ? t.push(l) : Nt(() => {
+      s(l);
+    });
+  }, c = (l) => (...P) => {
+    a(() => {
+      l(...P);
+    });
+  }, d = () => {
+    const l = t;
+    t = [], l.length && Nt(() => {
+      r(() => {
+        l.forEach((P) => {
+          s(P);
+        });
+      });
+    });
+  };
+  return {
+    batch: n,
+    batchCalls: c,
+    schedule: a,
+    setNotifyFunction: (l) => {
+      s = l;
+    },
+    setBatchNotifyFunction: (l) => {
+      r = l;
+    }
+  };
+}
+var R = Ys(), fe, $t, ns = ($t = class {
+  constructor() {
+    h(this, fe, void 0);
+  }
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout(), pt(this.gcTime) && o(this, fe, setTimeout(() => {
+      this.optionalRemove();
+    }, this.gcTime));
+  }
+  updateGcTime(t) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      t ?? (Te ? 1 / 0 : 5 * 60 * 1e3)
+    );
+  }
+  clearGcTimeout() {
+    i(this, fe) && (clearTimeout(i(this, fe)), o(this, fe, void 0));
+  }
+}, fe = new WeakMap(), $t), Se, je, K, ae, B, A, _e, ye, Ee, it, z, ee, Ht, Xs = (Ht = class extends ns {
+  constructor(e) {
+    super();
+    h(this, Ee);
+    h(this, z);
+    h(this, Se, void 0);
+    h(this, je, void 0);
+    h(this, K, void 0);
+    h(this, ae, void 0);
+    h(this, B, void 0);
+    h(this, A, void 0);
+    h(this, _e, void 0);
+    h(this, ye, void 0);
+    o(this, ye, !1), o(this, _e, e.defaultOptions), y(this, Ee, it).call(this, e.options), o(this, A, []), o(this, K, e.cache), this.queryKey = e.queryKey, this.queryHash = e.queryHash, o(this, Se, e.state || Zs(this.options)), this.state = i(this, Se), this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  optionalRemove() {
+    !i(this, A).length && this.state.fetchStatus === "idle" && i(this, K).remove(this);
+  }
+  setData(e, s) {
+    const r = gt(this.state.data, e, this.options);
+    return y(this, z, ee).call(this, {
+      data: r,
+      type: "success",
+      dataUpdatedAt: s == null ? void 0 : s.updatedAt,
+      manual: s == null ? void 0 : s.manual
+    }), r;
+  }
+  setState(e, s) {
+    y(this, z, ee).call(this, { type: "setState", state: e, setStateOptions: s });
+  }
+  cancel(e) {
+    var r;
+    const s = i(this, ae);
+    return (r = i(this, B)) == null || r.cancel(e), s ? s.then(H).catch(H) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy(), this.cancel({ silent: !0 });
+  }
+  reset() {
+    this.destroy(), this.setState(i(this, Se));
+  }
+  isActive() {
+    return i(this, A).some(
+      (e) => e.options.enabled !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 && !this.isActive();
+  }
+  isStale() {
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || i(this, A).some((e) => e.getCurrentResult().isStale);
+  }
+  isStaleByTime(e = 0) {
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || !es(this.state.dataUpdatedAt, e);
+  }
+  onFocus() {
+    var s;
+    const e = i(this, A).find((r) => r.shouldFetchOnWindowFocus());
+    e == null || e.refetch({ cancelRefetch: !1 }), (s = i(this, B)) == null || s.continue();
+  }
+  onOnline() {
+    var s;
+    const e = i(this, A).find((r) => r.shouldFetchOnReconnect());
+    e == null || e.refetch({ cancelRefetch: !1 }), (s = i(this, B)) == null || s.continue();
+  }
+  addObserver(e) {
+    i(this, A).includes(e) || (i(this, A).push(e), this.clearGcTimeout(), i(this, K).notify({ type: "observerAdded", query: this, observer: e }));
+  }
+  removeObserver(e) {
+    i(this, A).includes(e) && (o(this, A, i(this, A).filter((s) => s !== e)), i(this, A).length || (i(this, B) && (i(this, ye) ? i(this, B).cancel({ revert: !0 }) : i(this, B).cancelRetry()), this.scheduleGc()), i(this, K).notify({ type: "observerRemoved", query: this, observer: e }));
+  }
+  getObserversCount() {
+    return i(this, A).length;
+  }
+  invalidate() {
+    this.state.isInvalidated || y(this, z, ee).call(this, { type: "invalidate" });
+  }
+  fetch(e, s) {
+    var b, l, P, U;
+    if (this.state.fetchStatus !== "idle") {
+      if (this.state.dataUpdatedAt && (s != null && s.cancelRefetch))
+        this.cancel({ silent: !0 });
+      else if (i(this, ae))
+        return (b = i(this, B)) == null || b.continueRetry(), i(this, ae);
+    }
+    if (e && y(this, Ee, it).call(this, e), !this.options.queryFn) {
+      const p = i(this, A).find((v) => v.options.queryFn);
+      p && y(this, Ee, it).call(this, p.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(), n = {
+      queryKey: this.queryKey,
+      meta: this.meta
+    }, a = (p) => {
+      Object.defineProperty(p, "signal", {
+        enumerable: !0,
+        get: () => (o(this, ye, !0), r.signal)
+      });
+    };
+    a(n);
+    const c = () => this.options.queryFn ? (o(this, ye, !1), this.options.persister ? this.options.persister(
+      this.options.queryFn,
+      n,
+      this
+    ) : this.options.queryFn(
+      n
+    )) : Promise.reject(
+      new Error(`Missing queryFn: '${this.options.queryHash}'`)
+    ), d = {
+      fetchOptions: s,
+      options: this.options,
+      queryKey: this.queryKey,
+      state: this.state,
+      fetchFn: c
+    };
+    a(d), (l = this.options.behavior) == null || l.onFetch(
+      d,
+      this
+    ), o(this, je, this.state), (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((P = d.fetchOptions) == null ? void 0 : P.meta)) && y(this, z, ee).call(this, { type: "fetch", meta: (U = d.fetchOptions) == null ? void 0 : U.meta });
+    const g = (p) => {
+      var v, S, f, m;
+      yt(p) && p.silent || y(this, z, ee).call(this, {
+        type: "error",
+        error: p
+      }), yt(p) || ((S = (v = i(this, K).config).onError) == null || S.call(
+        v,
+        p,
+        this
+      ), (m = (f = i(this, K).config).onSettled) == null || m.call(
+        f,
+        this.state.data,
+        p,
+        this
+      )), this.isFetchingOptimistic || this.scheduleGc(), this.isFetchingOptimistic = !1;
+    };
+    return o(this, B, is({
+      fn: d.fetchFn,
+      abort: r.abort.bind(r),
+      onSuccess: (p) => {
+        var v, S, f, m;
+        if (typeof p > "u") {
+          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}`
+          ), g(new Error(`${this.queryHash} data is undefined`));
+          return;
+        }
+        this.setData(p), (S = (v = i(this, K).config).onSuccess) == null || S.call(v, p, this), (m = (f = i(this, K).config).onSettled) == null || m.call(
+          f,
+          p,
+          this.state.error,
+          this
+        ), this.isFetchingOptimistic || this.scheduleGc(), this.isFetchingOptimistic = !1;
+      },
+      onError: g,
+      onFail: (p, v) => {
+        y(this, z, ee).call(this, { type: "failed", failureCount: p, error: v });
+      },
+      onPause: () => {
+        y(this, z, ee).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        y(this, z, ee).call(this, { type: "continue" });
+      },
+      retry: d.options.retry,
+      retryDelay: d.options.retryDelay,
+      networkMode: d.options.networkMode
+    })), o(this, ae, i(this, B).promise), i(this, ae);
+  }
+}, Se = new WeakMap(), je = new WeakMap(), K = new WeakMap(), ae = new WeakMap(), B = new WeakMap(), A = new WeakMap(), _e = new WeakMap(), ye = new WeakMap(), Ee = new WeakSet(), it = function(e) {
+  this.options = { ...i(this, _e), ...e }, this.updateGcTime(this.options.gcTime);
+}, z = new WeakSet(), ee = function(e) {
+  const s = (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,
+          fetchFailureCount: 0,
+          fetchFailureReason: null,
+          fetchMeta: e.meta ?? null,
+          fetchStatus: ht(this.options.networkMode) ? "fetching" : "paused",
+          ...!r.dataUpdatedAt && {
+            error: null,
+            status: "pending"
+          }
+        };
+      case "success":
+        return {
+          ...r,
+          data: e.data,
+          dataUpdateCount: r.dataUpdateCount + 1,
+          dataUpdatedAt: e.dataUpdatedAt ?? Date.now(),
+          error: null,
+          isInvalidated: !1,
+          status: "success",
+          ...!e.manual && {
+            fetchStatus: "idle",
+            fetchFailureCount: 0,
+            fetchFailureReason: null
+          }
+        };
+      case "error":
+        const n = e.error;
+        return yt(n) && n.revert && i(this, je) ? { ...i(this, je), fetchStatus: "idle" } : {
+          ...r,
+          error: n,
+          errorUpdateCount: r.errorUpdateCount + 1,
+          errorUpdatedAt: Date.now(),
+          fetchFailureCount: r.fetchFailureCount + 1,
+          fetchFailureReason: n,
+          fetchStatus: "idle",
+          status: "error"
+        };
+      case "invalidate":
+        return {
+          ...r,
+          isInvalidated: !0
+        };
+      case "setState":
+        return {
+          ...r,
+          ...e.state
+        };
+    }
+  };
+  this.state = s(this.state), R.batch(() => {
+    i(this, A).forEach((r) => {
+      r.onQueryUpdate();
+    }), i(this, K).notify({ query: this, type: "updated", action: e });
+  });
+}, Ht);
+function Zs(t) {
+  const e = typeof t.initialData == "function" ? t.initialData() : t.initialData, s = typeof e < "u", r = s ? typeof t.initialDataUpdatedAt == "function" ? t.initialDataUpdatedAt() : t.initialDataUpdatedAt : 0;
+  return {
+    data: e,
+    dataUpdateCount: 0,
+    dataUpdatedAt: s ? r ?? Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: !1,
+    status: s ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+var J, Gt, er = (Gt = class extends Ie {
+  constructor(e = {}) {
+    super();
+    h(this, J, void 0);
+    this.config = e, o(this, J, /* @__PURE__ */ new Map());
+  }
+  build(e, s, r) {
+    const n = s.queryKey, a = s.queryHash ?? Rt(n, s);
+    let c = this.get(a);
+    return c || (c = new Xs({
+      cache: this,
+      queryKey: n,
+      queryHash: a,
+      options: e.defaultQueryOptions(s),
+      state: r,
+      defaultOptions: e.getQueryDefaults(n)
+    }), this.add(c)), c;
+  }
+  add(e) {
+    i(this, J).has(e.queryHash) || (i(this, J).set(e.queryHash, e), this.notify({
+      type: "added",
+      query: e
+    }));
+  }
+  remove(e) {
+    const s = i(this, J).get(e.queryHash);
+    s && (e.destroy(), s === e && i(this, J).delete(e.queryHash), this.notify({ type: "removed", query: e }));
+  }
+  clear() {
+    R.batch(() => {
+      this.getAll().forEach((e) => {
+        this.remove(e);
+      });
+    });
+  }
+  get(e) {
+    return i(this, J).get(e);
+  }
+  getAll() {
+    return [...i(this, J).values()];
+  }
+  find(e) {
+    const s = { exact: !0, ...e };
+    return this.getAll().find(
+      (r) => Ut(s, r)
+    );
+  }
+  findAll(e = {}) {
+    const s = this.getAll();
+    return Object.keys(e).length > 0 ? s.filter((r) => Ut(e, r)) : s;
+  }
+  notify(e) {
+    R.batch(() => {
+      this.listeners.forEach((s) => {
+        s(e);
+      });
+    });
+  }
+  onFocus() {
+    R.batch(() => {
+      this.getAll().forEach((e) => {
+        e.onFocus();
+      });
+    });
+  }
+  onOnline() {
+    R.batch(() => {
+      this.getAll().forEach((e) => {
+        e.onOnline();
+      });
+    });
+  }
+}, J = new WeakMap(), Gt), W, $e, I, Fe, Y, re, zt, tr = (zt = class extends ns {
+  constructor(e) {
+    super();
+    h(this, Y);
+    h(this, W, void 0);
+    h(this, $e, void 0);
+    h(this, I, void 0);
+    h(this, Fe, void 0);
+    this.mutationId = e.mutationId, o(this, $e, e.defaultOptions), o(this, I, e.mutationCache), o(this, W, []), this.state = e.state || as(), this.setOptions(e.options), this.scheduleGc();
+  }
+  setOptions(e) {
+    this.options = { ...i(this, $e), ...e }, this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(e) {
+    i(this, W).includes(e) || (i(this, W).push(e), this.clearGcTimeout(), i(this, I).notify({
+      type: "observerAdded",
+      mutation: this,
+      observer: e
+    }));
+  }
+  removeObserver(e) {
+    o(this, W, i(this, W).filter((s) => s !== e)), this.scheduleGc(), i(this, I).notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer: e
+    });
+  }
+  optionalRemove() {
+    i(this, W).length || (this.state.status === "pending" ? this.scheduleGc() : i(this, I).remove(this));
+  }
+  continue() {
+    var e;
+    return ((e = i(this, Fe)) == 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 n, a, c, d, g, b, l, P, U, p, v, S, f, m, E, x, w, q, Q, j;
+    const s = () => (o(this, Fe, is({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(e) : Promise.reject(new Error("No mutationFn found")),
+      onFail: (O, Z) => {
+        y(this, Y, re).call(this, { type: "failed", failureCount: O, error: Z });
+      },
+      onPause: () => {
+        y(this, Y, re).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        y(this, Y, re).call(this, { type: "continue" });
+      },
+      retry: this.options.retry ?? 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode
+    })), i(this, Fe).promise), r = this.state.status === "pending";
+    try {
+      if (!r) {
+        y(this, Y, re).call(this, { type: "pending", variables: e }), await ((a = (n = i(this, I).config).onMutate) == null ? void 0 : a.call(
+          n,
+          e,
+          this
+        ));
+        const Z = await ((d = (c = this.options).onMutate) == null ? void 0 : d.call(c, e));
+        Z !== this.state.context && y(this, Y, re).call(this, {
+          type: "pending",
+          context: Z,
+          variables: e
+        });
+      }
+      const O = await s();
+      return await ((b = (g = i(this, I).config).onSuccess) == null ? void 0 : b.call(
+        g,
+        O,
+        e,
+        this.state.context,
+        this
+      )), await ((P = (l = this.options).onSuccess) == null ? void 0 : P.call(l, O, e, this.state.context)), await ((p = (U = i(this, I).config).onSettled) == null ? void 0 : p.call(
+        U,
+        O,
+        null,
+        this.state.variables,
+        this.state.context,
+        this
+      )), await ((S = (v = this.options).onSettled) == null ? void 0 : S.call(v, O, null, e, this.state.context)), y(this, Y, re).call(this, { type: "success", data: O }), O;
+    } catch (O) {
+      try {
+        throw await ((m = (f = i(this, I).config).onError) == null ? void 0 : m.call(
+          f,
+          O,
+          e,
+          this.state.context,
+          this
+        )), await ((x = (E = this.options).onError) == null ? void 0 : x.call(
+          E,
+          O,
+          e,
+          this.state.context
+        )), await ((q = (w = i(this, I).config).onSettled) == null ? void 0 : q.call(
+          w,
+          void 0,
+          O,
+          this.state.variables,
+          this.state.context,
+          this
+        )), await ((j = (Q = this.options).onSettled) == null ? void 0 : j.call(
+          Q,
+          void 0,
+          O,
+          e,
+          this.state.context
+        )), O;
+      } finally {
+        y(this, Y, re).call(this, { type: "error", error: O });
+      }
+    }
+  }
+}, W = new WeakMap(), $e = new WeakMap(), I = new WeakMap(), Fe = new WeakMap(), Y = new WeakSet(), re = function(e) {
+  const s = (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: !ht(this.options.networkMode),
+          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 = s(this.state), R.batch(() => {
+    i(this, W).forEach((r) => {
+      r.onMutationUpdate(e);
+    }), i(this, I).notify({
+      mutation: this,
+      type: "updated",
+      action: e
+    });
+  });
+}, zt);
+function as() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var _, He, pe, Vt, sr = (Vt = class extends Ie {
+  constructor(e = {}) {
+    super();
+    h(this, _, void 0);
+    h(this, He, void 0);
+    h(this, pe, void 0);
+    this.config = e, o(this, _, []), o(this, He, 0);
+  }
+  build(e, s, r) {
+    const n = new tr({
+      mutationCache: this,
+      mutationId: ++rt(this, He)._,
+      options: e.defaultMutationOptions(s),
+      state: r
+    });
+    return this.add(n), n;
+  }
+  add(e) {
+    i(this, _).push(e), this.notify({ type: "added", mutation: e });
+  }
+  remove(e) {
+    o(this, _, i(this, _).filter((s) => s !== e)), this.notify({ type: "removed", mutation: e });
+  }
+  clear() {
+    R.batch(() => {
+      i(this, _).forEach((e) => {
+        this.remove(e);
+      });
+    });
+  }
+  getAll() {
+    return i(this, _);
+  }
+  find(e) {
+    const s = { exact: !0, ...e };
+    return i(this, _).find(
+      (r) => kt(s, r)
+    );
+  }
+  findAll(e = {}) {
+    return i(this, _).filter(
+      (s) => kt(e, s)
+    );
+  }
+  notify(e) {
+    R.batch(() => {
+      this.listeners.forEach((s) => {
+        s(e);
+      });
+    });
+  }
+  resumePausedMutations() {
+    return o(this, pe, (i(this, pe) ?? Promise.resolve()).then(() => {
+      const e = i(this, _).filter((s) => s.state.isPaused);
+      return R.batch(
+        () => e.reduce(
+          (s, r) => s.then(() => r.continue().catch(H)),
+          Promise.resolve()
+        )
+      );
+    }).then(() => {
+      o(this, pe, void 0);
+    })), i(this, pe);
+  }
+}, _ = new WeakMap(), He = new WeakMap(), pe = new WeakMap(), Vt);
+function rr(t) {
+  return {
+    onFetch: (e, s) => {
+      const r = async () => {
+        var v, S, f, m, E;
+        const n = e.options, a = (f = (S = (v = e.fetchOptions) == null ? void 0 : v.meta) == null ? void 0 : S.fetchMore) == null ? void 0 : f.direction, c = ((m = e.state.data) == null ? void 0 : m.pages) || [], d = ((E = e.state.data) == null ? void 0 : E.pageParams) || [], g = { pages: [], pageParams: [] };
+        let b = !1;
+        const l = (x) => {
+          Object.defineProperty(x, "signal", {
+            enumerable: !0,
+            get: () => (e.signal.aborted ? b = !0 : e.signal.addEventListener("abort", () => {
+              b = !0;
+            }), e.signal)
+          });
+        }, P = e.options.queryFn || (() => Promise.reject(
+          new Error(`Missing queryFn: '${e.options.queryHash}'`)
+        )), U = async (x, w, q) => {
+          if (b)
+            return Promise.reject();
+          if (w == null && x.pages.length)
+            return Promise.resolve(x);
+          const Q = {
+            queryKey: e.queryKey,
+            pageParam: w,
+            direction: q ? "backward" : "forward",
+            meta: e.options.meta
+          };
+          l(Q);
+          const j = await P(
+            Q
+          ), { maxPages: O } = e.options, Z = q ? zs : Gs;
+          return {
+            pages: Z(x.pages, j, O),
+            pageParams: Z(x.pageParams, w, O)
+          };
+        };
+        let p;
+        if (a && c.length) {
+          const x = a === "backward", w = x ? ir : Tt, q = {
+            pages: c,
+            pageParams: d
+          }, Q = w(n, q);
+          p = await U(q, Q, x);
+        } else {
+          p = await U(
+            g,
+            d[0] ?? n.initialPageParam
+          );
+          const x = t ?? c.length;
+          for (let w = 1; w < x; w++) {
+            const q = Tt(n, p);
+            p = await U(p, q);
+          }
+        }
+        return p;
+      };
+      e.options.persister ? e.fetchFn = () => {
+        var n, a;
+        return (a = (n = e.options).persister) == null ? void 0 : a.call(
+          n,
+          r,
+          {
+            queryKey: e.queryKey,
+            meta: e.options.meta,
+            signal: e.signal
+          },
+          s
+        );
+      } : e.fetchFn = r;
+    }
+  };
+}
+function Tt(t, { pages: e, pageParams: s }) {
+  const r = e.length - 1;
+  return t.getNextPageParam(
+    e[r],
+    e,
+    s[r],
+    s
+  );
+}
+function ir(t, { pages: e, pageParams: s }) {
+  var r;
+  return (r = t.getPreviousPageParam) == null ? void 0 : r.call(
+    t,
+    e[0],
+    e,
+    s[0],
+    s
+  );
+}
+var F, oe, ue, Re, Ae, ce, Me, qe, Jt, nr = (Jt = class {
+  constructor(t = {}) {
+    h(this, F, void 0);
+    h(this, oe, void 0);
+    h(this, ue, void 0);
+    h(this, Re, void 0);
+    h(this, Ae, void 0);
+    h(this, ce, void 0);
+    h(this, Me, void 0);
+    h(this, qe, void 0);
+    o(this, F, t.queryCache || new er()), o(this, oe, t.mutationCache || new sr()), o(this, ue, t.defaultOptions || {}), o(this, Re, /* @__PURE__ */ new Map()), o(this, Ae, /* @__PURE__ */ new Map()), o(this, ce, 0);
+  }
+  mount() {
+    rt(this, ce)._++, i(this, ce) === 1 && (o(this, Me, ot.subscribe(() => {
+      ot.isFocused() && (this.resumePausedMutations(), i(this, F).onFocus());
+    })), o(this, qe, ut.subscribe(() => {
+      ut.isOnline() && (this.resumePausedMutations(), i(this, F).onOnline());
+    })));
+  }
+  unmount() {
+    var t, e;
+    rt(this, ce)._--, i(this, ce) === 0 && ((t = i(this, Me)) == null || t.call(this), o(this, Me, void 0), (e = i(this, qe)) == null || e.call(this), o(this, qe, void 0));
+  }
+  isFetching(t) {
+    return i(this, F).findAll({ ...t, fetchStatus: "fetching" }).length;
+  }
+  isMutating(t) {
+    return i(this, oe).findAll({ ...t, status: "pending" }).length;
+  }
+  getQueryData(t) {
+    var e;
+    return (e = i(this, F).find({ queryKey: t })) == null ? void 0 : e.state.data;
+  }
+  ensureQueryData(t) {
+    const e = this.getQueryData(t.queryKey);
+    return e !== void 0 ? Promise.resolve(e) : this.fetchQuery(t);
+  }
+  getQueriesData(t) {
+    return this.getQueryCache().findAll(t).map(({ queryKey: e, state: s }) => {
+      const r = s.data;
+      return [e, r];
+    });
+  }
+  setQueryData(t, e, s) {
+    const r = i(this, F).find({ queryKey: t }), n = r == null ? void 0 : r.state.data, a = Hs(e, n);
+    if (typeof a > "u")
+      return;
+    const c = this.defaultQueryOptions({ queryKey: t });
+    return i(this, F).build(this, c).setData(a, { ...s, manual: !0 });
+  }
+  setQueriesData(t, e, s) {
+    return R.batch(
+      () => this.getQueryCache().findAll(t).map(({ queryKey: r }) => [
+        r,
+        this.setQueryData(r, e, s)
+      ])
+    );
+  }
+  getQueryState(t) {
+    var e;
+    return (e = i(this, F).find({ queryKey: t })) == null ? void 0 : e.state;
+  }
+  removeQueries(t) {
+    const e = i(this, F);
+    R.batch(() => {
+      e.findAll(t).forEach((s) => {
+        e.remove(s);
+      });
+    });
+  }
+  resetQueries(t, e) {
+    const s = i(this, F), r = {
+      type: "active",
+      ...t
+    };
+    return R.batch(() => (s.findAll(t).forEach((n) => {
+      n.reset();
+    }), this.refetchQueries(r, e)));
+  }
+  cancelQueries(t = {}, e = {}) {
+    const s = { revert: !0, ...e }, r = R.batch(
+      () => i(this, F).findAll(t).map((n) => n.cancel(s))
+    );
+    return Promise.all(r).then(H).catch(H);
+  }
+  invalidateQueries(t = {}, e = {}) {
+    return R.batch(() => {
+      if (i(this, F).findAll(t).forEach((r) => {
+        r.invalidate();
+      }), t.refetchType === "none")
+        return Promise.resolve();
+      const s = {
+        ...t,
+        type: t.refetchType ?? t.type ?? "active"
+      };
+      return this.refetchQueries(s, e);
+    });
+  }
+  refetchQueries(t = {}, e) {
+    const s = {
+      ...e,
+      cancelRefetch: (e == null ? void 0 : e.cancelRefetch) ?? !0
+    }, r = R.batch(
+      () => i(this, F).findAll(t).filter((n) => !n.isDisabled()).map((n) => {
+        let a = n.fetch(void 0, s);
+        return s.throwOnError || (a = a.catch(H)), n.state.fetchStatus === "paused" ? Promise.resolve() : a;
+      })
+    );
+    return Promise.all(r).then(H);
+  }
+  fetchQuery(t) {
+    const e = this.defaultQueryOptions(t);
+    typeof e.retry > "u" && (e.retry = !1);
+    const s = i(this, F).build(this, e);
+    return s.isStaleByTime(e.staleTime) ? s.fetch(e) : Promise.resolve(s.state.data);
+  }
+  prefetchQuery(t) {
+    return this.fetchQuery(t).then(H).catch(H);
+  }
+  fetchInfiniteQuery(t) {
+    return t.behavior = rr(t.pages), this.fetchQuery(t);
+  }
+  prefetchInfiniteQuery(t) {
+    return this.fetchInfiniteQuery(t).then(H).catch(H);
+  }
+  resumePausedMutations() {
+    return i(this, oe).resumePausedMutations();
+  }
+  getQueryCache() {
+    return i(this, F);
+  }
+  getMutationCache() {
+    return i(this, oe);
+  }
+  getDefaultOptions() {
+    return i(this, ue);
+  }
+  setDefaultOptions(t) {
+    o(this, ue, t);
+  }
+  setQueryDefaults(t, e) {
+    i(this, Re).set(Ke(t), {
+      queryKey: t,
+      defaultOptions: e
+    });
+  }
+  getQueryDefaults(t) {
+    const e = [...i(this, Re).values()];
+    let s = {};
+    return e.forEach((r) => {
+      Be(t, r.queryKey) && (s = { ...s, ...r.defaultOptions });
+    }), s;
+  }
+  setMutationDefaults(t, e) {
+    i(this, Ae).set(Ke(t), {
+      mutationKey: t,
+      defaultOptions: e
+    });
+  }
+  getMutationDefaults(t) {
+    const e = [...i(this, Ae).values()];
+    let s = {};
+    return e.forEach((r) => {
+      Be(t, r.mutationKey) && (s = { ...s, ...r.defaultOptions });
+    }), s;
+  }
+  defaultQueryOptions(t) {
+    if (t != null && t._defaulted)
+      return t;
+    const e = {
+      ...i(this, ue).queries,
+      ...(t == null ? void 0 : t.queryKey) && this.getQueryDefaults(t.queryKey),
+      ...t,
+      _defaulted: !0
+    };
+    return e.queryHash || (e.queryHash = Rt(
+      e.queryKey,
+      e
+    )), typeof e.refetchOnReconnect > "u" && (e.refetchOnReconnect = e.networkMode !== "always"), typeof e.throwOnError > "u" && (e.throwOnError = !!e.suspense), typeof e.networkMode > "u" && e.persister && (e.networkMode = "offlineFirst"), e;
+  }
+  defaultMutationOptions(t) {
+    return t != null && t._defaulted ? t : {
+      ...i(this, ue).mutations,
+      ...(t == null ? void 0 : t.mutationKey) && this.getMutationDefaults(t.mutationKey),
+      ...t,
+      _defaulted: !0
+    };
+  }
+  clear() {
+    i(this, F).clear(), i(this, oe).clear();
+  }
+}, F = new WeakMap(), oe = new WeakMap(), ue = new WeakMap(), Re = new WeakMap(), Ae = new WeakMap(), ce = new WeakMap(), Me = new WeakMap(), qe = new WeakMap(), Jt), T, C, Ue, k, me, ke, X, Ge, De, Qe, ge, be, he, ve, xe, Le, ze, bt, Ve, vt, Je, xt, We, wt, Ye, Ct, Xe, Pt, Ze, Ot, ct, os, Wt, ar = (Wt = class extends Ie {
+  constructor(e, s) {
+    super();
+    h(this, xe);
+    h(this, ze);
+    h(this, Ve);
+    h(this, Je);
+    h(this, We);
+    h(this, Ye);
+    h(this, Xe);
+    h(this, Ze);
+    h(this, ct);
+    h(this, T, void 0);
+    h(this, C, void 0);
+    h(this, Ue, void 0);
+    h(this, k, void 0);
+    h(this, me, void 0);
+    h(this, ke, void 0);
+    h(this, X, void 0);
+    h(this, Ge, void 0);
+    h(this, De, void 0);
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    h(this, Qe, void 0);
+    h(this, ge, void 0);
+    h(this, be, void 0);
+    h(this, he, void 0);
+    h(this, ve, void 0);
+    o(this, C, void 0), o(this, Ue, void 0), o(this, k, void 0), o(this, ve, /* @__PURE__ */ new Set()), o(this, T, e), this.options = s, o(this, X, null), this.bindMethods(), this.setOptions(s);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (i(this, C).addObserver(this), It(i(this, C), this.options) ? y(this, xe, Le).call(this) : this.updateResult(), y(this, We, wt).call(this));
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return St(
+      i(this, C),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return St(
+      i(this, C),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), y(this, Ye, Ct).call(this), y(this, Xe, Pt).call(this), i(this, C).removeObserver(this);
+  }
+  setOptions(e, s) {
+    const r = this.options, n = i(this, C);
+    if (this.options = i(this, T).defaultQueryOptions(e), at(r, this.options) || i(this, T).getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: i(this, C),
+      observer: this
+    }), typeof this.options.enabled < "u" && typeof this.options.enabled != "boolean")
+      throw new Error("Expected enabled to be a boolean");
+    this.options.queryKey || (this.options.queryKey = r.queryKey), y(this, Ze, Ot).call(this);
+    const a = this.hasListeners();
+    a && Lt(
+      i(this, C),
+      n,
+      this.options,
+      r
+    ) && y(this, xe, Le).call(this), this.updateResult(s), a && (i(this, C) !== n || this.options.enabled !== r.enabled || this.options.staleTime !== r.staleTime) && y(this, ze, bt).call(this);
+    const c = y(this, Ve, vt).call(this);
+    a && (i(this, C) !== n || this.options.enabled !== r.enabled || c !== i(this, he)) && y(this, Je, xt).call(this, c);
+  }
+  getOptimisticResult(e) {
+    const s = i(this, T).getQueryCache().build(i(this, T), e), r = this.createResult(s, e);
+    return ur(this, r) && (o(this, k, r), o(this, ke, this.options), o(this, me, i(this, C).state)), r;
+  }
+  getCurrentResult() {
+    return i(this, k);
+  }
+  trackResult(e) {
+    const s = {};
+    return Object.keys(e).forEach((r) => {
+      Object.defineProperty(s, r, {
+        configurable: !1,
+        enumerable: !0,
+        get: () => (i(this, ve).add(r), e[r])
+      });
+    }), s;
+  }
+  getCurrentQuery() {
+    return i(this, C);
+  }
+  refetch({ ...e } = {}) {
+    return this.fetch({
+      ...e
+    });
+  }
+  fetchOptimistic(e) {
+    const s = i(this, T).defaultQueryOptions(e), r = i(this, T).getQueryCache().build(i(this, T), s);
+    return r.isFetchingOptimistic = !0, r.fetch().then(() => this.createResult(r, s));
+  }
+  fetch(e) {
+    return y(this, xe, Le).call(this, {
+      ...e,
+      cancelRefetch: e.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), i(this, k)));
+  }
+  createResult(e, s) {
+    var Q;
+    const r = i(this, C), n = this.options, a = i(this, k), c = i(this, me), d = i(this, ke), b = e !== r ? e.state : i(this, Ue), { state: l } = e;
+    let { error: P, errorUpdatedAt: U, fetchStatus: p, status: v } = l, S = !1, f;
+    if (s._optimisticResults) {
+      const j = this.hasListeners(), O = !j && It(e, s), Z = j && Lt(e, r, s, n);
+      (O || Z) && (p = ht(e.options.networkMode) ? "fetching" : "paused", l.dataUpdatedAt || (v = "pending")), s._optimisticResults === "isRestoring" && (p = "idle");
+    }
+    if (s.select && typeof l.data < "u")
+      if (a && l.data === (c == null ? void 0 : c.data) && s.select === i(this, Ge))
+        f = i(this, De);
+      else
+        try {
+          o(this, Ge, s.select), f = s.select(l.data), f = gt(a == null ? void 0 : a.data, f, s), o(this, De, f), o(this, X, null);
+        } catch (j) {
+          o(this, X, j);
+        }
+    else
+      f = l.data;
+    if (typeof s.placeholderData < "u" && typeof f > "u" && v === "pending") {
+      let j;
+      if (a != null && a.isPlaceholderData && s.placeholderData === (d == null ? void 0 : d.placeholderData))
+        j = a.data;
+      else if (j = typeof s.placeholderData == "function" ? s.placeholderData(
+        (Q = i(this, Qe)) == null ? void 0 : Q.state.data,
+        i(this, Qe)
+      ) : s.placeholderData, s.select && typeof j < "u")
+        try {
+          j = s.select(j), o(this, X, null);
+        } catch (O) {
+          o(this, X, O);
+        }
+      typeof j < "u" && (v = "success", f = gt(
+        a == null ? void 0 : a.data,
+        j,
+        s
+      ), S = !0);
+    }
+    i(this, X) && (P = i(this, X), f = i(this, De), U = Date.now(), v = "error");
+    const m = p === "fetching", E = v === "pending", x = v === "error", w = E && m;
+    return {
+      status: v,
+      fetchStatus: p,
+      isPending: E,
+      isSuccess: v === "success",
+      isError: x,
+      isInitialLoading: w,
+      isLoading: w,
+      data: f,
+      dataUpdatedAt: l.dataUpdatedAt,
+      error: P,
+      errorUpdatedAt: U,
+      failureCount: l.fetchFailureCount,
+      failureReason: l.fetchFailureReason,
+      errorUpdateCount: l.errorUpdateCount,
+      isFetched: l.dataUpdateCount > 0 || l.errorUpdateCount > 0,
+      isFetchedAfterMount: l.dataUpdateCount > b.dataUpdateCount || l.errorUpdateCount > b.errorUpdateCount,
+      isFetching: m,
+      isRefetching: m && !E,
+      isLoadingError: x && l.dataUpdatedAt === 0,
+      isPaused: p === "paused",
+      isPlaceholderData: S,
+      isRefetchError: x && l.dataUpdatedAt !== 0,
+      isStale: At(e, s),
+      refetch: this.refetch
+    };
+  }
+  updateResult(e) {
+    const s = i(this, k), r = this.createResult(i(this, C), this.options);
+    if (o(this, me, i(this, C).state), o(this, ke, this.options), i(this, me).data !== void 0 && o(this, Qe, i(this, C)), at(r, s))
+      return;
+    o(this, k, r);
+    const n = {}, a = () => {
+      if (!s)
+        return !0;
+      const { notifyOnChangeProps: c } = this.options, d = typeof c == "function" ? c() : c;
+      if (d === "all" || !d && !i(this, ve).size)
+        return !0;
+      const g = new Set(
+        d ?? i(this, ve)
+      );
+      return this.options.throwOnError && g.add("error"), Object.keys(i(this, k)).some((b) => {
+        const l = b;
+        return i(this, k)[l] !== s[l] && g.has(l);
+      });
+    };
+    (e == null ? void 0 : e.listeners) !== !1 && a() && (n.listeners = !0), y(this, ct, os).call(this, { ...n, ...e });
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && y(this, We, wt).call(this);
+  }
+}, T = new WeakMap(), C = new WeakMap(), Ue = new WeakMap(), k = new WeakMap(), me = new WeakMap(), ke = new WeakMap(), X = new WeakMap(), Ge = new WeakMap(), De = new WeakMap(), Qe = new WeakMap(), ge = new WeakMap(), be = new WeakMap(), he = new WeakMap(), ve = new WeakMap(), xe = new WeakSet(), Le = function(e) {
+  y(this, Ze, Ot).call(this);
+  let s = i(this, C).fetch(
+    this.options,
+    e
+  );
+  return e != null && e.throwOnError || (s = s.catch(H)), s;
+}, ze = new WeakSet(), bt = function() {
+  if (y(this, Ye, Ct).call(this), Te || i(this, k).isStale || !pt(this.options.staleTime))
+    return;
+  const s = es(
+    i(this, k).dataUpdatedAt,
+    this.options.staleTime
+  ) + 1;
+  o(this, ge, setTimeout(() => {
+    i(this, k).isStale || this.updateResult();
+  }, s));
+}, Ve = new WeakSet(), vt = function() {
+  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(i(this, C)) : this.options.refetchInterval) ?? !1;
+}, Je = new WeakSet(), xt = function(e) {
+  y(this, Xe, Pt).call(this), o(this, he, e), !(Te || this.options.enabled === !1 || !pt(i(this, he)) || i(this, he) === 0) && o(this, be, setInterval(() => {
+    (this.options.refetchIntervalInBackground || ot.isFocused()) && y(this, xe, Le).call(this);
+  }, i(this, he)));
+}, We = new WeakSet(), wt = function() {
+  y(this, ze, bt).call(this), y(this, Je, xt).call(this, y(this, Ve, vt).call(this));
+}, Ye = new WeakSet(), Ct = function() {
+  i(this, ge) && (clearTimeout(i(this, ge)), o(this, ge, void 0));
+}, Xe = new WeakSet(), Pt = function() {
+  i(this, be) && (clearInterval(i(this, be)), o(this, be, void 0));
+}, Ze = new WeakSet(), Ot = function() {
+  const e = i(this, T).getQueryCache().build(i(this, T), this.options);
+  if (e === i(this, C))
+    return;
+  const s = i(this, C);
+  o(this, C, e), o(this, Ue, e.state), this.hasListeners() && (s == null || s.removeObserver(this), e.addObserver(this));
+}, ct = new WeakSet(), os = function(e) {
+  R.batch(() => {
+    e.listeners && this.listeners.forEach((s) => {
+      s(i(this, k));
+    }), i(this, T).getQueryCache().notify({
+      query: i(this, C),
+      type: "observerResultsUpdated"
+    });
+  });
+}, Wt);
+function or(t, e) {
+  return e.enabled !== !1 && !t.state.dataUpdatedAt && !(t.state.status === "error" && e.retryOnMount === !1);
+}
+function It(t, e) {
+  return or(t, e) || t.state.dataUpdatedAt > 0 && St(t, e, e.refetchOnMount);
+}
+function St(t, e, s) {
+  if (e.enabled !== !1) {
+    const r = typeof s == "function" ? s(t) : s;
+    return r === "always" || r !== !1 && At(t, e);
+  }
+  return !1;
+}
+function Lt(t, e, s, r) {
+  return s.enabled !== !1 && (t !== e || r.enabled === !1) && (!s.suspense || t.state.status !== "error") && At(t, s);
+}
+function At(t, e) {
+  return t.isStaleByTime(e.staleTime);
+}
+function ur(t, e) {
+  return !at(t.getCurrentResult(), e);
+}
+var le, N, $, te, Ne, nt, et, jt, Yt, cr = (Yt = class extends Ie {
+  constructor(e, s) {
+    super();
+    h(this, Ne);
+    h(this, et);
+    h(this, le, void 0);
+    h(this, N, void 0);
+    h(this, $, void 0);
+    h(this, te, void 0);
+    o(this, N, void 0), o(this, le, e), this.setOptions(s), this.bindMethods(), y(this, Ne, nt).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(e) {
+    var r;
+    const s = this.options;
+    this.options = i(this, le).defaultMutationOptions(e), at(s, this.options) || i(this, le).getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: i(this, $),
+      observer: this
+    }), (r = i(this, $)) == null || r.setOptions(this.options);
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || (e = i(this, $)) == null || e.removeObserver(this);
+  }
+  onMutationUpdate(e) {
+    y(this, Ne, nt).call(this), y(this, et, jt).call(this, e);
+  }
+  getCurrentResult() {
+    return i(this, N);
+  }
+  reset() {
+    o(this, $, void 0), y(this, Ne, nt).call(this), y(this, et, jt).call(this);
+  }
+  mutate(e, s) {
+    var r;
+    return o(this, te, s), (r = i(this, $)) == null || r.removeObserver(this), o(this, $, i(this, le).getMutationCache().build(i(this, le), this.options)), i(this, $).addObserver(this), i(this, $).execute(e);
+  }
+}, le = new WeakMap(), N = new WeakMap(), $ = new WeakMap(), te = new WeakMap(), Ne = new WeakSet(), nt = function() {
+  var s;
+  const e = ((s = i(this, $)) == null ? void 0 : s.state) ?? as();
+  o(this, N, {
+    ...e,
+    isPending: e.status === "pending",
+    isSuccess: e.status === "success",
+    isError: e.status === "error",
+    isIdle: e.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, et = new WeakSet(), jt = function(e) {
+  R.batch(() => {
+    var s, r, n, a, c, d, g, b;
+    i(this, te) && this.hasListeners() && ((e == null ? void 0 : e.type) === "success" ? ((r = (s = i(this, te)).onSuccess) == null || r.call(
+      s,
+      e.data,
+      i(this, N).variables,
+      i(this, N).context
+    ), (a = (n = i(this, te)).onSettled) == null || a.call(
+      n,
+      e.data,
+      null,
+      i(this, N).variables,
+      i(this, N).context
+    )) : (e == null ? void 0 : e.type) === "error" && ((d = (c = i(this, te)).onError) == null || d.call(
+      c,
+      e.error,
+      i(this, N).variables,
+      i(this, N).context
+    ), (b = (g = i(this, te)).onSettled) == null || b.call(
+      g,
+      void 0,
+      e.error,
+      i(this, N).variables,
+      i(this, N).context
+    ))), this.listeners.forEach((l) => {
+      l(i(this, N));
+    });
+  });
+}, Yt), us = M.createContext(
+  void 0
+), G = (t) => {
+  const e = M.useContext(us);
+  if (t)
+    return t;
+  if (!e)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return e;
+}, hr = ({
+  client: t,
+  children: e
+}) => (M.useEffect(() => (t.mount(), () => {
+  t.unmount();
+}), [t]), /* @__PURE__ */ M.createElement(us.Provider, { value: t }, e)), cs = M.createContext(!1), lr = () => M.useContext(cs);
+cs.Provider;
+function dr() {
+  let t = !1;
+  return {
+    clearReset: () => {
+      t = !1;
+    },
+    reset: () => {
+      t = !0;
+    },
+    isReset: () => t
+  };
+}
+var fr = M.createContext(dr()), yr = () => M.useContext(fr);
+function hs(t, e) {
+  return typeof t == "function" ? t(...e) : !!t;
+}
+var pr = (t, e) => {
+  (t.suspense || t.throwOnError) && (e.isReset() || (t.retryOnMount = !1));
+}, mr = (t) => {
+  M.useEffect(() => {
+    t.clearReset();
+  }, [t]);
+}, gr = ({
+  result: t,
+  errorResetBoundary: e,
+  throwOnError: s,
+  query: r
+}) => t.isError && !e.isReset() && !t.isFetching && hs(s, [t.error, r]), br = (t) => {
+  t.suspense && typeof t.staleTime != "number" && (t.staleTime = 1e3);
+}, vr = (t, e) => (t == null ? void 0 : t.suspense) && e.isPending, xr = (t, e, s) => e.fetchOptimistic(t).catch(() => {
+  s.clearReset();
+});
+function wr(t, e, s) {
+  if (process.env.NODE_ENV !== "production" && (typeof t != "object" || Array.isArray(t)))
+    throw new Error(
+      'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+    );
+  const r = G(s), n = lr(), a = yr(), c = r.defaultQueryOptions(t);
+  c._optimisticResults = n ? "isRestoring" : "optimistic", br(c), pr(c, a), mr(a);
+  const [d] = M.useState(
+    () => new e(
+      r,
+      c
+    )
+  ), g = d.getOptimisticResult(c);
+  if (M.useSyncExternalStore(
+    M.useCallback(
+      (b) => {
+        const l = n ? () => {
+        } : d.subscribe(R.batchCalls(b));
+        return d.updateResult(), l;
+      },
+      [d, n]
+    ),
+    () => d.getCurrentResult(),
+    () => d.getCurrentResult()
+  ), M.useEffect(() => {
+    d.setOptions(c, { listeners: !1 });
+  }, [c, d]), vr(c, g))
+    throw xr(c, d, a);
+  if (gr({
+    result: g,
+    errorResetBoundary: a,
+    throwOnError: c.throwOnError,
+    query: d.getCurrentQuery()
+  }))
+    throw g.error;
+  return c.notifyOnChangeProps ? g : d.trackResult(g);
+}
+function tt(t, e) {
+  return wr(t, ar, e);
+}
+function V(t, e) {
+  const s = G(e), [r] = M.useState(
+    () => new cr(
+      s,
+      t
+    )
+  );
+  M.useEffect(() => {
+    r.setOptions(t);
+  }, [r, t]);
+  const n = M.useSyncExternalStore(
+    M.useCallback(
+      (c) => r.subscribe(R.batchCalls(c)),
+      [r]
+    ),
+    () => r.getCurrentResult(),
+    () => r.getCurrentResult()
+  ), a = M.useCallback(
+    (c, d) => {
+      r.mutate(c, d).catch(Cr);
+    },
+    [r]
+  );
+  if (n.error && hs(r.options.throwOnError, [n.error]))
+    throw n.error;
+  return { ...n, mutate: a, mutateAsync: n.mutate };
+}
+function Cr() {
+}
+function D() {
+  return G().getQueryData(["apiBaseUrl"]) || "/api/chaibuilder";
+}
+const we = () => {
+  const { data: t, refetch: e } = tt({
+    queryKey: ["currentPage"],
+    queryFn: () => localStorage.getItem("currentPage") || ""
+  });
+  return [
+    t,
+    (s) => {
+      s && (localStorage.setItem("currentPage", s || ""), e());
+    }
+  ];
+};
+let Kt = "";
+const st = () => (Kt = localStorage.getItem("__chai_at"), Kt);
+function Pr(t) {
+  const e = {
+    method: "GET",
+    headers: { "x-chai-access-token": st() }
+  };
+  return fetch(t, e);
+}
+function Or(t, e) {
+  const s = {
+    method: "POST",
+    headers: { "x-chai-access-token": st() },
+    body: JSON.stringify(e)
+  };
+  return fetch(t, s);
+}
+function Sr(t, e) {
+  const s = {
+    method: "PUT",
+    headers: { "x-chai-access-token": st() },
+    body: JSON.stringify(e)
+  };
+  return fetch(t, s);
+}
+function jr(t, e) {
+  const s = {
+    method: "DELETE",
+    headers: { "x-chai-access-token": st() },
+    body: JSON.stringify(e)
+  };
+  return fetch(t, s);
+}
+const L = {
+  get: Pr,
+  post: Or,
+  put: Sr,
+  delete: jr
+}, ls = () => {
+  const [t, e] = we(), s = D();
+  return tt({
+    queryKey: ["project"],
+    queryFn: async () => {
+      const { data: r } = await L.get(`${s}/project`).then((n) => n.json());
+      if (!t && r) {
+        const n = localStorage.getItem("currentPage");
+        e(n || (r == null ? void 0 : r.homepage));
+      }
+      return r;
+    }
+  });
+}, ds = () => {
+  const t = D();
+  return tt({
+    queryKey: ["pages"],
+    queryFn: async () => {
+      const { data: e } = await L.get(`${t}/pages`).then((s) => s.json());
+      return e || [];
+    }
+  });
+}, fs = () => {
+  const [t] = we(), e = D();
+  return tt({
+    queryKey: ["page_data", t],
+    queryFn: async () => {
+      const { data: s } = await L.get(`${e}/page?uuid=${t}`).then((r) => r.json());
+      return s;
+    },
+    enabled: !!t,
+    staleTime: 3e3
+  });
+}, Et = () => /* @__PURE__ */ u.jsx("div", { className: "h-screen w-screen bg-gray-200", children: /* @__PURE__ */ u.jsxs("div", { className: "flex flex-col h-full w-full justify-center items-center", children: [
+  /* @__PURE__ */ u.jsxs("div", { className: "flex flex-row gap-2", children: [
+    /* @__PURE__ */ u.jsx("div", { className: "w-4 h-4 rounded-full bg-orange-600 animate-bounce [animation-delay:.6s]" }),
+    /* @__PURE__ */ u.jsx("div", { className: "w-4 h-4 rounded-full bg-blue-600 animate-bounce [animation-delay:.4s]" }),
+    /* @__PURE__ */ u.jsx("div", { className: "w-4 h-4 rounded-full bg-green-600 animate-bounce [animation-delay:.2s]" }),
+    /* @__PURE__ */ u.jsx("div", { className: "w-4 h-4 rounded-full bg-yellow-600 animate-bounce [animation-delay:.0s]" })
+  ] }),
+  /* @__PURE__ */ u.jsx("div", { className: "text-gray-700 font-thin", children: "Loading Builder..." })
+] }) }), Er = (t = "Project updated successfully.") => {
+  const e = G(), s = D();
+  return V({
+    mutationFn: async (r) => await L.put(`${s}/project`, r).then((n) => n.json()),
+    onSuccess: () => {
+      e.invalidateQueries({ queryKey: ["project"] }), se.success(t);
+    }
+  });
+}, Fr = () => {
+  const [t] = ["SAVED"], [e, s] = we(), r = bs(), { t: n } = xs();
+  return (a) => t !== "SAVED" ? (se.error(n("You have unsaved changes. Please save before changing the page.")), !1) : e === a.uuid ? !1 : (r(), setTimeout(() => s(a.uuid), 100), !0);
+}, li = () => {
+  const t = G(), e = Fr(), s = D();
+  return V({
+    mutationFn: async (r) => L.post(`${s}/pages`, r).then((n) => n.json()),
+    onSuccess: (r) => {
+      t.invalidateQueries({ queryKey: ["pages"] }), e({ uuid: r.uuid, slug: r.slug }), se.success("Page added successfully.");
+    }
+  });
+}, Rr = () => {
+  const t = D(), [e] = we(), s = G();
+  return V({
+    mutationFn: async (r) => L.put(`${t}/page`, r).then((n) => n.json()),
+    onSuccess: async (r) => {
+      var n;
+      if (r.result === "error" && ((n = r.error) == null ? void 0 : n.code) == "PAGE_LOCKED") {
+        s.invalidateQueries({ queryKey: ["page_data", e] });
+        return;
+      }
+      se.success("Page saved successfully.");
+    }
+  });
+}, Ar = () => {
+  const t = D(), { data: e } = ds(), [s] = we(), { data: r } = ls(), n = G();
+  return V({
+    mutationFn: async () => {
+      const a = e.find((c) => c.uuid === s).slug;
+      return await L.post(`${t}/publish`, {
+        slug: a,
+        uuid: s,
+        isHomepage: (r == null ? void 0 : r.homepage) === s
+      }).then((c) => c.json());
+    },
+    onSuccess: async (a) => {
+      var c;
+      if (a.result === "error" && ((c = a.error) == null ? void 0 : c.code) == "PAGE_LOCKED") {
+        n.invalidateQueries({ queryKey: ["page_data", s] });
+        return;
+      }
+      se.success("Page published successfully.", {
+        position: "bottom-right",
+        duration: 2e3
+      });
+    }
+  });
+}, di = () => {
+  const t = G(), e = D();
+  return V({
+    mutationFn: async (s) => L.delete(`${e}/page`, s).then((r) => r.json()),
+    onSuccess: () => {
+      se.success("Page deleted successfully."), t.invalidateQueries({ queryKey: ["pages"] });
+    }
+  });
+}, Mr = () => {
+  const t = G(), e = D();
+  return V({
+    mutationFn: async (s) => L.post(`${e}/take-control`, { uuid: s }).then((r) => r.json()),
+    onSuccess: (s, r) => {
+      t.invalidateQueries({ queryKey: ["page_data", r] });
+    }
+  });
+}, qr = () => {
+  const t = D();
+  return V({
+    mutationFn: async () => {
+      const { data: e } = await L.get(`${t}/library`).then((s) => s.json());
+      return Es(
+        Fs(e, (s) => !Rs(s, "hidden")),
+        "group"
+      );
+    }
+  });
+}, Ur = () => {
+  const t = D();
+  return V({
+    mutationFn: async (e) => {
+      if (!e || !e.uuid)
+        return [];
+      try {
+        const { data: s } = await L.get(`${t}/block?uuid=${e.uuid}&format=${e.format}`).then(async (r) => e.format === "html" ? Us(await r.text()) : await r.json());
+        return As(s, "0._name", Ms(e.group)), s || [];
+      } catch {
+        return [];
+      }
+    }
+  });
+}, kr = () => {
+  const t = D();
+  return V({
+    mutationFn: async (e) => {
+      const s = new FormData();
+      s.append("file", e);
+      const { data: r } = await fetch(`${t}/upload`, {
+        method: "POST",
+        headers: { "x-chai-access-token": st() },
+        body: s
+      }).then((n) => n.json());
+      return r;
+    }
+  });
+};
+function ys(t) {
+  return Zt({ tag: "svg", attr: { viewBox: "0 0 24 24" }, child: [{ tag: "path", attr: { fill: "none", d: "M0 0h24v24H0z" } }, { tag: "path", attr: { d: "M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z" } }] })(t);
+}
+function Dr(t) {
+  return Zt({ tag: "svg", attr: { viewBox: "0 0 24 24" }, child: [{ tag: "path", attr: { fill: "none", d: "M0 0h24v24H0z" } }, { tag: "path", attr: { d: "M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z" } }] })(t);
+}
+const Qr = () => {
+  const { mutate: t, isPending: e } = Mr(), [s] = we(), { data: r } = fs(), n = Mt(r, "lockedBy.name", ""), a = Mt(r, "lockedBy.email", "");
+  return /* @__PURE__ */ u.jsxs("div", { className: "bg-white dark:bg-gray-800 rounded-lg drop-shadow-2xl mx-auto p-10 space-y-4 text-center max-w-xl", children: [
+    /* @__PURE__ */ u.jsxs("h2", { className: "text-2xl font-bold", children: [
+      "Page is ",
+      /* @__PURE__ */ u.jsx("span", { className: "text-red-500", children: "locked" })
+    ] }),
+    /* @__PURE__ */ u.jsxs("div", { className: "text-gray-500 dark:text-gray-400 font-light", children: [
+      "This page is currently being edited by ",
+      /* @__PURE__ */ u.jsx("br", {}),
+      /* @__PURE__ */ u.jsxs("div", { className: "flex items-center gap-x-3 w-max mx-auto font-medium text-gray-700 mt-2 text-sm", children: [
+        /* @__PURE__ */ u.jsxs("div", { className: "flex items-center gap-x-2 bg-gray-100 py-1 px-2 rounded-md", children: [
+          /* @__PURE__ */ u.jsx(Dr, { className: "w-4 h-4 text-gray-500" }),
+          " ",
+          n
+        ] }),
+        /* @__PURE__ */ u.jsxs("div", { className: "flex items-center gap-x-2 bg-gray-100 py-1 px-2 rounded-md lowercase", children: [
+          /* @__PURE__ */ u.jsx(ys, { className: "w-4 h-4 text-gray-500" }),
+          " ",
+          a
+        ] })
+      ] }),
+      /* @__PURE__ */ u.jsxs("div", { className: "pt-4", children: [
+        "If you take control, ",
+        n,
+        " will be ",
+        /* @__PURE__ */ u.jsx("span", { className: "text-red-500", children: "restricted" }),
+        " from making additional edits."
+      ] })
+    ] }),
+    /* @__PURE__ */ u.jsx(
+      Xt,
+      {
+        disabled: e,
+        onClick: () => t(s),
+        className: `w-36 ${e ? "bg-transparent shadow-none hover:bg-transparent" : ""}`,
+        children: e ? /* @__PURE__ */ u.jsx(ks, { className: "text-sm animate-spin text-gray-500" }) : "Take Over"
+      }
+    )
+  ] });
+}, Nr = () => {
+  const t = D(), e = G();
+  return V({
+    mutationFn: async (s) => {
+      const r = await fetch(`${t}/login`, { method: "POST", body: JSON.stringify(s) });
+      if (r.ok)
+        return await r.json();
+      throw r.status === 401 ? new Error("Invalid login credentials") : new Error("Invalid");
+    },
+    onSuccess: (s) => {
+      const { data: r } = s;
+      if (!r.accessToken) {
+        se.error("Something went wrong. Please try again.", { position: "top-center" });
+        return;
+      }
+      localStorage.setItem("__chai_at", r.accessToken), localStorage.setItem("__chai_ur", JSON.stringify(qs(r, ["accessToken"]))), e.invalidateQueries({ queryKey: ["verify"] }), se.success("Logged in successfully.");
+    },
+    onError: () => {
+      se.error("Invalid login credentials. Please try again.", { position: "top-center" });
+    }
+  });
+}, Tr = () => {
+  const t = D();
+  return tt({
+    queryKey: ["verify"],
+    queryFn: async () => {
+      const e = await L.get(`${t}/verify`);
+      return e.ok ? (await e.json()).result === "success" ? { valid: !0 } : (localStorage.removeItem("__chai_at"), { valid: !1 }) : (localStorage.removeItem("__chai_at"), { valid: !0 });
+    }
+  });
+}, Ir = () => {
+  const t = D(), e = G();
+  return V({
+    mutationFn: async () => {
+      const { result: s } = await L.post(`${t}/logout`).then((r) => r.json());
+      if (s === "success")
+        return localStorage.clear(), e.invalidateQueries({ queryKey: ["verify"] }), { logout: !0 };
+      throw new Error("Invalid session");
+    }
+  });
+}, Lr = ({ children: t }) => {
+  const e = Ir();
+  return /* @__PURE__ */ u.jsxs(Ns, { children: [
+    /* @__PURE__ */ u.jsx(Ts, { asChild: !0, children: t }),
+    /* @__PURE__ */ u.jsxs(Is, { children: [
+      /* @__PURE__ */ u.jsxs(Ls, { children: [
+        /* @__PURE__ */ u.jsxs(Ks, { children: [
+          "Are you sure, you want to ",
+          /* @__PURE__ */ u.jsx("span", { className: "text-red-500", children: "Sign Out" }),
+          "?"
+        ] }),
+        /* @__PURE__ */ u.jsx(Bs, { children: "Kindly ensure that all your data is saved before proceeding with the sign-out process to prevent any potential loss of unsaved information" })
+      ] }),
+      /* @__PURE__ */ u.jsxs(_s, { children: [
+        /* @__PURE__ */ u.jsx($s, { disabled: e.isPending, children: "Cancel" }),
+        /* @__PURE__ */ u.jsxs(
+          "button",
+          {
+            disabled: e.isPending,
+            onClick: () => e.mutate(),
+            className: "rounded-md text-white w-28 text-center justify-center bg-red-600 hover:bg-red-700 flex items-center gap-x-2",
+            children: [
+              e.isPending && /* @__PURE__ */ u.jsx(Qs, { className: "animate-spin w-5 h-5" }),
+              "Sign Out"
+            ]
+          }
+        )
+      ] })
+    ] })
+  ] });
+}, Kr = () => /* @__PURE__ */ u.jsx(Lr, { children: /* @__PURE__ */ u.jsx("button", { className: "border-gray-200 rounded-md p-2 mb-2 border", children: /* @__PURE__ */ u.jsx(Ds, { className: "w-4 h-4 text-red-500 cursor-pointer hover:text-red-300 duration-300" }) }) }), Br = Kr, _r = Ft(() => import("./PagesPanel-u1IB-nRr.js")), $r = Ft(() => import("./ProjectPanel-EydGZmMW.js")), Hr = Ft(() => import("./CurrentPage-Kmfp-kFk.js")), Gr = () => /* @__PURE__ */ u.jsx("h2", { children: "Your Logo" }), zr = () => {
+  const { mutate: t } = Ar();
+  return ws("editable", !0) ? /* @__PURE__ */ u.jsx(Xt, { onClick: t, className: "bg-blue-600 text-white", children: "Publish" }) : null;
+}, Vr = (t) => {
+  var x;
+  const { data: e, isLoading: s } = ls(), { data: r, isLoading: n } = ds(), { data: a } = fs(), { mutate: c } = Er(), { mutate: d } = Rr(), [g] = we(), b = kr(), l = qr(), P = Ur(), U = D(), p = dt(
+    async (w) => await b.mutateAsync(w),
+    [b]
+  ), v = dt(async () => await l.mutateAsync(), [l]), S = dt(
+    async (w) => await P.mutateAsync(w),
+    [P]
+  ), f = async (w = 20, q = 0) => {
+    const Q = `limit=${w}&offset=${q}`, j = await fetch(`${U}/assets?${Q}`).then((O) => O.json());
+    return j.result === "success" ? j.data : [];
+  }, { logo: m = Gr } = t;
+  if (s || !e)
+    return /* @__PURE__ */ u.jsx(Et, {});
+  if (n || !r)
+    return /* @__PURE__ */ u.jsx(Et, {});
+  const E = {
+    ...t,
+    editable: a != null && a.lockedBy ? a == null ? void 0 : a.lockedBy.self : !0,
+    nonEditableComponent: Qr,
+    blocks: (a == null ? void 0 : a.blocks) || [],
+    brandingOptions: e.brandingOptions,
+    darkMode: t.darkMode || !1,
+    dataProviders: (a == null ? void 0 : a.providers) || [],
+    onSavePage: async ({ blocks: w, providers: q }) => (await d({ blocks: w, providers: q, uuid: g }), !0),
+    onSaveBrandingOptions: async (w) => (await c({ brandingOptions: w }), !0),
+    topBarComponents: {
+      left: [m],
+      center: [Hr],
+      right: [zr]
+    },
+    sideBarComponents: {
+      top: [
+        { icon: Cs, name: "pages", panel: _r },
+        { icon: Ps, name: "settings", panel: $r },
+        ...((x = t.sideBarComponents) == null ? void 0 : x.top) || []
+      ],
+      bottom: [Br]
+    },
+    uploadMediaCallback: p,
+    fetchMediaCallback: f,
+    getUILibraryBlocks: v,
+    getExternalPredefinedBlock: S,
+    getPages: () => r
+  };
+  return /* @__PURE__ */ u.jsx(vs, { ...E });
+}, Jr = ({ logo: t }) => {
+  const [e, s] = ft(!1), [r, n] = ft(""), [a, c] = ft(""), { mutate: d, isPending: g } = Nr(), b = (l) => {
+    l.preventDefault(), d({ email: r, password: a });
+  };
+  return /* @__PURE__ */ u.jsx("section", { className: "h-screen w-screen flex items-center justify-center bg-[radial-gradient(#AAA,transparent_0.5px)] duration-300 [background-size:6px_6px]", children: /* @__PURE__ */ u.jsx("div", { className: "overflow-hidden bg-white rounded-xl w-96 drop-shadow-2xl duration-300", children: /* @__PURE__ */ u.jsxs("div", { className: "p-12", children: [
+    /* @__PURE__ */ u.jsxs("div", { className: "max-w-2xl mx-auto text-center", children: [
+      /* @__PURE__ */ u.jsx(ms, { children: t ? ps.createElement(t) : "" }),
+      /* @__PURE__ */ u.jsx("p", { className: "max-w-xl mx-auto text-base leading-relaxed text-gray-700 font-thin", children: "Enter your login credential to continue" })
+    ] }),
+    /* @__PURE__ */ u.jsx("div", { className: "mt-8", children: /* @__PURE__ */ u.jsxs("form", { method: "POST", onSubmit: b, className: "space-y-5", children: [
+      /* @__PURE__ */ u.jsx("div", { children: /* @__PURE__ */ u.jsxs("div", { className: "mt-2.5 relative text-gray-400 focus-within:text-gray-600", children: [
+        /* @__PURE__ */ u.jsx("div", { className: "absolute inset-y-0 left-0 flex items-center pl-3 pointer-events-none", children: /* @__PURE__ */ u.jsx(ys, {}) }),
+        /* @__PURE__ */ u.jsx(
+          "input",
+          {
+            value: r,
+            onChange: (l) => n(l.target.value),
+            type: "email",
+            id: "email",
+            placeholder: "Enter email",
+            className: "block w-full py-4 px-10 text-black placeholder-gray-500 transition-all duration-200 bg-white border border-gray-200 rounded-md focus:outline-none focus:border-blue-600 caret-blue-600"
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ u.jsx("div", { children: /* @__PURE__ */ u.jsxs("div", { className: "mt-2.5 relative text-gray-400 focus-within:text-gray-600", children: [
+        /* @__PURE__ */ u.jsx("div", { className: "absolute inset-y-0 left-0 flex items-center pl-3 pointer-events-none", children: /* @__PURE__ */ u.jsx(
+          "svg",
+          {
+            className: "w-5 h-5",
+            xmlns: "http://www.w3.org/2000/svg",
+            fill: "none",
+            viewBox: "0 0 24 24",
+            stroke: "currentColor",
+            children: /* @__PURE__ */ u.jsx(
+              "path",
+              {
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeWidth: "2",
+                d: "M12 11c0 3.517-1.009 6.799-2.753 9.571m-3.44-2.04l.054-.09A13.916 13.916 0 008 11a4 4 0 118 0c0 1.017-.07 2.019-.203 3m-2.118 6.844A21.88 21.88 0 0015.171 17m3.839 1.132c.645-2.266.99-4.659.99-7.132A8 8 0 008 4.07M3 15.364c.64-1.319 1-2.8 1-4.364 0-1.457.39-2.823 1.07-4"
+              }
+            )
+          }
+        ) }),
+        /* @__PURE__ */ u.jsx(
+          "input",
+          {
+            value: a,
+            onChange: (l) => c(l.target.value),
+            type: e ? "text" : "password",
+            id: "pwd",
+            placeholder: "Enter password",
+            className: "block w-full py-4 px-10 text-black placeholder-gray-500 transition-all duration-200 bg-white border border-gray-200 rounded-md focus:outline-none focus:border-blue-600 caret-blue-600"
+          }
+        ),
+        /* @__PURE__ */ u.jsx(
+          "button",
+          {
+            type: "button",
+            className: "absolute inset-y-0 right-4 flex items-center pl-3 cursor-pointer",
+            onClick: () => s(!e),
+            children: e ? /* @__PURE__ */ u.jsx(Os, {}) : /* @__PURE__ */ u.jsx(Ss, {})
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ u.jsx("div", { children: /* @__PURE__ */ u.jsx(
+        "button",
+        {
+          disabled: g || qt(r) < 2 || qt(a) < 2,
+          type: "submit",
+          className: "inline-flex disabled:bg-gray-400 items-center justify-center w-full px-4 py-4 text-base font-semibold text-white transition-all duration-200 bg-blue-600 border border-transparent rounded-md focus:outline-none hover:bg-blue-700 focus:bg-blue-700",
+          children: g ? "Signing in..." : "Login"
+        }
+      ) })
+    ] }) }),
+    /* @__PURE__ */ u.jsx("div", { className: "mt-4 flex items-center justify-end gap-x-2 text-sm", children: /* @__PURE__ */ u.jsx(
+      "a",
+      {
+        href: "https://apps.chaibuilder.com/settings",
+        target: "_blank",
+        className: "text-gray-500 hover:text-blue-400",
+        children: "Forget your password?"
+      }
+    ) })
+  ] }) }) });
+}, Wr = (t) => {
+  const { data: e, isLoading: s } = Tr(), r = G();
+  return gs(() => {
+    r.setQueryData(["apiBaseUrl"], t.apiBaseUrl || "/api/chaibuilder");
+  }, [t.apiBaseUrl, r]), s ? /* @__PURE__ */ u.jsx(Et, {}) : e != null && e.valid ? /* @__PURE__ */ u.jsx(Vr, { ...t }) : /* @__PURE__ */ u.jsx(Jr, { logo: t.logo });
+}, Yr = new nr(), fi = (t) => /* @__PURE__ */ u.jsxs(hr, { client: Yr, children: [
+  /* @__PURE__ */ u.jsx(js, { richColors: !0 }),
+  /* @__PURE__ */ u.jsx(Wr, { ...t })
+] });
+export {
+  fi as C,
+  ls as a,
+  Er as b,
+  Fr as c,
+  we as d,
+  li as e,
+  G as f,
+  Rr as g,
+  di as h,
+  ds as u
+};