@chaibuilder/sdk 1.2.25 → 1.2.26

package/dist/index-llTXLDGE.js

@@ -0,0 +1,2201 @@
+var z2 = (a, t, h) => {
+  if (!t.has(a))
+    throw TypeError("Cannot " + h);
+};
+var c = (a, t, h) => (z2(a, t, "read from private field"), h ? h.call(a) : t.get(a)), d = (a, t, h) => {
+  if (t.has(a))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(a) : t.set(a, h);
+}, l = (a, t, h, v) => (z2(a, t, "write to private field"), v ? v.call(a, h) : t.set(a, h), h);
+var v2 = (a, t, h, v) => ({
+  set _(r) {
+    l(a, t, r, h);
+  },
+  get _() {
+    return c(a, t, v);
+  }
+}), o = (a, t, h) => (z2(a, t, "access private method"), h);
+import { j as i } from "./jsx-runtime-WbnYoNE9.js";
+import * as b from "react";
+import H0, { lazy as A2, useCallback as g2, useState as M2, Suspense as u0, useEffect as s0 } from "react";
+import { C as p0 } from "./index-SkyM3d6Q.js";
+import { FileTextIcon as V0, GearIcon as f0, EyeClosedIcon as m0, EyeOpenIcon as L0 } from "@radix-ui/react-icons";
+import { u as x0, B as Y2, A as w0, a as B0, b as C0, c as O0, d as A0, e as S0, f as y0, g as b0, h as P0 } from "./index-Gk6sASBd.js";
+import { toast as h1, Toaster as F0 } from "sonner";
+import { useTranslation as D0 } from "react-i18next";
+import { sortBy as R0, filter as k0, has as T0, set as E0, capitalize as N0, get as b2, omit as I0, size as P2 } from "lodash-es";
+import { g as W0 } from "./html-to-json-ngX9ef2u.js";
+import { Loader as U0, Loader2 as j0, LogOutIcon as Q0 } from "lucide-react";
+import { G as X2 } from "./index-YpnaudSM.js";
+var N1 = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(a) {
+    return this.listeners.add(a), this.onSubscribe(), () => {
+      this.listeners.delete(a), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, E1 = typeof window > "u" || "Deno" in window;
+function K() {
+}
+function K0(a, t) {
+  return typeof a == "function" ? a(t) : a;
+}
+function H2(a) {
+  return typeof a == "number" && a >= 0 && a !== 1 / 0;
+}
+function t0(a, t) {
+  return Math.max(a + (t || 0) - Date.now(), 0);
+}
+function F2(a, t) {
+  const {
+    type: h = "all",
+    exact: v,
+    fetchStatus: r,
+    predicate: n,
+    queryKey: e,
+    stale: g
+  } = a;
+  if (e) {
+    if (v) {
+      if (t.queryHash !== S2(e, t.options))
+        return !1;
+    } else if (!U1(t.queryKey, e))
+      return !1;
+  }
+  if (h !== "all") {
+    const s = t.isActive();
+    if (h === "active" && !s || h === "inactive" && s)
+      return !1;
+  }
+  return !(typeof g == "boolean" && t.isStale() !== g || typeof r < "u" && r !== t.state.fetchStatus || n && !n(t));
+}
+function D2(a, t) {
+  const { exact: h, status: v, predicate: r, mutationKey: n } = a;
+  if (n) {
+    if (!t.options.mutationKey)
+      return !1;
+    if (h) {
+      if (W1(t.options.mutationKey) !== W1(n))
+        return !1;
+    } else if (!U1(t.options.mutationKey, n))
+      return !1;
+  }
+  return !(v && t.state.status !== v || r && !r(t));
+}
+function S2(a, t) {
+  return ((t == null ? void 0 : t.queryKeyHashFn) || W1)(a);
+}
+function W1(a) {
+  return JSON.stringify(
+    a,
+    (t, h) => u2(h) ? Object.keys(h).sort().reduce((v, r) => (v[r] = h[r], v), {}) : h
+  );
+}
+function U1(a, t) {
+  return a === t ? !0 : typeof a != typeof t ? !1 : a && t && typeof a == "object" && typeof t == "object" ? !Object.keys(t).some((h) => !U1(a[h], t[h])) : !1;
+}
+function a0(a, t) {
+  if (a === t)
+    return a;
+  const h = R2(a) && R2(t);
+  if (h || u2(a) && u2(t)) {
+    const v = h ? a.length : Object.keys(a).length, r = h ? t : Object.keys(t), n = r.length, e = h ? [] : {};
+    let g = 0;
+    for (let s = 0; s < n; s++) {
+      const p = h ? s : r[s];
+      e[p] = a0(a[p], t[p]), e[p] === a[p] && g++;
+    }
+    return v === n && g === v ? a : e;
+  }
+  return t;
+}
+function n2(a, t) {
+  if (a && !t || t && !a)
+    return !1;
+  for (const h in a)
+    if (a[h] !== t[h])
+      return !1;
+  return !0;
+}
+function R2(a) {
+  return Array.isArray(a) && a.length === Object.keys(a).length;
+}
+function u2(a) {
+  if (!k2(a))
+    return !1;
+  const t = a.constructor;
+  if (typeof t > "u")
+    return !0;
+  const h = t.prototype;
+  return !(!k2(h) || !h.hasOwnProperty("isPrototypeOf"));
+}
+function k2(a) {
+  return Object.prototype.toString.call(a) === "[object Object]";
+}
+function h0(a) {
+  return new Promise((t) => {
+    setTimeout(t, a);
+  });
+}
+function T2(a) {
+  h0(0).then(a);
+}
+function s2(a, t, h) {
+  return typeof h.structuralSharing == "function" ? h.structuralSharing(a, t) : h.structuralSharing !== !1 ? a0(a, t) : t;
+}
+function G0(a, t, h = 0) {
+  const v = [...a, t];
+  return h && v.length > h ? v.slice(1) : v;
+}
+function q0(a, t, h = 0) {
+  const v = [t, ...a];
+  return h && v.length > h ? v.slice(0, -1) : v;
+}
+var g1, c1, L1, U2, _0 = (U2 = class extends N1 {
+  constructor() {
+    super();
+    d(this, g1, void 0);
+    d(this, c1, void 0);
+    d(this, L1, void 0);
+    l(this, L1, (t) => {
+      if (!E1 && window.addEventListener) {
+        const h = () => t();
+        return window.addEventListener("visibilitychange", h, !1), () => {
+          window.removeEventListener("visibilitychange", h);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    c(this, c1) || this.setEventListener(c(this, L1));
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || ((t = c(this, c1)) == null || t.call(this), l(this, c1, void 0));
+  }
+  setEventListener(t) {
+    var h;
+    l(this, L1, t), (h = c(this, c1)) == null || h.call(this), l(this, c1, t((v) => {
+      typeof v == "boolean" ? this.setFocused(v) : this.onFocus();
+    }));
+  }
+  setFocused(t) {
+    c(this, g1) !== t && (l(this, g1, t), this.onFocus());
+  }
+  onFocus() {
+    this.listeners.forEach((t) => {
+      t();
+    });
+  }
+  isFocused() {
+    var t;
+    return typeof c(this, g1) == "boolean" ? c(this, g1) : ((t = globalThis.document) == null ? void 0 : t.visibilityState) !== "hidden";
+  }
+}, g1 = new WeakMap(), c1 = new WeakMap(), L1 = new WeakMap(), U2), l2 = new _0(), x1, r1, w1, j2, $0 = (j2 = class extends N1 {
+  constructor() {
+    super();
+    d(this, x1, !0);
+    d(this, r1, void 0);
+    d(this, w1, void 0);
+    l(this, w1, (t) => {
+      if (!E1 && window.addEventListener) {
+        const h = () => t(!0), v = () => t(!1);
+        return window.addEventListener("online", h, !1), window.addEventListener("offline", v, !1), () => {
+          window.removeEventListener("online", h), window.removeEventListener("offline", v);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    c(this, r1) || this.setEventListener(c(this, w1));
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || ((t = c(this, r1)) == null || t.call(this), l(this, r1, void 0));
+  }
+  setEventListener(t) {
+    var h;
+    l(this, w1, t), (h = c(this, r1)) == null || h.call(this), l(this, r1, t(this.setOnline.bind(this)));
+  }
+  setOnline(t) {
+    c(this, x1) !== t && (l(this, x1, t), this.listeners.forEach((v) => {
+      v(t);
+    }));
+  }
+  isOnline() {
+    return c(this, x1);
+  }
+}, x1 = new WeakMap(), r1 = new WeakMap(), w1 = new WeakMap(), j2), i2 = new $0();
+function J0(a) {
+  return Math.min(1e3 * 2 ** a, 3e4);
+}
+function d2(a) {
+  return (a ?? "online") === "online" ? i2.isOnline() : !0;
+}
+var v0 = class {
+  constructor(a) {
+    this.revert = a == null ? void 0 : a.revert, this.silent = a == null ? void 0 : a.silent;
+  }
+};
+function o2(a) {
+  return a instanceof v0;
+}
+function c0(a) {
+  let t = !1, h = 0, v = !1, r, n, e;
+  const g = new Promise((M, u) => {
+    n = M, e = u;
+  }), s = (M) => {
+    var u;
+    v || (H(new v0(M)), (u = a.abort) == null || u.call(a));
+  }, p = () => {
+    t = !0;
+  }, z = () => {
+    t = !1;
+  }, x = () => !l2.isFocused() || a.networkMode !== "always" && !i2.isOnline(), F = (M) => {
+    var u;
+    v || (v = !0, (u = a.onSuccess) == null || u.call(a, M), r == null || r(), n(M));
+  }, H = (M) => {
+    var u;
+    v || (v = !0, (u = a.onError) == null || u.call(a, M), r == null || r(), e(M));
+  }, V = () => new Promise((M) => {
+    var u;
+    r = (O) => {
+      const f = v || !x();
+      return f && M(O), f;
+    }, (u = a.onPause) == null || u.call(a);
+  }).then(() => {
+    var M;
+    r = void 0, v || (M = a.onContinue) == null || M.call(a);
+  }), B = () => {
+    if (v)
+      return;
+    let M;
+    try {
+      M = a.fn();
+    } catch (u) {
+      M = Promise.reject(u);
+    }
+    Promise.resolve(M).then(F).catch((u) => {
+      var k;
+      if (v)
+        return;
+      const O = a.retry ?? (E1 ? 0 : 3), f = a.retryDelay ?? J0, m = typeof f == "function" ? f(h, u) : f, P = O === !0 || typeof O == "number" && h < O || typeof O == "function" && O(h, u);
+      if (t || !P) {
+        H(u);
+        return;
+      }
+      h++, (k = a.onFail) == null || k.call(a, h, u), h0(m).then(() => {
+        if (x())
+          return V();
+      }).then(() => {
+        t ? H(u) : B();
+      });
+    });
+  };
+  return d2(a.networkMode) ? B() : V().then(B), {
+    promise: g,
+    cancel: s,
+    continue: () => (r == null ? void 0 : r()) ? g : Promise.resolve(),
+    cancelRetry: p,
+    continueRetry: z
+  };
+}
+function Z0() {
+  let a = [], t = 0, h = (z) => {
+    z();
+  }, v = (z) => {
+    z();
+  };
+  const r = (z) => {
+    let x;
+    t++;
+    try {
+      x = z();
+    } finally {
+      t--, t || g();
+    }
+    return x;
+  }, n = (z) => {
+    t ? a.push(z) : T2(() => {
+      h(z);
+    });
+  }, e = (z) => (...x) => {
+    n(() => {
+      z(...x);
+    });
+  }, g = () => {
+    const z = a;
+    a = [], z.length && T2(() => {
+      v(() => {
+        z.forEach((x) => {
+          h(x);
+        });
+      });
+    });
+  };
+  return {
+    batch: r,
+    batchCalls: e,
+    schedule: n,
+    setNotifyFunction: (z) => {
+      h = z;
+    },
+    setBatchNotifyFunction: (z) => {
+      v = z;
+    }
+  };
+}
+var S = Z0(), M1, Q2, r0 = (Q2 = class {
+  constructor() {
+    d(this, M1, void 0);
+  }
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout(), H2(this.gcTime) && l(this, M1, setTimeout(() => {
+      this.optionalRemove();
+    }, this.gcTime));
+  }
+  updateGcTime(a) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      a ?? (E1 ? 1 / 0 : 5 * 60 * 1e3)
+    );
+  }
+  clearGcTimeout() {
+    c(this, M1) && (clearTimeout(c(this, M1)), l(this, M1, void 0));
+  }
+}, M1 = new WeakMap(), Q2), B1, C1, W, n1, U, y, j1, o1, O1, c2, q, t1, K2, Y0 = (K2 = class extends r0 {
+  constructor(t) {
+    super();
+    d(this, O1);
+    d(this, q);
+    d(this, B1, void 0);
+    d(this, C1, void 0);
+    d(this, W, void 0);
+    d(this, n1, void 0);
+    d(this, U, void 0);
+    d(this, y, void 0);
+    d(this, j1, void 0);
+    d(this, o1, void 0);
+    l(this, o1, !1), l(this, j1, t.defaultOptions), o(this, O1, c2).call(this, t.options), l(this, y, []), l(this, W, t.cache), this.queryKey = t.queryKey, this.queryHash = t.queryHash, l(this, B1, t.state || X0(this.options)), this.state = c(this, B1), this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  optionalRemove() {
+    !c(this, y).length && this.state.fetchStatus === "idle" && c(this, W).remove(this);
+  }
+  setData(t, h) {
+    const v = s2(this.state.data, t, this.options);
+    return o(this, q, t1).call(this, {
+      data: v,
+      type: "success",
+      dataUpdatedAt: h == null ? void 0 : h.updatedAt,
+      manual: h == null ? void 0 : h.manual
+    }), v;
+  }
+  setState(t, h) {
+    o(this, q, t1).call(this, { type: "setState", state: t, setStateOptions: h });
+  }
+  cancel(t) {
+    var v;
+    const h = c(this, n1);
+    return (v = c(this, U)) == null || v.cancel(t), h ? h.then(K).catch(K) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy(), this.cancel({ silent: !0 });
+  }
+  reset() {
+    this.destroy(), this.setState(c(this, B1));
+  }
+  isActive() {
+    return c(this, y).some(
+      (t) => t.options.enabled !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 && !this.isActive();
+  }
+  isStale() {
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || c(this, y).some((t) => t.getCurrentResult().isStale);
+  }
+  isStaleByTime(t = 0) {
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || !t0(this.state.dataUpdatedAt, t);
+  }
+  onFocus() {
+    var h;
+    const t = c(this, y).find((v) => v.shouldFetchOnWindowFocus());
+    t == null || t.refetch({ cancelRefetch: !1 }), (h = c(this, U)) == null || h.continue();
+  }
+  onOnline() {
+    var h;
+    const t = c(this, y).find((v) => v.shouldFetchOnReconnect());
+    t == null || t.refetch({ cancelRefetch: !1 }), (h = c(this, U)) == null || h.continue();
+  }
+  addObserver(t) {
+    c(this, y).includes(t) || (c(this, y).push(t), this.clearGcTimeout(), c(this, W).notify({ type: "observerAdded", query: this, observer: t }));
+  }
+  removeObserver(t) {
+    c(this, y).includes(t) && (l(this, y, c(this, y).filter((h) => h !== t)), c(this, y).length || (c(this, U) && (c(this, o1) ? c(this, U).cancel({ revert: !0 }) : c(this, U).cancelRetry()), this.scheduleGc()), c(this, W).notify({ type: "observerRemoved", query: this, observer: t }));
+  }
+  getObserversCount() {
+    return c(this, y).length;
+  }
+  invalidate() {
+    this.state.isInvalidated || o(this, q, t1).call(this, { type: "invalidate" });
+  }
+  fetch(t, h) {
+    var p, z, x, F;
+    if (this.state.fetchStatus !== "idle") {
+      if (this.state.dataUpdatedAt && (h != null && h.cancelRefetch))
+        this.cancel({ silent: !0 });
+      else if (c(this, n1))
+        return (p = c(this, U)) == null || p.continueRetry(), c(this, n1);
+    }
+    if (t && o(this, O1, c2).call(this, t), !this.options.queryFn) {
+      const H = c(this, y).find((V) => V.options.queryFn);
+      H && o(this, O1, c2).call(this, H.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 v = new AbortController(), r = {
+      queryKey: this.queryKey,
+      meta: this.meta
+    }, n = (H) => {
+      Object.defineProperty(H, "signal", {
+        enumerable: !0,
+        get: () => (l(this, o1, !0), v.signal)
+      });
+    };
+    n(r);
+    const e = () => this.options.queryFn ? (l(this, o1, !1), this.options.persister ? this.options.persister(
+      this.options.queryFn,
+      r,
+      this
+    ) : this.options.queryFn(
+      r
+    )) : Promise.reject(
+      new Error(`Missing queryFn: '${this.options.queryHash}'`)
+    ), g = {
+      fetchOptions: h,
+      options: this.options,
+      queryKey: this.queryKey,
+      state: this.state,
+      fetchFn: e
+    };
+    n(g), (z = this.options.behavior) == null || z.onFetch(
+      g,
+      this
+    ), l(this, C1, this.state), (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((x = g.fetchOptions) == null ? void 0 : x.meta)) && o(this, q, t1).call(this, { type: "fetch", meta: (F = g.fetchOptions) == null ? void 0 : F.meta });
+    const s = (H) => {
+      var V, B, M, u;
+      o2(H) && H.silent || o(this, q, t1).call(this, {
+        type: "error",
+        error: H
+      }), o2(H) || ((B = (V = c(this, W).config).onError) == null || B.call(
+        V,
+        H,
+        this
+      ), (u = (M = c(this, W).config).onSettled) == null || u.call(
+        M,
+        this.state.data,
+        H,
+        this
+      )), this.isFetchingOptimistic || this.scheduleGc(), this.isFetchingOptimistic = !1;
+    };
+    return l(this, U, c0({
+      fn: g.fetchFn,
+      abort: v.abort.bind(v),
+      onSuccess: (H) => {
+        var V, B, M, u;
+        if (typeof H > "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}`
+          ), s(new Error(`${this.queryHash} data is undefined`));
+          return;
+        }
+        this.setData(H), (B = (V = c(this, W).config).onSuccess) == null || B.call(V, H, this), (u = (M = c(this, W).config).onSettled) == null || u.call(
+          M,
+          H,
+          this.state.error,
+          this
+        ), this.isFetchingOptimistic || this.scheduleGc(), this.isFetchingOptimistic = !1;
+      },
+      onError: s,
+      onFail: (H, V) => {
+        o(this, q, t1).call(this, { type: "failed", failureCount: H, error: V });
+      },
+      onPause: () => {
+        o(this, q, t1).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        o(this, q, t1).call(this, { type: "continue" });
+      },
+      retry: g.options.retry,
+      retryDelay: g.options.retryDelay,
+      networkMode: g.options.networkMode
+    })), l(this, n1, c(this, U).promise), c(this, n1);
+  }
+}, B1 = new WeakMap(), C1 = new WeakMap(), W = new WeakMap(), n1 = new WeakMap(), U = new WeakMap(), y = new WeakMap(), j1 = new WeakMap(), o1 = new WeakMap(), O1 = new WeakSet(), c2 = function(t) {
+  this.options = { ...c(this, j1), ...t }, this.updateGcTime(this.options.gcTime);
+}, q = new WeakSet(), t1 = function(t) {
+  const h = (v) => {
+    switch (t.type) {
+      case "failed":
+        return {
+          ...v,
+          fetchFailureCount: t.failureCount,
+          fetchFailureReason: t.error
+        };
+      case "pause":
+        return {
+          ...v,
+          fetchStatus: "paused"
+        };
+      case "continue":
+        return {
+          ...v,
+          fetchStatus: "fetching"
+        };
+      case "fetch":
+        return {
+          ...v,
+          fetchFailureCount: 0,
+          fetchFailureReason: null,
+          fetchMeta: t.meta ?? null,
+          fetchStatus: d2(this.options.networkMode) ? "fetching" : "paused",
+          ...!v.dataUpdatedAt && {
+            error: null,
+            status: "pending"
+          }
+        };
+      case "success":
+        return {
+          ...v,
+          data: t.data,
+          dataUpdateCount: v.dataUpdateCount + 1,
+          dataUpdatedAt: t.dataUpdatedAt ?? Date.now(),
+          error: null,
+          isInvalidated: !1,
+          status: "success",
+          ...!t.manual && {
+            fetchStatus: "idle",
+            fetchFailureCount: 0,
+            fetchFailureReason: null
+          }
+        };
+      case "error":
+        const r = t.error;
+        return o2(r) && r.revert && c(this, C1) ? { ...c(this, C1), fetchStatus: "idle" } : {
+          ...v,
+          error: r,
+          errorUpdateCount: v.errorUpdateCount + 1,
+          errorUpdatedAt: Date.now(),
+          fetchFailureCount: v.fetchFailureCount + 1,
+          fetchFailureReason: r,
+          fetchStatus: "idle",
+          status: "error"
+        };
+      case "invalidate":
+        return {
+          ...v,
+          isInvalidated: !0
+        };
+      case "setState":
+        return {
+          ...v,
+          ...t.state
+        };
+    }
+  };
+  this.state = h(this.state), S.batch(() => {
+    c(this, y).forEach((v) => {
+      v.onQueryUpdate();
+    }), c(this, W).notify({ query: this, type: "updated", action: t });
+  });
+}, K2);
+function X0(a) {
+  const t = typeof a.initialData == "function" ? a.initialData() : a.initialData, h = typeof t < "u", v = h ? typeof a.initialDataUpdatedAt == "function" ? a.initialDataUpdatedAt() : a.initialDataUpdatedAt : 0;
+  return {
+    data: t,
+    dataUpdateCount: 0,
+    dataUpdatedAt: h ? v ?? Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: !1,
+    status: h ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+var $, G2, t4 = (G2 = class extends N1 {
+  constructor(t = {}) {
+    super();
+    d(this, $, void 0);
+    this.config = t, l(this, $, /* @__PURE__ */ new Map());
+  }
+  build(t, h, v) {
+    const r = h.queryKey, n = h.queryHash ?? S2(r, h);
+    let e = this.get(n);
+    return e || (e = new Y0({
+      cache: this,
+      queryKey: r,
+      queryHash: n,
+      options: t.defaultQueryOptions(h),
+      state: v,
+      defaultOptions: t.getQueryDefaults(r)
+    }), this.add(e)), e;
+  }
+  add(t) {
+    c(this, $).has(t.queryHash) || (c(this, $).set(t.queryHash, t), this.notify({
+      type: "added",
+      query: t
+    }));
+  }
+  remove(t) {
+    const h = c(this, $).get(t.queryHash);
+    h && (t.destroy(), h === t && c(this, $).delete(t.queryHash), this.notify({ type: "removed", query: t }));
+  }
+  clear() {
+    S.batch(() => {
+      this.getAll().forEach((t) => {
+        this.remove(t);
+      });
+    });
+  }
+  get(t) {
+    return c(this, $).get(t);
+  }
+  getAll() {
+    return [...c(this, $).values()];
+  }
+  find(t) {
+    const h = { exact: !0, ...t };
+    return this.getAll().find(
+      (v) => F2(h, v)
+    );
+  }
+  findAll(t = {}) {
+    const h = this.getAll();
+    return Object.keys(t).length > 0 ? h.filter((v) => F2(t, v)) : h;
+  }
+  notify(t) {
+    S.batch(() => {
+      this.listeners.forEach((h) => {
+        h(t);
+      });
+    });
+  }
+  onFocus() {
+    S.batch(() => {
+      this.getAll().forEach((t) => {
+        t.onFocus();
+      });
+    });
+  }
+  onOnline() {
+    S.batch(() => {
+      this.getAll().forEach((t) => {
+        t.onOnline();
+      });
+    });
+  }
+}, $ = new WeakMap(), G2), J, Q1, N, A1, Z, v1, q2, a4 = (q2 = class extends r0 {
+  constructor(t) {
+    super();
+    d(this, Z);
+    d(this, J, void 0);
+    d(this, Q1, void 0);
+    d(this, N, void 0);
+    d(this, A1, void 0);
+    this.mutationId = t.mutationId, l(this, Q1, t.defaultOptions), l(this, N, t.mutationCache), l(this, J, []), this.state = t.state || n0(), this.setOptions(t.options), this.scheduleGc();
+  }
+  setOptions(t) {
+    this.options = { ...c(this, Q1), ...t }, this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(t) {
+    c(this, J).includes(t) || (c(this, J).push(t), this.clearGcTimeout(), c(this, N).notify({
+      type: "observerAdded",
+      mutation: this,
+      observer: t
+    }));
+  }
+  removeObserver(t) {
+    l(this, J, c(this, J).filter((h) => h !== t)), this.scheduleGc(), c(this, N).notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer: t
+    });
+  }
+  optionalRemove() {
+    c(this, J).length || (this.state.status === "pending" ? this.scheduleGc() : c(this, N).remove(this));
+  }
+  continue() {
+    var t;
+    return ((t = c(this, A1)) == null ? void 0 : t.continue()) ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+    this.execute(this.state.variables);
+  }
+  async execute(t) {
+    var r, n, e, g, s, p, z, x, F, H, V, B, M, u, O, f, m, P, k, C;
+    const h = () => (l(this, A1, c0({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(t) : Promise.reject(new Error("No mutationFn found")),
+      onFail: (w, X) => {
+        o(this, Z, v1).call(this, { type: "failed", failureCount: w, error: X });
+      },
+      onPause: () => {
+        o(this, Z, v1).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        o(this, Z, v1).call(this, { type: "continue" });
+      },
+      retry: this.options.retry ?? 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode
+    })), c(this, A1).promise), v = this.state.status === "pending";
+    try {
+      if (!v) {
+        o(this, Z, v1).call(this, { type: "pending", variables: t }), await ((n = (r = c(this, N).config).onMutate) == null ? void 0 : n.call(
+          r,
+          t,
+          this
+        ));
+        const X = await ((g = (e = this.options).onMutate) == null ? void 0 : g.call(e, t));
+        X !== this.state.context && o(this, Z, v1).call(this, {
+          type: "pending",
+          context: X,
+          variables: t
+        });
+      }
+      const w = await h();
+      return await ((p = (s = c(this, N).config).onSuccess) == null ? void 0 : p.call(
+        s,
+        w,
+        t,
+        this.state.context,
+        this
+      )), await ((x = (z = this.options).onSuccess) == null ? void 0 : x.call(z, w, t, this.state.context)), await ((H = (F = c(this, N).config).onSettled) == null ? void 0 : H.call(
+        F,
+        w,
+        null,
+        this.state.variables,
+        this.state.context,
+        this
+      )), await ((B = (V = this.options).onSettled) == null ? void 0 : B.call(V, w, null, t, this.state.context)), o(this, Z, v1).call(this, { type: "success", data: w }), w;
+    } catch (w) {
+      try {
+        throw await ((u = (M = c(this, N).config).onError) == null ? void 0 : u.call(
+          M,
+          w,
+          t,
+          this.state.context,
+          this
+        )), await ((f = (O = this.options).onError) == null ? void 0 : f.call(
+          O,
+          w,
+          t,
+          this.state.context
+        )), await ((P = (m = c(this, N).config).onSettled) == null ? void 0 : P.call(
+          m,
+          void 0,
+          w,
+          this.state.variables,
+          this.state.context,
+          this
+        )), await ((C = (k = this.options).onSettled) == null ? void 0 : C.call(
+          k,
+          void 0,
+          w,
+          t,
+          this.state.context
+        )), w;
+      } finally {
+        o(this, Z, v1).call(this, { type: "error", error: w });
+      }
+    }
+  }
+}, J = new WeakMap(), Q1 = new WeakMap(), N = new WeakMap(), A1 = new WeakMap(), Z = new WeakSet(), v1 = function(t) {
+  const h = (v) => {
+    switch (t.type) {
+      case "failed":
+        return {
+          ...v,
+          failureCount: t.failureCount,
+          failureReason: t.error
+        };
+      case "pause":
+        return {
+          ...v,
+          isPaused: !0
+        };
+      case "continue":
+        return {
+          ...v,
+          isPaused: !1
+        };
+      case "pending":
+        return {
+          ...v,
+          context: t.context,
+          data: void 0,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          isPaused: !d2(this.options.networkMode),
+          status: "pending",
+          variables: t.variables,
+          submittedAt: Date.now()
+        };
+      case "success":
+        return {
+          ...v,
+          data: t.data,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          status: "success",
+          isPaused: !1
+        };
+      case "error":
+        return {
+          ...v,
+          data: void 0,
+          error: t.error,
+          failureCount: v.failureCount + 1,
+          failureReason: t.error,
+          isPaused: !1,
+          status: "error"
+        };
+    }
+  };
+  this.state = h(this.state), S.batch(() => {
+    c(this, J).forEach((v) => {
+      v.onMutationUpdate(t);
+    }), c(this, N).notify({
+      mutation: this,
+      type: "updated",
+      action: t
+    });
+  });
+}, q2);
+function n0() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var j, K1, H1, _2, h4 = (_2 = class extends N1 {
+  constructor(t = {}) {
+    super();
+    d(this, j, void 0);
+    d(this, K1, void 0);
+    d(this, H1, void 0);
+    this.config = t, l(this, j, []), l(this, K1, 0);
+  }
+  build(t, h, v) {
+    const r = new a4({
+      mutationCache: this,
+      mutationId: ++v2(this, K1)._,
+      options: t.defaultMutationOptions(h),
+      state: v
+    });
+    return this.add(r), r;
+  }
+  add(t) {
+    c(this, j).push(t), this.notify({ type: "added", mutation: t });
+  }
+  remove(t) {
+    l(this, j, c(this, j).filter((h) => h !== t)), this.notify({ type: "removed", mutation: t });
+  }
+  clear() {
+    S.batch(() => {
+      c(this, j).forEach((t) => {
+        this.remove(t);
+      });
+    });
+  }
+  getAll() {
+    return c(this, j);
+  }
+  find(t) {
+    const h = { exact: !0, ...t };
+    return c(this, j).find(
+      (v) => D2(h, v)
+    );
+  }
+  findAll(t = {}) {
+    return c(this, j).filter(
+      (h) => D2(t, h)
+    );
+  }
+  notify(t) {
+    S.batch(() => {
+      this.listeners.forEach((h) => {
+        h(t);
+      });
+    });
+  }
+  resumePausedMutations() {
+    return l(this, H1, (c(this, H1) ?? Promise.resolve()).then(() => {
+      const t = c(this, j).filter((h) => h.state.isPaused);
+      return S.batch(
+        () => t.reduce(
+          (h, v) => h.then(() => v.continue().catch(K)),
+          Promise.resolve()
+        )
+      );
+    }).then(() => {
+      l(this, H1, void 0);
+    })), c(this, H1);
+  }
+}, j = new WeakMap(), K1 = new WeakMap(), H1 = new WeakMap(), _2);
+function v4(a) {
+  return {
+    onFetch: (t, h) => {
+      const v = async () => {
+        var V, B, M, u, O;
+        const r = t.options, n = (M = (B = (V = t.fetchOptions) == null ? void 0 : V.meta) == null ? void 0 : B.fetchMore) == null ? void 0 : M.direction, e = ((u = t.state.data) == null ? void 0 : u.pages) || [], g = ((O = t.state.data) == null ? void 0 : O.pageParams) || [], s = { pages: [], pageParams: [] };
+        let p = !1;
+        const z = (f) => {
+          Object.defineProperty(f, "signal", {
+            enumerable: !0,
+            get: () => (t.signal.aborted ? p = !0 : t.signal.addEventListener("abort", () => {
+              p = !0;
+            }), t.signal)
+          });
+        }, x = t.options.queryFn || (() => Promise.reject(
+          new Error(`Missing queryFn: '${t.options.queryHash}'`)
+        )), F = async (f, m, P) => {
+          if (p)
+            return Promise.reject();
+          if (m == null && f.pages.length)
+            return Promise.resolve(f);
+          const k = {
+            queryKey: t.queryKey,
+            pageParam: m,
+            direction: P ? "backward" : "forward",
+            meta: t.options.meta
+          };
+          z(k);
+          const C = await x(
+            k
+          ), { maxPages: w } = t.options, X = P ? q0 : G0;
+          return {
+            pages: X(f.pages, C, w),
+            pageParams: X(f.pageParams, m, w)
+          };
+        };
+        let H;
+        if (n && e.length) {
+          const f = n === "backward", m = f ? c4 : E2, P = {
+            pages: e,
+            pageParams: g
+          }, k = m(r, P);
+          H = await F(P, k, f);
+        } else {
+          H = await F(
+            s,
+            g[0] ?? r.initialPageParam
+          );
+          const f = a ?? e.length;
+          for (let m = 1; m < f; m++) {
+            const P = E2(r, H);
+            H = await F(H, P);
+          }
+        }
+        return H;
+      };
+      t.options.persister ? t.fetchFn = () => {
+        var r, n;
+        return (n = (r = t.options).persister) == null ? void 0 : n.call(
+          r,
+          v,
+          {
+            queryKey: t.queryKey,
+            meta: t.options.meta,
+            signal: t.signal
+          },
+          h
+        );
+      } : t.fetchFn = v;
+    }
+  };
+}
+function E2(a, { pages: t, pageParams: h }) {
+  const v = t.length - 1;
+  return a.getNextPageParam(
+    t[v],
+    t,
+    h[v],
+    h
+  );
+}
+function c4(a, { pages: t, pageParams: h }) {
+  var v;
+  return (v = a.getPreviousPageParam) == null ? void 0 : v.call(
+    a,
+    t[0],
+    t,
+    h[0],
+    h
+  );
+}
+var A, l1, i1, S1, y1, e1, b1, P1, $2, r4 = ($2 = class {
+  constructor(a = {}) {
+    d(this, A, void 0);
+    d(this, l1, void 0);
+    d(this, i1, void 0);
+    d(this, S1, void 0);
+    d(this, y1, void 0);
+    d(this, e1, void 0);
+    d(this, b1, void 0);
+    d(this, P1, void 0);
+    l(this, A, a.queryCache || new t4()), l(this, l1, a.mutationCache || new h4()), l(this, i1, a.defaultOptions || {}), l(this, S1, /* @__PURE__ */ new Map()), l(this, y1, /* @__PURE__ */ new Map()), l(this, e1, 0);
+  }
+  mount() {
+    v2(this, e1)._++, c(this, e1) === 1 && (l(this, b1, l2.subscribe(() => {
+      l2.isFocused() && (this.resumePausedMutations(), c(this, A).onFocus());
+    })), l(this, P1, i2.subscribe(() => {
+      i2.isOnline() && (this.resumePausedMutations(), c(this, A).onOnline());
+    })));
+  }
+  unmount() {
+    var a, t;
+    v2(this, e1)._--, c(this, e1) === 0 && ((a = c(this, b1)) == null || a.call(this), l(this, b1, void 0), (t = c(this, P1)) == null || t.call(this), l(this, P1, void 0));
+  }
+  isFetching(a) {
+    return c(this, A).findAll({ ...a, fetchStatus: "fetching" }).length;
+  }
+  isMutating(a) {
+    return c(this, l1).findAll({ ...a, status: "pending" }).length;
+  }
+  getQueryData(a) {
+    var t;
+    return (t = c(this, A).find({ queryKey: a })) == null ? void 0 : t.state.data;
+  }
+  ensureQueryData(a) {
+    const t = this.getQueryData(a.queryKey);
+    return t !== void 0 ? Promise.resolve(t) : this.fetchQuery(a);
+  }
+  getQueriesData(a) {
+    return this.getQueryCache().findAll(a).map(({ queryKey: t, state: h }) => {
+      const v = h.data;
+      return [t, v];
+    });
+  }
+  setQueryData(a, t, h) {
+    const v = c(this, A).find({ queryKey: a }), r = v == null ? void 0 : v.state.data, n = K0(t, r);
+    if (typeof n > "u")
+      return;
+    const e = this.defaultQueryOptions({ queryKey: a });
+    return c(this, A).build(this, e).setData(n, { ...h, manual: !0 });
+  }
+  setQueriesData(a, t, h) {
+    return S.batch(
+      () => this.getQueryCache().findAll(a).map(({ queryKey: v }) => [
+        v,
+        this.setQueryData(v, t, h)
+      ])
+    );
+  }
+  getQueryState(a) {
+    var t;
+    return (t = c(this, A).find({ queryKey: a })) == null ? void 0 : t.state;
+  }
+  removeQueries(a) {
+    const t = c(this, A);
+    S.batch(() => {
+      t.findAll(a).forEach((h) => {
+        t.remove(h);
+      });
+    });
+  }
+  resetQueries(a, t) {
+    const h = c(this, A), v = {
+      type: "active",
+      ...a
+    };
+    return S.batch(() => (h.findAll(a).forEach((r) => {
+      r.reset();
+    }), this.refetchQueries(v, t)));
+  }
+  cancelQueries(a = {}, t = {}) {
+    const h = { revert: !0, ...t }, v = S.batch(
+      () => c(this, A).findAll(a).map((r) => r.cancel(h))
+    );
+    return Promise.all(v).then(K).catch(K);
+  }
+  invalidateQueries(a = {}, t = {}) {
+    return S.batch(() => {
+      if (c(this, A).findAll(a).forEach((v) => {
+        v.invalidate();
+      }), a.refetchType === "none")
+        return Promise.resolve();
+      const h = {
+        ...a,
+        type: a.refetchType ?? a.type ?? "active"
+      };
+      return this.refetchQueries(h, t);
+    });
+  }
+  refetchQueries(a = {}, t) {
+    const h = {
+      ...t,
+      cancelRefetch: (t == null ? void 0 : t.cancelRefetch) ?? !0
+    }, v = S.batch(
+      () => c(this, A).findAll(a).filter((r) => !r.isDisabled()).map((r) => {
+        let n = r.fetch(void 0, h);
+        return h.throwOnError || (n = n.catch(K)), r.state.fetchStatus === "paused" ? Promise.resolve() : n;
+      })
+    );
+    return Promise.all(v).then(K);
+  }
+  fetchQuery(a) {
+    const t = this.defaultQueryOptions(a);
+    typeof t.retry > "u" && (t.retry = !1);
+    const h = c(this, A).build(this, t);
+    return h.isStaleByTime(t.staleTime) ? h.fetch(t) : Promise.resolve(h.state.data);
+  }
+  prefetchQuery(a) {
+    return this.fetchQuery(a).then(K).catch(K);
+  }
+  fetchInfiniteQuery(a) {
+    return a.behavior = v4(a.pages), this.fetchQuery(a);
+  }
+  prefetchInfiniteQuery(a) {
+    return this.fetchInfiniteQuery(a).then(K).catch(K);
+  }
+  resumePausedMutations() {
+    return c(this, l1).resumePausedMutations();
+  }
+  getQueryCache() {
+    return c(this, A);
+  }
+  getMutationCache() {
+    return c(this, l1);
+  }
+  getDefaultOptions() {
+    return c(this, i1);
+  }
+  setDefaultOptions(a) {
+    l(this, i1, a);
+  }
+  setQueryDefaults(a, t) {
+    c(this, S1).set(W1(a), {
+      queryKey: a,
+      defaultOptions: t
+    });
+  }
+  getQueryDefaults(a) {
+    const t = [...c(this, S1).values()];
+    let h = {};
+    return t.forEach((v) => {
+      U1(a, v.queryKey) && (h = { ...h, ...v.defaultOptions });
+    }), h;
+  }
+  setMutationDefaults(a, t) {
+    c(this, y1).set(W1(a), {
+      mutationKey: a,
+      defaultOptions: t
+    });
+  }
+  getMutationDefaults(a) {
+    const t = [...c(this, y1).values()];
+    let h = {};
+    return t.forEach((v) => {
+      U1(a, v.mutationKey) && (h = { ...h, ...v.defaultOptions });
+    }), h;
+  }
+  defaultQueryOptions(a) {
+    if (a != null && a._defaulted)
+      return a;
+    const t = {
+      ...c(this, i1).queries,
+      ...(a == null ? void 0 : a.queryKey) && this.getQueryDefaults(a.queryKey),
+      ...a,
+      _defaulted: !0
+    };
+    return t.queryHash || (t.queryHash = S2(
+      t.queryKey,
+      t
+    )), typeof t.refetchOnReconnect > "u" && (t.refetchOnReconnect = t.networkMode !== "always"), typeof t.throwOnError > "u" && (t.throwOnError = !!t.suspense), typeof t.networkMode > "u" && t.persister && (t.networkMode = "offlineFirst"), t;
+  }
+  defaultMutationOptions(a) {
+    return a != null && a._defaulted ? a : {
+      ...c(this, i1).mutations,
+      ...(a == null ? void 0 : a.mutationKey) && this.getMutationDefaults(a.mutationKey),
+      ...a,
+      _defaulted: !0
+    };
+  }
+  clear() {
+    c(this, A).clear(), c(this, l1).clear();
+  }
+}, A = new WeakMap(), l1 = new WeakMap(), i1 = new WeakMap(), S1 = new WeakMap(), y1 = new WeakMap(), e1 = new WeakMap(), b1 = new WeakMap(), P1 = new WeakMap(), $2), E, L, F1, D, u1, D1, Y, G1, R1, k1, s1, p1, d1, V1, f1, I1, q1, p2, _1, V2, $1, f2, J1, m2, Z1, L2, Y1, x2, X1, w2, e2, l0, J2, n4 = (J2 = class extends N1 {
+  constructor(t, h) {
+    super();
+    d(this, f1);
+    d(this, q1);
+    d(this, _1);
+    d(this, $1);
+    d(this, J1);
+    d(this, Z1);
+    d(this, Y1);
+    d(this, X1);
+    d(this, e2);
+    d(this, E, void 0);
+    d(this, L, void 0);
+    d(this, F1, void 0);
+    d(this, D, void 0);
+    d(this, u1, void 0);
+    d(this, D1, void 0);
+    d(this, Y, void 0);
+    d(this, G1, void 0);
+    d(this, R1, 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.
+    d(this, k1, void 0);
+    d(this, s1, void 0);
+    d(this, p1, void 0);
+    d(this, d1, void 0);
+    d(this, V1, void 0);
+    l(this, L, void 0), l(this, F1, void 0), l(this, D, void 0), l(this, V1, /* @__PURE__ */ new Set()), l(this, E, t), this.options = h, l(this, Y, null), this.bindMethods(), this.setOptions(h);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (c(this, L).addObserver(this), N2(c(this, L), this.options) ? o(this, f1, I1).call(this) : this.updateResult(), o(this, J1, m2).call(this));
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return B2(
+      c(this, L),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return B2(
+      c(this, L),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), o(this, Z1, L2).call(this), o(this, Y1, x2).call(this), c(this, L).removeObserver(this);
+  }
+  setOptions(t, h) {
+    const v = this.options, r = c(this, L);
+    if (this.options = c(this, E).defaultQueryOptions(t), n2(v, this.options) || c(this, E).getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: c(this, L),
+      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 = v.queryKey), o(this, X1, w2).call(this);
+    const n = this.hasListeners();
+    n && I2(
+      c(this, L),
+      r,
+      this.options,
+      v
+    ) && o(this, f1, I1).call(this), this.updateResult(h), n && (c(this, L) !== r || this.options.enabled !== v.enabled || this.options.staleTime !== v.staleTime) && o(this, q1, p2).call(this);
+    const e = o(this, _1, V2).call(this);
+    n && (c(this, L) !== r || this.options.enabled !== v.enabled || e !== c(this, d1)) && o(this, $1, f2).call(this, e);
+  }
+  getOptimisticResult(t) {
+    const h = c(this, E).getQueryCache().build(c(this, E), t), v = this.createResult(h, t);
+    return i4(this, v) && (l(this, D, v), l(this, D1, this.options), l(this, u1, c(this, L).state)), v;
+  }
+  getCurrentResult() {
+    return c(this, D);
+  }
+  trackResult(t) {
+    const h = {};
+    return Object.keys(t).forEach((v) => {
+      Object.defineProperty(h, v, {
+        configurable: !1,
+        enumerable: !0,
+        get: () => (c(this, V1).add(v), t[v])
+      });
+    }), h;
+  }
+  getCurrentQuery() {
+    return c(this, L);
+  }
+  refetch({ ...t } = {}) {
+    return this.fetch({
+      ...t
+    });
+  }
+  fetchOptimistic(t) {
+    const h = c(this, E).defaultQueryOptions(t), v = c(this, E).getQueryCache().build(c(this, E), h);
+    return v.isFetchingOptimistic = !0, v.fetch().then(() => this.createResult(v, h));
+  }
+  fetch(t) {
+    return o(this, f1, I1).call(this, {
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), c(this, D)));
+  }
+  createResult(t, h) {
+    var k;
+    const v = c(this, L), r = this.options, n = c(this, D), e = c(this, u1), g = c(this, D1), p = t !== v ? t.state : c(this, F1), { state: z } = t;
+    let { error: x, errorUpdatedAt: F, fetchStatus: H, status: V } = z, B = !1, M;
+    if (h._optimisticResults) {
+      const C = this.hasListeners(), w = !C && N2(t, h), X = C && I2(t, v, h, r);
+      (w || X) && (H = d2(t.options.networkMode) ? "fetching" : "paused", z.dataUpdatedAt || (V = "pending")), h._optimisticResults === "isRestoring" && (H = "idle");
+    }
+    if (h.select && typeof z.data < "u")
+      if (n && z.data === (e == null ? void 0 : e.data) && h.select === c(this, G1))
+        M = c(this, R1);
+      else
+        try {
+          l(this, G1, h.select), M = h.select(z.data), M = s2(n == null ? void 0 : n.data, M, h), l(this, R1, M), l(this, Y, null);
+        } catch (C) {
+          l(this, Y, C);
+        }
+    else
+      M = z.data;
+    if (typeof h.placeholderData < "u" && typeof M > "u" && V === "pending") {
+      let C;
+      if (n != null && n.isPlaceholderData && h.placeholderData === (g == null ? void 0 : g.placeholderData))
+        C = n.data;
+      else if (C = typeof h.placeholderData == "function" ? h.placeholderData(
+        (k = c(this, k1)) == null ? void 0 : k.state.data,
+        c(this, k1)
+      ) : h.placeholderData, h.select && typeof C < "u")
+        try {
+          C = h.select(C), l(this, Y, null);
+        } catch (w) {
+          l(this, Y, w);
+        }
+      typeof C < "u" && (V = "success", M = s2(
+        n == null ? void 0 : n.data,
+        C,
+        h
+      ), B = !0);
+    }
+    c(this, Y) && (x = c(this, Y), M = c(this, R1), F = Date.now(), V = "error");
+    const u = H === "fetching", O = V === "pending", f = V === "error", m = O && u;
+    return {
+      status: V,
+      fetchStatus: H,
+      isPending: O,
+      isSuccess: V === "success",
+      isError: f,
+      isInitialLoading: m,
+      isLoading: m,
+      data: M,
+      dataUpdatedAt: z.dataUpdatedAt,
+      error: x,
+      errorUpdatedAt: F,
+      failureCount: z.fetchFailureCount,
+      failureReason: z.fetchFailureReason,
+      errorUpdateCount: z.errorUpdateCount,
+      isFetched: z.dataUpdateCount > 0 || z.errorUpdateCount > 0,
+      isFetchedAfterMount: z.dataUpdateCount > p.dataUpdateCount || z.errorUpdateCount > p.errorUpdateCount,
+      isFetching: u,
+      isRefetching: u && !O,
+      isLoadingError: f && z.dataUpdatedAt === 0,
+      isPaused: H === "paused",
+      isPlaceholderData: B,
+      isRefetchError: f && z.dataUpdatedAt !== 0,
+      isStale: y2(t, h),
+      refetch: this.refetch
+    };
+  }
+  updateResult(t) {
+    const h = c(this, D), v = this.createResult(c(this, L), this.options);
+    if (l(this, u1, c(this, L).state), l(this, D1, this.options), c(this, u1).data !== void 0 && l(this, k1, c(this, L)), n2(v, h))
+      return;
+    l(this, D, v);
+    const r = {}, n = () => {
+      if (!h)
+        return !0;
+      const { notifyOnChangeProps: e } = this.options, g = typeof e == "function" ? e() : e;
+      if (g === "all" || !g && !c(this, V1).size)
+        return !0;
+      const s = new Set(
+        g ?? c(this, V1)
+      );
+      return this.options.throwOnError && s.add("error"), Object.keys(c(this, D)).some((p) => {
+        const z = p;
+        return c(this, D)[z] !== h[z] && s.has(z);
+      });
+    };
+    (t == null ? void 0 : t.listeners) !== !1 && n() && (r.listeners = !0), o(this, e2, l0).call(this, { ...r, ...t });
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && o(this, J1, m2).call(this);
+  }
+}, E = new WeakMap(), L = new WeakMap(), F1 = new WeakMap(), D = new WeakMap(), u1 = new WeakMap(), D1 = new WeakMap(), Y = new WeakMap(), G1 = new WeakMap(), R1 = new WeakMap(), k1 = new WeakMap(), s1 = new WeakMap(), p1 = new WeakMap(), d1 = new WeakMap(), V1 = new WeakMap(), f1 = new WeakSet(), I1 = function(t) {
+  o(this, X1, w2).call(this);
+  let h = c(this, L).fetch(
+    this.options,
+    t
+  );
+  return t != null && t.throwOnError || (h = h.catch(K)), h;
+}, q1 = new WeakSet(), p2 = function() {
+  if (o(this, Z1, L2).call(this), E1 || c(this, D).isStale || !H2(this.options.staleTime))
+    return;
+  const h = t0(
+    c(this, D).dataUpdatedAt,
+    this.options.staleTime
+  ) + 1;
+  l(this, s1, setTimeout(() => {
+    c(this, D).isStale || this.updateResult();
+  }, h));
+}, _1 = new WeakSet(), V2 = function() {
+  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(c(this, L)) : this.options.refetchInterval) ?? !1;
+}, $1 = new WeakSet(), f2 = function(t) {
+  o(this, Y1, x2).call(this), l(this, d1, t), !(E1 || this.options.enabled === !1 || !H2(c(this, d1)) || c(this, d1) === 0) && l(this, p1, setInterval(() => {
+    (this.options.refetchIntervalInBackground || l2.isFocused()) && o(this, f1, I1).call(this);
+  }, c(this, d1)));
+}, J1 = new WeakSet(), m2 = function() {
+  o(this, q1, p2).call(this), o(this, $1, f2).call(this, o(this, _1, V2).call(this));
+}, Z1 = new WeakSet(), L2 = function() {
+  c(this, s1) && (clearTimeout(c(this, s1)), l(this, s1, void 0));
+}, Y1 = new WeakSet(), x2 = function() {
+  c(this, p1) && (clearInterval(c(this, p1)), l(this, p1, void 0));
+}, X1 = new WeakSet(), w2 = function() {
+  const t = c(this, E).getQueryCache().build(c(this, E), this.options);
+  if (t === c(this, L))
+    return;
+  const h = c(this, L);
+  l(this, L, t), l(this, F1, t.state), this.hasListeners() && (h == null || h.removeObserver(this), t.addObserver(this));
+}, e2 = new WeakSet(), l0 = function(t) {
+  S.batch(() => {
+    t.listeners && this.listeners.forEach((h) => {
+      h(c(this, D));
+    }), c(this, E).getQueryCache().notify({
+      query: c(this, L),
+      type: "observerResultsUpdated"
+    });
+  });
+}, J2);
+function l4(a, t) {
+  return t.enabled !== !1 && !a.state.dataUpdatedAt && !(a.state.status === "error" && t.retryOnMount === !1);
+}
+function N2(a, t) {
+  return l4(a, t) || a.state.dataUpdatedAt > 0 && B2(a, t, t.refetchOnMount);
+}
+function B2(a, t, h) {
+  if (t.enabled !== !1) {
+    const v = typeof h == "function" ? h(a) : h;
+    return v === "always" || v !== !1 && y2(a, t);
+  }
+  return !1;
+}
+function I2(a, t, h, v) {
+  return h.enabled !== !1 && (a !== t || v.enabled === !1) && (!h.suspense || a.state.status !== "error") && y2(a, h);
+}
+function y2(a, t) {
+  return a.isStaleByTime(t.staleTime);
+}
+function i4(a, t) {
+  return !n2(a.getCurrentResult(), t);
+}
+var z1, T, Q, a1, T1, r2, t2, C2, Z2, e4 = (Z2 = class extends N1 {
+  constructor(t, h) {
+    super();
+    d(this, T1);
+    d(this, t2);
+    d(this, z1, void 0);
+    d(this, T, void 0);
+    d(this, Q, void 0);
+    d(this, a1, void 0);
+    l(this, T, void 0), l(this, z1, t), this.setOptions(h), this.bindMethods(), o(this, T1, r2).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(t) {
+    var v;
+    const h = this.options;
+    this.options = c(this, z1).defaultMutationOptions(t), n2(h, this.options) || c(this, z1).getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: c(this, Q),
+      observer: this
+    }), (v = c(this, Q)) == null || v.setOptions(this.options);
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || (t = c(this, Q)) == null || t.removeObserver(this);
+  }
+  onMutationUpdate(t) {
+    o(this, T1, r2).call(this), o(this, t2, C2).call(this, t);
+  }
+  getCurrentResult() {
+    return c(this, T);
+  }
+  reset() {
+    l(this, Q, void 0), o(this, T1, r2).call(this), o(this, t2, C2).call(this);
+  }
+  mutate(t, h) {
+    var v;
+    return l(this, a1, h), (v = c(this, Q)) == null || v.removeObserver(this), l(this, Q, c(this, z1).getMutationCache().build(c(this, z1), this.options)), c(this, Q).addObserver(this), c(this, Q).execute(t);
+  }
+}, z1 = new WeakMap(), T = new WeakMap(), Q = new WeakMap(), a1 = new WeakMap(), T1 = new WeakSet(), r2 = function() {
+  var h;
+  const t = ((h = c(this, Q)) == null ? void 0 : h.state) ?? n0();
+  l(this, T, {
+    ...t,
+    isPending: t.status === "pending",
+    isSuccess: t.status === "success",
+    isError: t.status === "error",
+    isIdle: t.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, t2 = new WeakSet(), C2 = function(t) {
+  S.batch(() => {
+    var h, v, r, n, e, g, s, p;
+    c(this, a1) && this.hasListeners() && ((t == null ? void 0 : t.type) === "success" ? ((v = (h = c(this, a1)).onSuccess) == null || v.call(
+      h,
+      t.data,
+      c(this, T).variables,
+      c(this, T).context
+    ), (n = (r = c(this, a1)).onSettled) == null || n.call(
+      r,
+      t.data,
+      null,
+      c(this, T).variables,
+      c(this, T).context
+    )) : (t == null ? void 0 : t.type) === "error" && ((g = (e = c(this, a1)).onError) == null || g.call(
+      e,
+      t.error,
+      c(this, T).variables,
+      c(this, T).context
+    ), (p = (s = c(this, a1)).onSettled) == null || p.call(
+      s,
+      void 0,
+      t.error,
+      c(this, T).variables,
+      c(this, T).context
+    ))), this.listeners.forEach((z) => {
+      z(c(this, T));
+    });
+  });
+}, Z2);
+var i0 = b.createContext(
+  void 0
+), G = (a) => {
+  const t = b.useContext(i0);
+  if (a)
+    return a;
+  if (!t)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return t;
+}, d4 = ({
+  client: a,
+  children: t
+}) => (b.useEffect(() => (a.mount(), () => {
+  a.unmount();
+}), [a]), /* @__PURE__ */ b.createElement(i0.Provider, { value: a }, t)), e0 = b.createContext(!1), z4 = () => b.useContext(e0), et = e0.Provider;
+function g4() {
+  let a = !1;
+  return {
+    clearReset: () => {
+      a = !1;
+    },
+    reset: () => {
+      a = !0;
+    },
+    isReset: () => a
+  };
+}
+var M4 = b.createContext(g4()), o4 = () => b.useContext(M4);
+function d0(a, t) {
+  return typeof a == "function" ? a(...t) : !!a;
+}
+var H4 = (a, t) => {
+  (a.suspense || a.throwOnError) && (t.isReset() || (a.retryOnMount = !1));
+}, u4 = (a) => {
+  b.useEffect(() => {
+    a.clearReset();
+  }, [a]);
+}, s4 = ({
+  result: a,
+  errorResetBoundary: t,
+  throwOnError: h,
+  query: v
+}) => a.isError && !t.isReset() && !a.isFetching && d0(h, [a.error, v]);
+var p4 = (a) => {
+  a.suspense && typeof a.staleTime != "number" && (a.staleTime = 1e3);
+};
+var V4 = (a, t) => (a == null ? void 0 : a.suspense) && t.isPending, f4 = (a, t, h) => t.fetchOptimistic(a).catch(() => {
+  h.clearReset();
+});
+function m4(a, t, h) {
+  if (process.env.NODE_ENV !== "production" && (typeof a != "object" || Array.isArray(a)))
+    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 v = G(h), r = z4(), n = o4(), e = v.defaultQueryOptions(a);
+  e._optimisticResults = r ? "isRestoring" : "optimistic", p4(e), H4(e, n), u4(n);
+  const [g] = b.useState(
+    () => new t(
+      v,
+      e
+    )
+  ), s = g.getOptimisticResult(e);
+  if (b.useSyncExternalStore(
+    b.useCallback(
+      (p) => {
+        const z = r ? () => {
+        } : g.subscribe(S.batchCalls(p));
+        return g.updateResult(), z;
+      },
+      [g, r]
+    ),
+    () => g.getCurrentResult(),
+    () => g.getCurrentResult()
+  ), b.useEffect(() => {
+    g.setOptions(e, { listeners: !1 });
+  }, [e, g]), V4(e, s))
+    throw f4(e, g, n);
+  if (s4({
+    result: s,
+    errorResetBoundary: n,
+    throwOnError: e.throwOnError,
+    query: g.getCurrentQuery()
+  }))
+    throw s.error;
+  return e.notifyOnChangeProps ? s : g.trackResult(s);
+}
+function a2(a, t) {
+  return m4(a, n4, t);
+}
+function _(a, t) {
+  const h = G(t), [v] = b.useState(
+    () => new e4(
+      h,
+      a
+    )
+  );
+  b.useEffect(() => {
+    v.setOptions(a);
+  }, [v, a]);
+  const r = b.useSyncExternalStore(
+    b.useCallback(
+      (e) => v.subscribe(S.batchCalls(e)),
+      [v]
+    ),
+    () => v.getCurrentResult(),
+    () => v.getCurrentResult()
+  ), n = b.useCallback(
+    (e, g) => {
+      v.mutate(e, g).catch(L4);
+    },
+    [v]
+  );
+  if (r.error && d0(v.options.throwOnError, [r.error]))
+    throw r.error;
+  return { ...r, mutate: n, mutateAsync: r.mutate };
+}
+function L4() {
+}
+function R() {
+  return G().getQueryData(["apiBaseUrl"]) || "/api/chaibuilder";
+}
+const m1 = () => {
+  const { data: a, refetch: t } = a2({
+    queryKey: ["currentPage"],
+    queryFn: () => localStorage.getItem("currentPage") || ""
+  });
+  return [
+    a,
+    (h) => {
+      h && (localStorage.setItem("currentPage", h || ""), t());
+    }
+  ];
+};
+let W2 = "";
+const h2 = () => (W2 = localStorage.getItem("__chai_at"), W2);
+function x4(a) {
+  const t = {
+    method: "GET",
+    headers: { "x-chai-access-token": h2() }
+  };
+  return fetch(a, t);
+}
+function w4(a, t) {
+  const h = {
+    method: "POST",
+    headers: { "x-chai-access-token": h2() },
+    body: JSON.stringify(t)
+  };
+  return fetch(a, h);
+}
+function B4(a, t) {
+  const h = {
+    method: "PUT",
+    headers: { "x-chai-access-token": h2() },
+    body: JSON.stringify(t)
+  };
+  return fetch(a, h);
+}
+function C4(a, t) {
+  const h = {
+    method: "DELETE",
+    headers: { "x-chai-access-token": h2() },
+    body: JSON.stringify(t)
+  };
+  return fetch(a, h);
+}
+const I = {
+  get: x4,
+  post: w4,
+  put: B4,
+  delete: C4
+}, z0 = () => {
+  const [a, t] = m1(), h = R();
+  return a2({
+    queryKey: ["project"],
+    queryFn: async () => {
+      const { data: v } = await I.get(`${h}/project`).then((r) => r.json());
+      if (!a && v) {
+        const r = localStorage.getItem("currentPage");
+        t(r || (v == null ? void 0 : v.homepage));
+      }
+      return v;
+    }
+  });
+}, g0 = () => {
+  const a = R();
+  return a2({
+    queryKey: ["pages"],
+    queryFn: async () => {
+      const { data: t } = await I.get(`${a}/pages`).then((h) => h.json());
+      return t || [];
+    }
+  });
+}, M0 = () => {
+  const [a] = m1(), t = R();
+  return a2({
+    queryKey: ["page_data", a],
+    queryFn: async () => {
+      const { data: h } = await I.get(`${t}/page?uuid=${a}`).then((v) => v.json());
+      return h;
+    },
+    enabled: !!a,
+    staleTime: 3e3
+  });
+}, O2 = () => /* @__PURE__ */ i.jsx("div", { className: "h-screen w-screen bg-gray-200", children: /* @__PURE__ */ i.jsxs("div", { className: "flex flex-col h-full w-full justify-center items-center", children: [
+  /* @__PURE__ */ i.jsxs("div", { className: "flex flex-row gap-2", children: [
+    /* @__PURE__ */ i.jsx("div", { className: "w-4 h-4 rounded-full bg-orange-600 animate-bounce [animation-delay:.6s]" }),
+    /* @__PURE__ */ i.jsx("div", { className: "w-4 h-4 rounded-full bg-blue-600 animate-bounce [animation-delay:.4s]" }),
+    /* @__PURE__ */ i.jsx("div", { className: "w-4 h-4 rounded-full bg-green-600 animate-bounce [animation-delay:.2s]" }),
+    /* @__PURE__ */ i.jsx("div", { className: "w-4 h-4 rounded-full bg-yellow-600 animate-bounce [animation-delay:.0s]" })
+  ] }),
+  /* @__PURE__ */ i.jsx("div", { className: "text-gray-700 font-thin", children: "Loading Builder..." })
+] }) }), O4 = (a = "Project updated successfully.") => {
+  const t = G(), h = R();
+  return _({
+    mutationFn: async (v) => await I.put(`${h}/project`, v).then((r) => r.json()),
+    onSuccess: () => {
+      t.invalidateQueries({ queryKey: ["project"] }), h1.success(a);
+    }
+  });
+}, A4 = () => {
+  const [a] = ["SAVED"], [t, h] = m1(), v = x0(), { t: r } = D0();
+  return (n) => a !== "SAVED" ? (h1.error(r("You have unsaved changes. Please save before changing the page.")), !1) : t === n.uuid ? !1 : (v(), setTimeout(() => h(n.uuid), 100), !0);
+}, dt = () => {
+  const a = G(), t = A4(), h = R();
+  return _({
+    mutationFn: async (v) => I.post(`${h}/pages`, v).then((r) => r.json()),
+    onSuccess: (v) => {
+      a.invalidateQueries({ queryKey: ["pages"] }), t({ uuid: v.uuid, slug: v.slug }), h1.success("Page added successfully.");
+    }
+  });
+}, S4 = () => {
+  const a = R(), [t] = m1(), h = G();
+  return _({
+    mutationFn: async (v) => I.put(`${a}/page`, v).then((r) => r.json()),
+    onSuccess: async (v) => {
+      var r;
+      if (v.result === "error" && ((r = v.error) == null ? void 0 : r.code) == "PAGE_LOCKED") {
+        h.invalidateQueries({ queryKey: ["page_data", t] });
+        return;
+      }
+      h1.success("Page saved successfully.");
+    }
+  });
+}, y4 = () => {
+  const a = R(), { data: t } = g0(), [h] = m1(), { data: v } = z0(), r = G();
+  return _({
+    mutationFn: async () => {
+      const n = t.find((e) => e.uuid === h).slug;
+      return await I.post(`${a}/publish`, {
+        slug: n,
+        uuid: h,
+        isHomepage: (v == null ? void 0 : v.homepage) === h
+      }).then((e) => e.json());
+    },
+    onSuccess: async (n) => {
+      var e;
+      if (n.result === "error" && ((e = n.error) == null ? void 0 : e.code) == "PAGE_LOCKED") {
+        r.invalidateQueries({ queryKey: ["page_data", h] });
+        return;
+      }
+      h1.success("Page published successfully.", {
+        position: "bottom-right",
+        duration: 2e3
+      });
+    }
+  });
+}, zt = () => {
+  const a = G(), t = R();
+  return _({
+    mutationFn: async (h) => I.delete(`${t}/page`, h).then((v) => v.json()),
+    onSuccess: () => {
+      h1.success("Page deleted successfully."), a.invalidateQueries({ queryKey: ["pages"] });
+    }
+  });
+}, b4 = () => {
+  const a = G(), t = R();
+  return _({
+    mutationFn: async (h) => I.post(`${t}/take-control`, { uuid: h }).then((v) => v.json()),
+    onSuccess: (h, v) => {
+      a.invalidateQueries({ queryKey: ["page_data", v] });
+    }
+  });
+}, P4 = () => {
+  const a = R();
+  return _({
+    mutationFn: async () => {
+      const { data: t } = await I.get(`${a}/library`).then((h) => h.json());
+      return R0(
+        k0(t, (h) => !T0(h, "hidden")),
+        "group"
+      );
+    }
+  });
+}, F4 = () => {
+  const a = R();
+  return _({
+    mutationFn: async (t) => {
+      if (!t || !t.uuid)
+        return [];
+      try {
+        const { data: h } = await I.get(`${a}/block?uuid=${t.uuid}&format=${t.format}`).then(async (v) => t.format === "html" ? W0(await v.text()) : await v.json());
+        return E0(h, "0._name", N0(t.group)), h || [];
+      } catch {
+        return [];
+      }
+    }
+  });
+}, D4 = () => {
+  const a = R();
+  return _({
+    mutationFn: async (t) => {
+      const h = new FormData();
+      h.append("file", t);
+      const { data: v } = await fetch(`${a}/upload`, {
+        method: "POST",
+        headers: { "x-chai-access-token": h2() },
+        body: h
+      }).then((r) => r.json());
+      return v;
+    }
+  });
+};
+function o0(a) {
+  return X2({ 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" } }] })(a);
+}
+function R4(a) {
+  return X2({ 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" } }] })(a);
+}
+const k4 = () => {
+  const { mutate: a, isPending: t } = b4(), [h] = m1(), { data: v } = M0(), r = b2(v, "lockedBy.name", ""), n = b2(v, "lockedBy.email", "");
+  return /* @__PURE__ */ i.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__ */ i.jsxs("h2", { className: "text-2xl font-bold", children: [
+      "Page is ",
+      /* @__PURE__ */ i.jsx("span", { className: "text-red-500", children: "locked" })
+    ] }),
+    /* @__PURE__ */ i.jsxs("div", { className: "text-gray-500 dark:text-gray-400 font-light", children: [
+      "This page is currently being edited by ",
+      /* @__PURE__ */ i.jsx("br", {}),
+      /* @__PURE__ */ i.jsxs("div", { className: "flex items-center gap-x-3 w-max mx-auto font-medium text-gray-700 mt-2 text-sm", children: [
+        /* @__PURE__ */ i.jsxs("div", { className: "flex items-center gap-x-2 bg-gray-100 py-1 px-2 rounded-md", children: [
+          /* @__PURE__ */ i.jsx(R4, { className: "w-4 h-4 text-gray-500" }),
+          " ",
+          r
+        ] }),
+        /* @__PURE__ */ i.jsxs("div", { className: "flex items-center gap-x-2 bg-gray-100 py-1 px-2 rounded-md lowercase", children: [
+          /* @__PURE__ */ i.jsx(o0, { className: "w-4 h-4 text-gray-500" }),
+          " ",
+          n
+        ] })
+      ] }),
+      /* @__PURE__ */ i.jsxs("div", { className: "pt-4", children: [
+        "If you take control, ",
+        r,
+        " will be ",
+        /* @__PURE__ */ i.jsx("span", { className: "text-red-500", children: "restricted" }),
+        " from making additional edits."
+      ] })
+    ] }),
+    /* @__PURE__ */ i.jsx(
+      Y2,
+      {
+        disabled: t,
+        onClick: () => a(h),
+        className: `w-36 ${t ? "bg-transparent shadow-none hover:bg-transparent" : ""}`,
+        children: t ? /* @__PURE__ */ i.jsx(U0, { className: "text-sm animate-spin text-gray-500" }) : "Take Over"
+      }
+    )
+  ] });
+}, T4 = () => {
+  const a = R(), t = G();
+  return _({
+    mutationFn: async (h) => {
+      const v = await fetch(`${a}/login`, { method: "POST", body: JSON.stringify(h) });
+      if (v.ok)
+        return await v.json();
+      throw v.status === 401 ? new Error("Invalid login credentials") : new Error("Invalid");
+    },
+    onSuccess: (h) => {
+      const { data: v } = h;
+      if (!v.accessToken) {
+        h1.error("Something went wrong. Please try again.", { position: "top-center" });
+        return;
+      }
+      localStorage.setItem("__chai_at", v.accessToken), localStorage.setItem("__chai_ur", JSON.stringify(I0(v, ["accessToken"]))), t.invalidateQueries({ queryKey: ["verify"] }), h1.success("Logged in successfully.");
+    },
+    onError: () => {
+      h1.error("Invalid login credentials. Please try again.", { position: "top-center" });
+    }
+  });
+}, E4 = () => {
+  const a = R();
+  return a2({
+    queryKey: ["verify"],
+    queryFn: async () => {
+      const t = await I.get(`${a}/verify`);
+      return t.ok ? (await t.json()).result === "success" ? { valid: !0 } : (localStorage.removeItem("__chai_at"), { valid: !1 }) : (localStorage.removeItem("__chai_at"), { valid: !0 });
+    }
+  });
+}, N4 = () => {
+  const a = R(), t = G();
+  return _({
+    mutationFn: async () => {
+      const { result: h } = await I.post(`${a}/logout`).then((v) => v.json());
+      if (h === "success")
+        return localStorage.clear(), t.invalidateQueries({ queryKey: ["verify"] }), { logout: !0 };
+      throw new Error("Invalid session");
+    }
+  });
+}, I4 = ({ children: a }) => {
+  const t = N4();
+  return /* @__PURE__ */ i.jsxs(w0, { children: [
+    /* @__PURE__ */ i.jsx(B0, { asChild: !0, children: a }),
+    /* @__PURE__ */ i.jsxs(C0, { children: [
+      /* @__PURE__ */ i.jsxs(O0, { children: [
+        /* @__PURE__ */ i.jsxs(A0, { children: [
+          "Are you sure, you want to ",
+          /* @__PURE__ */ i.jsx("span", { className: "text-red-500", children: "Sign Out" }),
+          "?"
+        ] }),
+        /* @__PURE__ */ i.jsx(S0, { 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__ */ i.jsxs(y0, { children: [
+        /* @__PURE__ */ i.jsx(b0, { disabled: t.isPending, children: "Cancel" }),
+        /* @__PURE__ */ i.jsxs(
+          "button",
+          {
+            disabled: t.isPending,
+            onClick: () => t.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: [
+              t.isPending && /* @__PURE__ */ i.jsx(j0, { className: "animate-spin w-5 h-5" }),
+              "Sign Out"
+            ]
+          }
+        )
+      ] })
+    ] })
+  ] });
+}, W4 = () => /* @__PURE__ */ i.jsx(I4, { children: /* @__PURE__ */ i.jsx("button", { className: "border-gray-200 rounded-md p-2 mb-2 border", children: /* @__PURE__ */ i.jsx(Q0, { className: "w-4 h-4 text-red-500 cursor-pointer hover:text-red-300 duration-300" }) }) }), U4 = A2(() => import("./PagesPanel-6rrLXEO-.js")), j4 = A2(() => import("./ProjectPanel-tz3bjdXy.js")), Q4 = A2(() => import("./CurrentPage-tJUjXWdb.js")), K4 = () => /* @__PURE__ */ i.jsx("h2", { children: "Your Logo" }), G4 = () => {
+  const { mutate: a } = y4();
+  return P0("editable", !0) ? /* @__PURE__ */ i.jsx(Y2, { onClick: a, className: "bg-blue-600 text-white", children: "Publish" }) : null;
+}, q4 = (a) => {
+  var f;
+  const { data: t, isLoading: h } = z0(), { data: v, isLoading: r } = g0(), { data: n } = M0(), { mutate: e } = O4(), { mutate: g } = S4(), [s] = m1(), p = D4(), z = P4(), x = F4(), F = R(), H = g2(
+    async (m) => await p.mutateAsync(m),
+    [p]
+  ), V = g2(async () => await z.mutateAsync(), [z]), B = g2(
+    async (m) => await x.mutateAsync(m),
+    [x]
+  ), M = async (m = 20, P = 0) => {
+    const k = `limit=${m}&offset=${P}`, C = await fetch(`${F}/assets?${k}`).then((w) => w.json());
+    return C.result === "success" ? C.data : [];
+  }, { logo: u = K4 } = a;
+  if (h || !t)
+    return /* @__PURE__ */ i.jsx(O2, {});
+  if (r || !v)
+    return /* @__PURE__ */ i.jsx(O2, {});
+  const O = {
+    ...a,
+    editable: n != null && n.lockedBy ? n == null ? void 0 : n.lockedBy.self : !0,
+    nonEditableComponent: k4,
+    blocks: (n == null ? void 0 : n.blocks) || [],
+    brandingOptions: t.brandingOptions,
+    darkMode: a.darkMode || !1,
+    dataProviders: (n == null ? void 0 : n.providers) || [],
+    onSavePage: async ({ blocks: m, providers: P }) => (await g({ blocks: m, providers: P, uuid: s }), !0),
+    onSaveBrandingOptions: async (m) => (await e({ brandingOptions: m }), !0),
+    topBarComponents: {
+      left: [u],
+      center: [Q4],
+      right: [G4]
+    },
+    sideBarComponents: {
+      top: [
+        { icon: V0, name: "pages", panel: U4 },
+        { icon: f0, name: "settings", panel: j4 },
+        ...((f = a.sideBarComponents) == null ? void 0 : f.top) || []
+      ],
+      bottom: [W4]
+    },
+    uploadMediaCallback: H,
+    fetchMediaCallback: M,
+    getUILibraryBlocks: V,
+    getExternalPredefinedBlock: B,
+    getPages: () => v
+  };
+  return /* @__PURE__ */ i.jsx(p0, { ...O });
+}, _4 = ({ logo: a }) => {
+  const [t, h] = M2(!1), [v, r] = M2(""), [n, e] = M2(""), { mutate: g, isPending: s } = T4(), p = (z) => {
+    z.preventDefault(), g({ email: v, password: n });
+  };
+  return /* @__PURE__ */ i.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__ */ i.jsx("div", { className: "overflow-hidden bg-white rounded-xl w-96 drop-shadow-2xl duration-300", children: /* @__PURE__ */ i.jsxs("div", { className: "p-12", children: [
+    /* @__PURE__ */ i.jsxs("div", { className: "max-w-2xl mx-auto text-center", children: [
+      /* @__PURE__ */ i.jsx(u0, { children: a ? H0.createElement(a) : "" }),
+      /* @__PURE__ */ i.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__ */ i.jsx("div", { className: "mt-8", children: /* @__PURE__ */ i.jsxs("form", { method: "POST", onSubmit: p, className: "space-y-5", children: [
+      /* @__PURE__ */ i.jsx("div", { children: /* @__PURE__ */ i.jsxs("div", { className: "mt-2.5 relative text-gray-400 focus-within:text-gray-600", children: [
+        /* @__PURE__ */ i.jsx("div", { className: "absolute inset-y-0 left-0 flex items-center pl-3 pointer-events-none", children: /* @__PURE__ */ i.jsx(o0, {}) }),
+        /* @__PURE__ */ i.jsx(
+          "input",
+          {
+            value: v,
+            onChange: (z) => r(z.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__ */ i.jsx("div", { children: /* @__PURE__ */ i.jsxs("div", { className: "mt-2.5 relative text-gray-400 focus-within:text-gray-600", children: [
+        /* @__PURE__ */ i.jsx("div", { className: "absolute inset-y-0 left-0 flex items-center pl-3 pointer-events-none", children: /* @__PURE__ */ i.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__ */ i.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__ */ i.jsx(
+          "input",
+          {
+            value: n,
+            onChange: (z) => e(z.target.value),
+            type: t ? "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__ */ i.jsx(
+          "button",
+          {
+            type: "button",
+            className: "absolute inset-y-0 right-4 flex items-center pl-3 cursor-pointer",
+            onClick: () => h(!t),
+            children: t ? /* @__PURE__ */ i.jsx(m0, {}) : /* @__PURE__ */ i.jsx(L0, {})
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ i.jsx("div", { children: /* @__PURE__ */ i.jsx(
+        "button",
+        {
+          disabled: s || P2(v) < 2 || P2(n) < 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: s ? "Signing in..." : "Login"
+        }
+      ) })
+    ] }) }),
+    /* @__PURE__ */ i.jsx("div", { className: "mt-4 flex items-center justify-end gap-x-2 text-sm", children: /* @__PURE__ */ i.jsx(
+      "a",
+      {
+        href: "https://apps.chaibuilder.com/settings",
+        target: "_blank",
+        className: "text-gray-500 hover:text-blue-400",
+        children: "Forget your password?"
+      }
+    ) })
+  ] }) }) });
+}, $4 = (a) => {
+  const { data: t, isLoading: h } = E4(), v = G();
+  return s0(() => {
+    v.setQueryData(["apiBaseUrl"], a.apiBaseUrl || "/api/chaibuilder");
+  }, [a.apiBaseUrl, v]), h ? /* @__PURE__ */ i.jsx(O2, {}) : t != null && t.valid ? /* @__PURE__ */ i.jsx(q4, { ...a }) : /* @__PURE__ */ i.jsx(_4, { logo: a.logo });
+}, J4 = new r4(), gt = (a) => /* @__PURE__ */ i.jsxs(d4, { client: J4, children: [
+  /* @__PURE__ */ i.jsx(F0, { richColors: !0 }),
+  /* @__PURE__ */ i.jsx($4, { ...a })
+] });
+export {
+  gt as C,
+  z0 as a,
+  O4 as b,
+  A4 as c,
+  m1 as d,
+  dt as e,
+  G as f,
+  S4 as g,
+  zt as h,
+  g0 as u
+};