@chaibuilder/sdk 1.2.92 → 1.2.93-beta.1

package/dist/useGlobalBlocksStore-HlGhDxuV.js

@@ -0,0 +1,1258 @@
+import Qe, { createContext as et, useReducer as tt, useEffect as le, useDebugValue as ot, useCallback as N, useContext as nt, useState as st, useMemo as rt } from "react";
+import { find as Q, filter as H, flatten as Y, map as x, omit as ue, isString as xe, has as De, includes as ee, without as ct, get as $, compact as it, isObject as lt, each as q, set as pe, first as te, noop as ge, isEmpty as ut, keys as he, chunk as dt, forEach as at } from "lodash-es";
+import { atom as P, useAtomValue as J, useAtom as W } from "jotai";
+import { g as re } from "./iconBase-HBZkvN04.js";
+import { g as ft } from "./_commonjsHelpers-f3sTPFkQ.js";
+import { useThrottledCallback as pt } from "@react-hookz/web";
+import "react-i18next";
+import "@chaibuilder/runtime";
+import gt from "tree-model";
+var O = { VITE_OPENAI_API_KEY: "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", VITE_UNSPASH_ACCESS_KEY: "XgYBCm-XCHecRMsbfhw6oZWGkltco1U5TYMEd0LXZeA", BASE_URL: "/", MODE: "production", DEV: !1, PROD: !0, SSR: !1 };
+let ht = 0;
+function R(e, t) {
+  const o = `atom${++ht}`, n = {
+    toString: () => o
+  };
+  return typeof e == "function" ? n.read = e : (n.init = e, n.read = (s) => s(n), n.write = (s, r, c) => r(
+    n,
+    typeof c == "function" ? c(s(n)) : c
+  )), t && (n.write = t), n;
+}
+const de = (e) => "init" in e, ae = (e) => !!e.write, ce = /* @__PURE__ */ new WeakMap(), mt = (e, t) => {
+  ce.set(e, t), e.catch(() => {
+  }).finally(() => ce.delete(e));
+}, ye = (e, t) => {
+  const o = ce.get(e);
+  o && (ce.delete(e), o(t));
+}, Pe = (e, t) => {
+  e.status = "fulfilled", e.value = t;
+}, Le = (e, t) => {
+  e.status = "rejected", e.reason = t;
+}, vt = (e) => typeof (e == null ? void 0 : e.then) == "function", K = (e, t) => "v" in e && "v" in t && Object.is(e.v, t.v), Ie = (e, t) => "e" in e && "e" in t && Object.is(e.e, t.e), z = (e) => "v" in e && e.v instanceof Promise, Bt = (e, t) => "v" in e && "v" in t && e.v.orig && e.v.orig === t.v.orig, se = (e) => {
+  if ("e" in e)
+    throw e.e;
+  return e.v;
+}, kt = () => {
+  const e = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new Map();
+  let n, s, r;
+  (O ? "production" : void 0) !== "production" && (n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set());
+  const c = (i) => e.get(i), u = (i, a) => {
+    (O ? "production" : void 0) !== "production" && Object.freeze(a);
+    const g = e.get(i);
+    if (e.set(i, a), o.has(i) || o.set(i, g), g && z(g)) {
+      const f = "v" in a ? a.v instanceof Promise ? a.v : Promise.resolve(a.v) : Promise.reject(a.e);
+      ye(g.v, f);
+    }
+  }, d = (i, a, g) => {
+    const f = /* @__PURE__ */ new Map();
+    let h = !1;
+    g.forEach((p, v) => {
+      !p && v === i && (p = a), p ? (f.set(v, p), a.d.get(v) !== p && (h = !0)) : (O ? "production" : void 0) !== "production" && console.warn("[Bug] atom state not found");
+    }), (h || a.d.size !== f.size) && (a.d = f);
+  }, l = (i, a, g) => {
+    const f = c(i), h = {
+      d: (f == null ? void 0 : f.d) || /* @__PURE__ */ new Map(),
+      v: a
+    };
+    if (g && d(i, h, g), f && K(f, h) && f.d === h.d)
+      return f;
+    if (f && z(f) && z(h) && Bt(f, h)) {
+      if (f.d === h.d)
+        return f;
+      h.v = f.v;
+    }
+    return u(i, h), h;
+  }, m = (i, a, g, f) => {
+    if (vt(a)) {
+      let h;
+      const p = new Promise((v, E) => {
+        let k = !1;
+        a.then(
+          (_) => {
+            if (!k) {
+              k = !0;
+              const b = c(i), j = l(
+                i,
+                p,
+                g
+              );
+              Pe(p, _), v(_), (b == null ? void 0 : b.d) !== j.d && C(i, j, b == null ? void 0 : b.d);
+            }
+          },
+          (_) => {
+            if (!k) {
+              k = !0;
+              const b = c(i), j = l(
+                i,
+                p,
+                g
+              );
+              Le(p, _), E(_), (b == null ? void 0 : b.d) !== j.d && C(i, j, b == null ? void 0 : b.d);
+            }
+          }
+        ), h = (_) => {
+          k || (k = !0, _.then(
+            (b) => Pe(p, b),
+            (b) => Le(p, b)
+          ), v(_));
+        };
+      });
+      return p.orig = a, p.status = "pending", mt(p, (v) => {
+        v && h(v), f == null || f();
+      }), l(i, p, g);
+    }
+    return l(i, a, g);
+  }, I = (i, a, g) => {
+    const f = c(i), h = {
+      d: (f == null ? void 0 : f.d) || /* @__PURE__ */ new Map(),
+      e: a
+    };
+    return g && d(i, h, g), f && Ie(f, h) && f.d === h.d ? f : (u(i, h), h);
+  }, F = (i) => {
+    const a = c(i);
+    if (a && (a.d.forEach((k, _) => {
+      _ !== i && !t.has(_) && F(_);
+    }), Array.from(a.d).every(([k, _]) => {
+      const b = c(k);
+      return k === i || b === _ || // TODO This is a hack, we should find a better solution.
+      b && !z(b) && K(b, _);
+    })))
+      return a;
+    const g = /* @__PURE__ */ new Map();
+    let f = !0;
+    const h = (k) => {
+      if (k === i) {
+        const b = c(k);
+        if (b)
+          return g.set(k, b), se(b);
+        if (de(k))
+          return g.set(k, void 0), k.init;
+        throw new Error("no atom init");
+      }
+      const _ = F(k);
+      return g.set(k, _), se(_);
+    };
+    let p, v;
+    const E = {
+      get signal() {
+        return p || (p = new AbortController()), p.signal;
+      },
+      get setSelf() {
+        return (O ? "production" : void 0) !== "production" && !ae(i) && console.warn("setSelf function cannot be used with read-only atom"), !v && ae(i) && (v = (...k) => {
+          if ((O ? "production" : void 0) !== "production" && f && console.warn("setSelf function cannot be called in sync"), !f)
+            return S(i, ...k);
+        }), v;
+      }
+    };
+    try {
+      const k = i.read(h, E);
+      return m(
+        i,
+        k,
+        g,
+        () => p == null ? void 0 : p.abort()
+      );
+    } catch (k) {
+      return I(i, k, g);
+    } finally {
+      f = !1;
+    }
+  }, U = (i) => se(F(i)), B = (i) => {
+    let a = t.get(i);
+    return a || (a = y(i)), a;
+  }, A = (i, a) => !a.l.size && (!a.t.size || a.t.size === 1 && a.t.has(i)), L = (i) => {
+    const a = t.get(i);
+    a && A(i, a) && M(i);
+  }, D = (i) => {
+    const a = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new WeakMap(), f = (p) => {
+      const v = t.get(p);
+      v == null || v.t.forEach((E) => {
+        E !== p && (a.set(
+          E,
+          (a.get(E) || /* @__PURE__ */ new Set()).add(p)
+        ), g.set(E, (g.get(E) || 0) + 1), f(E));
+      });
+    };
+    f(i);
+    const h = (p) => {
+      const v = t.get(p);
+      v == null || v.t.forEach((E) => {
+        var k;
+        if (E !== p) {
+          let _ = g.get(E);
+          if (_ && g.set(E, --_), !_) {
+            let b = !!((k = a.get(E)) != null && k.size);
+            if (b) {
+              const j = c(E), qe = F(E);
+              b = !j || !K(j, qe);
+            }
+            b || a.forEach((j) => j.delete(E));
+          }
+          h(E);
+        }
+      });
+    };
+    h(i);
+  }, w = (i, ...a) => {
+    let g = !0;
+    const f = (v) => se(F(v)), h = (v, ...E) => {
+      let k;
+      if (v === i) {
+        if (!de(v))
+          throw new Error("atom not writable");
+        const _ = c(v), b = m(v, E[0]);
+        (!_ || !K(_, b)) && D(v);
+      } else
+        k = w(v, ...E);
+      if (!g) {
+        const _ = V();
+        (O ? "production" : void 0) !== "production" && s.forEach(
+          (b) => b({ type: "async-write", flushed: _ })
+        );
+      }
+      return k;
+    }, p = i.write(f, h, ...a);
+    return g = !1, p;
+  }, S = (i, ...a) => {
+    const g = w(i, ...a), f = V();
+    return (O ? "production" : void 0) !== "production" && s.forEach(
+      (h) => h({ type: "write", flushed: f })
+    ), g;
+  }, y = (i, a) => {
+    const g = {
+      t: new Set(a && [a]),
+      l: /* @__PURE__ */ new Set()
+    };
+    if (t.set(i, g), (O ? "production" : void 0) !== "production" && r.add(i), F(i).d.forEach((f, h) => {
+      const p = t.get(h);
+      p ? p.t.add(i) : h !== i && y(h, i);
+    }), F(i), ae(i) && i.onMount) {
+      const f = i.onMount((...h) => S(i, ...h));
+      f && (g.u = f);
+    }
+    return g;
+  }, M = (i) => {
+    var a;
+    const g = (a = t.get(i)) == null ? void 0 : a.u;
+    g && g(), t.delete(i), (O ? "production" : void 0) !== "production" && r.delete(i);
+    const f = c(i);
+    f ? (z(f) && ye(f.v), f.d.forEach((h, p) => {
+      if (p !== i) {
+        const v = t.get(p);
+        v && (v.t.delete(i), A(p, v) && M(p));
+      }
+    })) : (O ? "production" : void 0) !== "production" && console.warn("[Bug] could not find atom state to unmount", i);
+  }, C = (i, a, g) => {
+    const f = new Set(a.d.keys());
+    g == null || g.forEach((h, p) => {
+      if (f.has(p)) {
+        f.delete(p);
+        return;
+      }
+      const v = t.get(p);
+      v && (v.t.delete(i), A(p, v) && M(p));
+    }), f.forEach((h) => {
+      const p = t.get(h);
+      p ? p.t.add(i) : t.has(i) && y(h, i);
+    });
+  }, V = () => {
+    let i;
+    for ((O ? "production" : void 0) !== "production" && (i = /* @__PURE__ */ new Set()); o.size; ) {
+      const a = Array.from(o);
+      o.clear(), a.forEach(([g, f]) => {
+        const h = c(g);
+        if (h) {
+          h.d !== (f == null ? void 0 : f.d) && C(g, h, f == null ? void 0 : f.d);
+          const p = t.get(g);
+          p && !// TODO This seems pretty hacky. Hope to fix it.
+          // Maybe we could `mountDependencies` in `setAtomState`?
+          (f && !z(f) && (K(f, h) || Ie(f, h))) && (p.l.forEach((v) => v()), (O ? "production" : void 0) !== "production" && i.add(g));
+        } else
+          (O ? "production" : void 0) !== "production" && console.warn("[Bug] no atom state to flush");
+      });
+    }
+    if ((O ? "production" : void 0) !== "production")
+      return n.forEach((a) => a("state")), i;
+  }, T = (i, a) => {
+    const g = B(i), f = V(), h = g.l;
+    return h.add(a), (O ? "production" : void 0) !== "production" && (n.forEach((p) => p("sub")), s.forEach(
+      (p) => p({ type: "sub", flushed: f })
+    )), () => {
+      h.delete(a), L(i), (O ? "production" : void 0) !== "production" && (n.forEach((p) => p("unsub")), s.forEach((p) => p({ type: "unsub" })));
+    };
+  };
+  return (O ? "production" : void 0) !== "production" ? {
+    get: U,
+    set: S,
+    sub: T,
+    // store dev methods (these are tentative and subject to change without notice)
+    dev_subscribe_store: (i, a) => a !== 2 ? (console.warn(
+      "The current StoreListener revision is 2. The older ones are deprecated."
+    ), n.add(i), () => {
+      n.delete(i);
+    }) : (s.add(i), () => {
+      s.delete(i);
+    }),
+    dev_get_mounted_atoms: () => r.values(),
+    dev_get_atom_state: (i) => e.get(i),
+    dev_get_mounted: (i) => t.get(i),
+    dev_restore_atoms: (i) => {
+      for (const [g, f] of i)
+        de(g) && (m(g, f), D(g));
+      const a = V();
+      s.forEach(
+        (g) => g({ type: "restore", flushed: a })
+      );
+    }
+  } : {
+    get: U,
+    set: S,
+    sub: T
+  };
+};
+let fe;
+const bt = () => (fe || (fe = kt()), fe);
+var Be = { VITE_OPENAI_API_KEY: "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", VITE_UNSPASH_ACCESS_KEY: "XgYBCm-XCHecRMsbfhw6oZWGkltco1U5TYMEd0LXZeA", BASE_URL: "/", MODE: "production", DEV: !1, PROD: !0, SSR: !1 };
+const Te = Symbol(), Ce = (e, t, o) => (t.has(o) ? t : t.set(o, e())).get(o), _t = /* @__PURE__ */ new WeakMap(), At = (e, t, o) => {
+  const n = Ce(() => /* @__PURE__ */ new WeakMap(), _t, t);
+  return Ce(e, n, o);
+}, St = {}, Oe = (e) => !!e.write, wt = (e) => typeof e == "function";
+function Et(e, t) {
+  return At(
+    () => {
+      const o = /* @__PURE__ */ new WeakMap(), n = (c, u) => {
+        let d = o.get(c);
+        if (d)
+          return d;
+        const l = u && o.get(u), m = [], I = [];
+        return c.forEach((F, U) => {
+          const B = t ? t(F) : U;
+          I[U] = B;
+          const A = l && l.atomList[l.keyList.indexOf(B)];
+          if (A) {
+            m[U] = A;
+            return;
+          }
+          const L = (w) => {
+            const S = w(s), y = w(e), C = n(y, S == null ? void 0 : S.arr).keyList.indexOf(B);
+            if (C < 0 || C >= y.length) {
+              const V = c[n(c).keyList.indexOf(B)];
+              if (V)
+                return V;
+              throw new Error("splitAtom: index out of bounds for read");
+            }
+            return y[C];
+          }, D = (w, S, y) => {
+            const M = w(s), C = w(e), T = n(C, M == null ? void 0 : M.arr).keyList.indexOf(B);
+            if (T < 0 || T >= C.length)
+              throw new Error("splitAtom: index out of bounds for write");
+            const i = wt(y) ? y(C[T]) : y;
+            S(e, [
+              ...C.slice(0, T),
+              i,
+              ...C.slice(T + 1)
+            ]);
+          };
+          m[U] = Oe(e) ? R(L, D) : R(L);
+        }), l && l.keyList.length === I.length && l.keyList.every((F, U) => F === I[U]) ? d = l : d = { arr: c, atomList: m, keyList: I }, o.set(c, d), d;
+      }, s = R((c) => {
+        const u = c(s), d = c(e);
+        return n(d, u == null ? void 0 : u.arr);
+      });
+      (Be ? "production" : void 0) !== "production" && (s.debugPrivate = !0), s.init = void 0;
+      const r = Oe(e) ? R(
+        (c) => c(s).atomList,
+        (c, u, d) => {
+          switch (d.type) {
+            case "remove": {
+              const l = c(r).indexOf(d.atom);
+              if (l >= 0) {
+                const m = c(e);
+                u(e, [
+                  ...m.slice(0, l),
+                  ...m.slice(l + 1)
+                ]);
+              }
+              break;
+            }
+            case "insert": {
+              const l = d.before ? c(r).indexOf(d.before) : c(r).length;
+              if (l >= 0) {
+                const m = c(e);
+                u(e, [
+                  ...m.slice(0, l),
+                  d.value,
+                  ...m.slice(l)
+                ]);
+              }
+              break;
+            }
+            case "move": {
+              const l = c(r).indexOf(d.atom), m = d.before ? c(r).indexOf(d.before) : c(r).length;
+              if (l >= 0 && m >= 0) {
+                const I = c(e);
+                l < m ? u(e, [
+                  ...I.slice(0, l),
+                  ...I.slice(l + 1, m),
+                  I[l],
+                  ...I.slice(m)
+                ]) : u(e, [
+                  ...I.slice(0, m),
+                  I[l],
+                  ...I.slice(m, l),
+                  ...I.slice(l + 1)
+                ]);
+              }
+              break;
+            }
+          }
+        }
+      ) : R((c) => c(s).atomList);
+      return r;
+    },
+    e,
+    t || St
+  );
+}
+function So(e) {
+  const t = Symbol(), o = R(t);
+  (Be ? "production" : void 0) !== "production" && (o.debugPrivate = !0);
+  const n = R(
+    (s, r) => {
+      const c = s(o);
+      return c !== t ? c : e(s, r);
+    },
+    (s, r, c) => {
+      if (c === Te)
+        r(o, t);
+      else if (typeof c == "function") {
+        const u = s(n);
+        r(o, c(u));
+      } else
+        r(o, c);
+    }
+  );
+  return n;
+}
+const yt = (e) => typeof (e == null ? void 0 : e.then) == "function";
+function Pt(e) {
+  let t, o;
+  const n = {
+    getItem: (s, r) => {
+      var c, u;
+      const d = (m) => {
+        if (m = m || "", t !== m) {
+          try {
+            o = JSON.parse(m);
+          } catch {
+            return r;
+          }
+          t = m;
+        }
+        return o;
+      }, l = (u = (c = e()) == null ? void 0 : c.getItem(s)) != null ? u : null;
+      return yt(l) ? l.then(d) : d(l);
+    },
+    setItem: (s, r) => {
+      var c;
+      return (c = e()) == null ? void 0 : c.setItem(s, JSON.stringify(r));
+    },
+    removeItem: (s) => {
+      var r;
+      return (r = e()) == null ? void 0 : r.removeItem(s);
+    }
+  };
+  return typeof window < "u" && typeof window.addEventListener == "function" && (n.subscribe = (s, r, c) => {
+    if (!(e() instanceof window.Storage))
+      return () => {
+      };
+    const u = (d) => {
+      if (d.storageArea === e() && d.key === s) {
+        let l;
+        try {
+          l = JSON.parse(d.newValue || "");
+        } catch {
+          l = c;
+        }
+        r(l);
+      }
+    };
+    return window.addEventListener("storage", u), () => {
+      window.removeEventListener("storage", u);
+    };
+  }), n;
+}
+const Lt = Pt(
+  () => typeof window < "u" ? window.localStorage : void 0
+);
+function It(e, t, o = Lt, n) {
+  const s = n == null ? void 0 : n.unstable_getOnInit, r = R(
+    s ? o.getItem(e, t) : t
+  );
+  return (Be ? "production" : void 0) !== "production" && (r.debugPrivate = !0), r.onMount = (u) => {
+    s || u(o.getItem(e, t));
+    let d;
+    return o.subscribe && (d = o.subscribe(e, u, t)), d;
+  }, R(
+    (u) => u(r),
+    (u, d, l) => {
+      const m = typeof l == "function" ? l(u(r)) : l;
+      return m === Te ? (d(r, t), o.removeItem(e)) : m instanceof Promise ? m.then((I) => (d(r, I), o.setItem(e, I))) : (d(r, m), o.setItem(e, m));
+    }
+  );
+}
+var Ct = { VITE_OPENAI_API_KEY: "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", VITE_UNSPASH_ACCESS_KEY: "XgYBCm-XCHecRMsbfhw6oZWGkltco1U5TYMEd0LXZeA", BASE_URL: "/", MODE: "production", DEV: !1, PROD: !0, SSR: !1 };
+const Ot = et(void 0), Fe = (e) => {
+  const t = nt(Ot);
+  return (e == null ? void 0 : e.store) || t || bt();
+}, Mt = (e) => typeof (e == null ? void 0 : e.then) == "function", xt = Qe.use || ((e) => {
+  if (e.status === "pending")
+    throw e;
+  if (e.status === "fulfilled")
+    return e.value;
+  throw e.status === "rejected" ? e.reason : (e.status = "pending", e.then(
+    (t) => {
+      e.status = "fulfilled", e.value = t;
+    },
+    (t) => {
+      e.status = "rejected", e.reason = t;
+    }
+  ), e);
+});
+function Dt(e, t) {
+  const o = Fe(t), [[n, s, r], c] = tt(
+    (l) => {
+      const m = o.get(e);
+      return Object.is(l[0], m) && l[1] === o && l[2] === e ? l : [m, o, e];
+    },
+    void 0,
+    () => [o.get(e), o, e]
+  );
+  let u = n;
+  (s !== o || r !== e) && (c(), u = o.get(e));
+  const d = t == null ? void 0 : t.delay;
+  return le(() => {
+    const l = o.sub(e, () => {
+      if (typeof d == "number") {
+        setTimeout(c, d);
+        return;
+      }
+      c();
+    });
+    return c(), l;
+  }, [o, e, d]), ot(u), Mt(u) ? xt(u) : u;
+}
+function Tt(e, t) {
+  const o = Fe(t);
+  return N(
+    (...s) => {
+      if ((Ct ? "production" : void 0) !== "production" && !("write" in e))
+        throw new Error("not writable atom");
+      return o.set(e, ...s);
+    },
+    [o, e]
+  );
+}
+function ie(e, t) {
+  return [
+    Dt(e, t),
+    // We do wrong type assertion here, which results in throwing an error.
+    Tt(e, t)
+  ];
+}
+function Re(e, t, o) {
+  const n = H(e, (r) => r._parent === t), s = [];
+  for (let r = 0; r < n.length; r++) {
+    const c = Ue(n[r]);
+    if (Object.keys(c).length > 0 && Object.keys(c).forEach((u) => {
+      n[r][u] = `slot:${re()}`;
+    }), H(e, { _parent: n[r]._id }).length > 0) {
+      const u = re();
+      s.push({ ...n[r], oldId: n[r]._id, _id: u, _parent: o }), s.push(Y(Re(e, n[r]._id, u)));
+    } else
+      s.push({
+        ...n[r],
+        oldId: n[r]._id,
+        _id: re(),
+        _parent: o
+      });
+  }
+  return Y(s);
+}
+function Ne(e) {
+  const t = {};
+  e.forEach((n) => {
+    t[n._id] = { ...n, children: [] };
+  });
+  const o = [];
+  return e.forEach((n) => {
+    if (n._parent) {
+      const s = t[n._parent];
+      s && s.children.push(t[n._id]);
+    } else
+      o.push(t[n._id]);
+  }), o;
+}
+const Ue = (e) => {
+  const t = {};
+  return Object.keys(e).forEach((o) => {
+    xe(e[o]) && e[o].startsWith("slot") && (t[o] = e[o].replace("slot:", ""));
+  }), t;
+}, wo = (e, t, o = null) => {
+  let n = Q(e, { _id: t });
+  n = { ...n, oldId: n._id, _id: re() }, o && (n = { ...n, _parent: o });
+  const s = [n];
+  H(e, { _parent: t }).length > 0 && s.push(Y(Re(e, t, n._id)));
+  const r = Y(s);
+  return x(r, (c) => {
+    const u = c, d = Ue(u);
+    return Object.keys(d).length > 0 && Object.keys(d).forEach((l) => {
+      const m = Q(r, { oldId: d[l].replace("slot:", "") });
+      u[l] = `slot:${m._id}`;
+    }), ue(u, ["global", "oldId"]);
+  });
+}, X = P([]);
+X.debugLabel = "presentBlocksAtom";
+const Ft = P((e) => {
+  const t = e(X);
+  return Ne([...t]);
+});
+Ft.debugLabel = "treeDSBlocks";
+X.debugLabel = "presentBlocksAtom";
+const Rt = Et(X);
+Rt.debugLabel = "pageBlocksAtomsAtom";
+const Nt = P("");
+Nt.debugLabel = "builderActivePageAtom";
+const Ut = P(-1);
+Ut.debugLabel = "destinationDropIndexAtom";
+const Ve = P([]);
+Ve.debugLabel = "buildingBlocksAtom";
+const Vt = P((e) => {
+  const t = e(Ve);
+  return H(t, (o) => De(o, "blockId"));
+});
+Vt.debugLabel = "globalBlocksAtom";
+const ke = P([]);
+ke.debugLabel = "selectedBlockIdsAtom";
+const be = P((e) => {
+  const t = e(X), o = e(ke);
+  return x(
+    H(t, ({ _id: n }) => ee(o, n)),
+    (n) => ({ ...n })
+  );
+});
+be.debugLabel = "selectedBlocksAtom";
+const _e = P((e) => {
+  const t = e(be);
+  if (t.length === 0)
+    return null;
+  if (t.length === 1)
+    return t[0];
+});
+_e.debugLabel = "selectedBlockAtom";
+const jt = (e) => $(e, "_parent", null), Gt = P((e) => {
+  const t = e(be), o = x(t, jt);
+  return H(e(X), (n) => ee(o, n._id));
+});
+Gt.debugLabel = "selectedBlocksParentsAtom";
+const je = P(() => !1);
+je.debugLabel = "selectedBlockFlexChildAtom";
+const Ge = P(() => !1);
+Ge.debugLabel = "selectedBlockGridChildAtom";
+const Yt = P("");
+Yt.debugLabel = "styleStateAtom";
+const Ht = It("styleBreakpoint", "xs");
+Ht.debugLabel = "styleBreakpointAtom";
+const Eo = () => ({
+  flexChild: J(je),
+  gridChild: J(Ge)
+}), yo = () => J(_e), Xt = P((e) => {
+  const t = e(_e), o = e(X);
+  let n = t;
+  const s = [t];
+  do {
+    const r = o.find(({ _id: c }) => c === (n == null ? void 0 : n._parent));
+    n = r, r && s.push(r);
+  } while (n != null && n._parent);
+  return s;
+}), Po = () => it(J(Xt)), Wt = () => {
+  const [e, t] = W(ke), o = N(
+    (n) => {
+      t((s) => ee(s, n) ? ct(s, n) : [...s, n]);
+    },
+    [t]
+  );
+  return [e, t, o];
+};
+var Ye = { exports: {} };
+(function(e) {
+  (function() {
+    function t(n, s, r) {
+      return n.splice(
+        s,
+        !r || 1 + r - s + (!(r < 0 ^ s >= 0) && (r < 0 || -1) * n.length)
+      ), n.length;
+    }
+    let o = function() {
+      let n = [], s = -1, r = 0, c = !1, u;
+      function d(l, m) {
+        return !l || typeof l[m] != "function" ? this : (c = !0, l[m](), c = !1, this);
+      }
+      return {
+        /**
+         * Adds a command to the queue.
+         * @property {object} command           - Command
+         * @property {function} command.undo    - Undo function
+         * @property {function} command.redo    - Redo function
+         * @property {string} [command.groupId] - Optional group id
+         */
+        add: function(l) {
+          return c ? this : (n.splice(s + 1, n.length - s), n.push(l), r && n.length > r && t(n, 0, -(r + 1)), s = n.length - 1, u && u(), this);
+        },
+        /**
+         * Pass a function to be called on undo and redo actions.
+         * @property {function} callbackFunc - Callback function
+         */
+        setCallback: function(l) {
+          u = l;
+        },
+        /**
+         * Performs undo: call the undo function at the current index and decrease the index by 1.
+         */
+        undo: function() {
+          let l = n[s];
+          if (!l)
+            return this;
+          const m = l.groupId;
+          for (; l.groupId === m && (d(l, "undo"), s -= 1, l = n[s], !(!l || !l.groupId)); )
+            ;
+          return u && u(), this;
+        },
+        /**
+         * Performs redo: call the redo function at the next index and increase the index by 1.
+         */
+        redo: function() {
+          let l = n[s + 1];
+          if (!l)
+            return this;
+          const m = l.groupId;
+          for (; l.groupId === m && (d(l, "redo"), s += 1, l = n[s + 1], !(!l || !l.groupId)); )
+            ;
+          return u && u(), this;
+        },
+        /**
+         * Clears the memory, losing all stored states. Resets the index.
+         */
+        clear: function() {
+          let l = n.length;
+          n = [], s = -1, u && l > 0 && u();
+        },
+        /**
+         * Tests if any undo actions exist.
+         * @returns {boolean}
+         */
+        hasUndo: function() {
+          return s !== -1;
+        },
+        /**
+         * Tests if any redo actions exist.
+         * @returns {boolean}
+         */
+        hasRedo: function() {
+          return s < n.length - 1;
+        },
+        /**
+         * Returns the list of queued commands.
+         * @param {string} [groupId] - Optionally filter commands by group ID
+         * @returns {array}
+         */
+        getCommands: function(l) {
+          return l ? n.filter((m) => m.groupId === l) : n;
+        },
+        /**
+         * Returns the index of the actions list.
+         * @returns {number}
+         */
+        getIndex: function() {
+          return s;
+        },
+        /**
+         * Sets the maximum number of undo steps. Default: 0 (unlimited).
+         * @property {number} max - Maximum number of undo steps
+         */
+        setLimit: function(l) {
+          r = l;
+        }
+      };
+    };
+    e.exports ? e.exports = o : window.UndoManager = o;
+  })();
+})(Ye);
+var zt = Ye.exports;
+const Jt = /* @__PURE__ */ ft(zt), Lo = [
+  "hover",
+  "focus",
+  "focus-within",
+  "focus-visible",
+  "active",
+  "visited",
+  "target",
+  "first",
+  "last",
+  "only",
+  "odd",
+  "even",
+  "first-of-type",
+  "last-of-type",
+  "only-of-type",
+  "empty",
+  "disabled",
+  "checked",
+  "indeterminate",
+  "default",
+  "required",
+  "valid",
+  "invalid",
+  "in-range",
+  "out-of-range",
+  "placeholder-shown",
+  "autofill",
+  "read-only",
+  "open",
+  "before",
+  "after",
+  "first-letter",
+  "first-line",
+  "marker",
+  "selection",
+  "file",
+  "placeholder",
+  // preline
+  "hs-collapse-open",
+  "hs-accordion-active"
+], me = {
+  bodyFont: "Inter",
+  headingFont: "Inter",
+  roundedCorners: 5,
+  primaryColor: "#570df8",
+  secondaryColor: "#f002b8",
+  bodyBgDarkColor: "#031022",
+  bodyBgLightColor: "#fcfcfc",
+  bodyTextDarkColor: "#ffffff",
+  bodyTextLightColor: "#000000"
+}, $t = P(me), Zt = P(null), He = () => {
+  const [e, t] = W($t);
+  return [
+    lt(e) ? { ...me, ...e } : me,
+    t
+  ];
+}, Io = () => W(Zt), Kt = P(null), qt = () => ({ currentPage: J(Kt) });
+function Xe(e) {
+  return Ne(e);
+}
+const Ae = (e, t) => Y(
+  e.map((o) => {
+    if (o = t ? { ...o, _parent: t } : { ...o }, o.children) {
+      const n = [...o.children];
+      return delete o.children, Y([o, ...Ae(n, o._id)]);
+    }
+    return o;
+  })
+);
+function Se(e, t = !1) {
+  for (let o = 0; o < e.length; o++) {
+    const n = e[o];
+    n.global && !t ? e[o] = {
+      type: "GlobalBlock",
+      blockId: n.blockId,
+      _parent: $(n, "_parent", null),
+      _id: n._id
+    } : n.children && n.children.length && Se(n.children);
+  }
+}
+function We(e) {
+  let t = [], o = H(e, { type: "GlobalBlock" });
+  return o.length > 0 && (o = x(o, ze), q(o, (n) => {
+    t = [...t, ...Qt(n)];
+  })), t;
+}
+function Qt(e) {
+  let t = [];
+  const o = $(te(e), "_parent", null);
+  pe(te(e), "_parent", null);
+  const n = [flatToNestedInstance.convert(Je(e))];
+  Se(n, !0);
+  let s = Ae(n, e[0]._id);
+  return s = pe(s, "0._parent", o), t = [...t, s, ...We(s)], t;
+}
+function ze(e) {
+  const t = Q(ve, { _id: e._id });
+  if (!t)
+    return [];
+  const o = [t], n = H(ve, { _parent: e._id });
+  return n.length ? Y([...o, ...Y(x(n, ze))]) : Y(o);
+}
+const Je = (e) => JSON.parse(JSON.stringify(e));
+let ve = [];
+function eo(e) {
+  ve = e;
+  const t = Xe(Je(e));
+  Se(t);
+  const o = Ae(t, null), n = We(o), s = {};
+  return q(n, (r) => pe(s, te(r).blockId, r)), [o, s];
+}
+const to = () => {
+  const [e] = He(), { currentPage: t } = qt(), [o] = ne();
+  return N(() => {
+    const n = x(
+      o,
+      (r) => ue(r, ["expanded", "order", "title", "siblings", "tempClasses"])
+    ), [s = []] = eo(n);
+    return {
+      currentPage: t,
+      blocks: s
+    };
+  }, [e, t, o]);
+}, $e = P(null);
+$e.debugLabel = "chaiBuilderPropsAtom";
+const oo = P({});
+oo.debugLabel = "chaiExternalDataAtom";
+const oe = (e, t = void 0) => {
+  const o = J($e);
+  return $(o, e, t);
+}, Ze = P([]);
+Ze.debugLabel = "dataProvidersAtom";
+const no = () => W(Ze), we = P("SAVED");
+we.debugLabel = "builderSaveStateAtom";
+const Co = () => {
+  const [e, t] = W(we), o = oe("onSave", async (d) => {
+  }), n = oe("onSaveStateChange", ge), s = to(), [r] = no(), [c] = He();
+  return { savePage: pt(
+    async () => {
+      t("SAVING"), n("SAVING");
+      const d = s();
+      return await o({ blocks: d.blocks, providers: r, brandingOptions: c, themeConfiguration: c }), setTimeout(() => {
+        t("SAVED"), n("SAVED");
+      }, 100), !0;
+    },
+    [s, t, c, o, n],
+    3e3
+    // save only every 5 seconds
+  ), saveState: e, setSaveState: t };
+}, G = new Jt();
+G.setLimit(50);
+const so = () => {
+  const [, e] = W(we), t = oe("onSaveStateChange", ge);
+  return le(() => (G.setCallback(() => {
+    e("UNSAVED"), t("UNSAVED");
+  }), () => {
+    G.setCallback(ge);
+  }), []), {
+    add: G.add,
+    undo: G.undo,
+    redo: G.redo,
+    hasRedo: G.hasRedo,
+    hasUndo: G.hasUndo,
+    clear: G.clear
+  };
+}, Ee = (e, t) => {
+  const o = [], n = H(e, (s) => ee(t, s._id) || ee(t, s._parent) ? (o.push(s._id), !1) : !0);
+  return ut(o) ? n : Ee(n, o);
+}, Oo = () => {
+  const [e] = ne(), [t, o] = Wt(), { setNewBlocks: n } = Z();
+  return N(
+    (s) => {
+      var c;
+      const r = ((c = Q(e, { _id: s[0] })) == null ? void 0 : c._parent) || null;
+      n(Ee(e, s)), setTimeout(() => o(r ? [r] : []), 200);
+    },
+    [e, o, t]
+  );
+};
+function ro(e, t, o, n) {
+  let s = e.filter((u) => !u._parent);
+  o && (s = e.filter((u) => u._parent === o));
+  const r = n !== void 0 ? n : s.length;
+  let c = e.length;
+  for (let u = 0, d = 0; u < e.length; u++)
+    if (e[u]._parent === o) {
+      if (d === r) {
+        c = u;
+        break;
+      }
+      d++;
+    }
+  return !o && n !== void 0 && n >= s.length && (c = e.length), [...e.slice(0, c), ...t, ...e.slice(c)];
+}
+function co(e) {
+  let t = [];
+  return e.walk((o) => (delete o.model.children, t.push(o.model), !0)), t;
+}
+function Me(e, t) {
+  return e.first((o) => o.model._id === t) || null;
+}
+function io(e, t, o, n) {
+  const s = Me(e, t), r = Me(e, o);
+  if (s && r) {
+    s.drop(), r.children || (r.model.children = []);
+    try {
+      r.addChildAtIndex(s, n);
+    } catch (c) {
+      return console.error("Error adding child to parent:", c), !1;
+    }
+    return !0;
+  }
+  return !1;
+}
+function lo(e, t, o, n) {
+  if (!t)
+    return e;
+  o = o || "root";
+  const r = new gt().parse({ _id: "root", children: Xe(e) });
+  if (io(r, t, o, n)) {
+    const c = co(r), u = c.find((d) => d._id === t);
+    return u && (u._parent = o === "root" ? null : o), c.shift(), c;
+  }
+  return e;
+}
+const uo = () => {
+  const [, e] = ne();
+  return {
+    setNewBlocks: (t) => {
+      e(t);
+    },
+    addBlocks: (t, o, n) => {
+      e((s) => ro(s, t, o, n));
+    },
+    removeBlocks: (t) => {
+      e((o) => Ee(o, t));
+    },
+    moveBlocks: (t, o, n) => {
+      e((s) => {
+        let r = s;
+        for (let c = 0; c < t.length; c++)
+          r = lo(r, t[c], o, n);
+        return r;
+      });
+    },
+    updateBlocksProps: (t) => {
+      e((o) => {
+        const n = t.map((s) => s._id);
+        return o.map((s) => {
+          if (n.includes(s._id)) {
+            const r = Q(t, { _id: s._id });
+            return { ...s, ...ue(r, "_id") };
+          }
+          return s;
+        });
+      });
+    }
+  };
+}, ne = () => W(X), Z = () => {
+  const { add: e } = so(), [t] = ne(), {
+    setNewBlocks: o,
+    addBlocks: n,
+    removeBlocks: s,
+    moveBlocks: r,
+    updateBlocksProps: c
+  } = uo();
+  return {
+    moveBlocks: (B, A, L) => {
+      const D = x(B, (S) => {
+        const M = t.find((T) => T._id === S)._parent || null, V = t.filter((T) => M ? T._parent === M : !T._parent).map((T) => T._id).indexOf(S);
+        return { _id: S, oldParent: M, oldPosition: V };
+      }), w = D.find(({ _id: S }) => S === B[0]);
+      w && w.oldParent === A && w.oldPosition === L || (r(B, A, L), e({
+        undo: () => q(D, ({ _id: S, oldParent: y, oldPosition: M }) => {
+          r([S], y, M);
+        }),
+        redo: () => r(B, A, L)
+      }));
+    },
+    addBlocks: (B, A, L) => {
+      n(B, A, L), e({
+        undo: () => s(x(B, "_id")),
+        redo: () => n(B, A, L)
+      });
+    },
+    removeBlocks: (B) => {
+      var w;
+      const A = (w = te(B)) == null ? void 0 : w._parent, D = t.filter((S) => A ? S._parent === A : !S._parent).indexOf(te(B));
+      s(x(B, "_id")), e({
+        undo: () => n(B, A, D),
+        redo: () => s(x(B, "_id"))
+      });
+    },
+    updateBlocks: (B, A, L) => {
+      let D = [];
+      if (L)
+        D = x(B, (w) => ({ _id: w, ...L }));
+      else {
+        const w = he(A);
+        D = x(B, (S) => {
+          const y = t.find((C) => C._id === S), M = { _id: S };
+          return q(w, (C) => M[C] = y[C]), M;
+        });
+      }
+      c(x(B, (w) => ({ _id: w, ...A }))), e({
+        undo: () => c(D),
+        redo: () => c(x(B, (w) => ({ _id: w, ...A })))
+      });
+    },
+    updateBlocksRuntime: (B, A) => {
+      c(x(B, (L) => ({ _id: L, ...A })));
+    },
+    setNewBlocks: (B) => {
+      o(B), e({
+        undo: () => o(t),
+        redo: () => o(B)
+      });
+    },
+    updateMultipleBlocksProps: (B) => {
+      let A = [];
+      A = x(B, (L) => {
+        const D = he(L), w = t.find((y) => y._id === L._id), S = {};
+        return q(D, (y) => S[y] = w[y]), S;
+      }), c(B), e({
+        undo: () => c(A),
+        redo: () => c(B)
+      });
+    }
+  };
+}, Mo = () => {
+  const { updateBlocks: e } = Z();
+  return N(
+    (t, o, n) => {
+      e(t, o, n);
+    },
+    [e]
+  );
+}, xo = () => {
+  const { updateMultipleBlocksProps: e } = Z();
+  return N(
+    (t) => {
+      e(t);
+    },
+    [e]
+  );
+}, ao = () => {
+  const { updateBlocksRuntime: e } = Z();
+  return N(
+    async (t, o, n = 30) => {
+      const s = he(ue(o, ["_id"]));
+      for (const r of s) {
+        const c = o[r];
+        if (xe(c)) {
+          const u = dt(c.split(""), 12);
+          let d = "";
+          e([t], { [r]: "" });
+          for (let l = 0; l < u.length; l++)
+            d += u[l].join(""), e([t], { [r]: d }), await new Promise((m) => setTimeout(m, n));
+        }
+      }
+    },
+    [e]
+  );
+}, Do = () => {
+  const { updateMultipleBlocksProps: e } = Z(), t = ao();
+  return N(
+    async (o) => {
+      for (const n of o)
+        await t(n._id, n);
+      e(o);
+    },
+    [e]
+  );
+}, To = () => {
+  const { updateBlocksRuntime: e } = Z();
+  return N(
+    (t, o) => {
+      e(t, o);
+    },
+    [e]
+  );
+}, Ke = R({}), fo = R({}), Fo = () => {
+  const [e, t] = ie(Ke), o = N(
+    (s) => $(e, s == null ? void 0 : s.globalBlock, []),
+    [e]
+  ), n = N(() => {
+    t({});
+  }, [t]);
+  return { getGlobalBlocks: o, reset: n };
+}, Ro = () => {
+  const [e] = ne(), [t, o] = ie(Ke), [n, s] = ie(fo), r = oe("getGlobalBlockBlocks", async (u) => []), c = rt(() => e.filter((d) => d._type === "GlobalBlock").filter((d) => d._type === "GlobalBlock").map((d) => d.globalBlock), [e]);
+  le(() => {
+    at(c, (u) => {
+      De(t, u) || $(n, `${u}.loading`, !1) || (s((d) => ({ ...d, [u]: { loading: !0, error: null } })), r(u).then((d) => {
+        o((l) => ({ ...l, [u]: d })), s((l) => ({
+          ...l,
+          [u]: { loading: !1, error: null }
+        }));
+      }).catch((d) => {
+        s((l) => ({
+          ...l,
+          [u]: { loading: !1, error: d.message }
+        }));
+      }));
+    });
+  }, [
+    r,
+    t,
+    c,
+    n,
+    o,
+    s
+  ]);
+}, po = R({}), No = () => {
+  const [e, t] = st(!1), [o, n] = ie(po), s = oe("getGlobalBlocks", async () => []), r = N(async () => {
+    t(!0);
+    const c = await s();
+    n(c), t(!1);
+  }, [s, n]);
+  return le(() => {
+    r();
+  }, []), { data: o, isLoading: e, refetch: r };
+};
+export {
+  Eo as A,
+  Fe as B,
+  R as C,
+  So as D,
+  Dt as E,
+  Tt as F,
+  kt as G,
+  we as H,
+  Ro as I,
+  $e as J,
+  Ze as K,
+  Co as L,
+  Lo as M,
+  No as N,
+  qt as O,
+  Wt as a,
+  Z as b,
+  It as c,
+  X as d,
+  _e as e,
+  Yt as f,
+  wo as g,
+  so as h,
+  ie as i,
+  Fo as j,
+  oe as k,
+  Mo as l,
+  Oo as m,
+  He as n,
+  oo as o,
+  Rt as p,
+  no as q,
+  yo as r,
+  Ht as s,
+  Po as t,
+  ne as u,
+  Io as v,
+  Ft as w,
+  To as x,
+  Do as y,
+  xo as z
+};