@fragmentsx/client-core 0.0.1

package/dist/index.es.js

@@ -0,0 +1,1862 @@
+var t = (e) => !e && e == null, s = (e) => !t(e), y = (e) => typeof e == "object" && !Array.isArray(e) && s(e), a = (e) => typeof Node == "object" ? e instanceof Node : e && typeof e == "object" && typeof e.nodeType == "number" && typeof e.nodeName == "string", p = (e) => typeof e == "string" || n(e), n = (e) => typeof e == "object" && typeof e._type == "string", r = (e) => typeof e == "string" && e.split(":").length >= 2, i = (e) => typeof e != "object" && typeof e != "function" || e === null, b = (e) => typeof e == "string" ? /<\/?[a-z][\s\S]*>/i.test(e) : false;
+var G = (t2) => r(t2), te = (t2) => p(t2), ne = (t2) => n(t2), S = (t2) => y(t2), re = (t2, s2) => {
+  if (t2 === s2) return true;
+  if (Array.isArray(t2) && Array.isArray(s2)) return t2.length === s2.length && t2.every((a2, h) => s2[h] === a2);
+  if (!S(t2) || !S(s2)) return false;
+  let p2 = Object.keys(t2), c = Object.keys(s2);
+  if (p2.length !== c.length) return false;
+  for (let a2 of p2) {
+    if (!c.includes(a2)) return false;
+    let h = t2[a2], l = s2[a2];
+    if (i(h) && i(l) && h !== l) return false;
+  }
+  return true;
+}, W = (t2, s2) => {
+  if (t2 === s2) return true;
+  if (Array.isArray(t2) && Array.isArray(s2)) return t2.length === s2.length && t2.every((a2, h) => W(a2, s2[h]));
+  if (!S(s2) || !S(t2)) return t2 === s2;
+  let p2 = Object.keys(t2), c = Object.keys(s2);
+  if (p2.length !== c.length) return false;
+  for (let a2 of p2) if (!c.includes(a2) || !W(t2[a2], s2[a2])) return false;
+  return true;
+};
+var z = (...t2) => Array.from(new Set(t2)), se = (...t2) => t2.filter((s2, p2, c) => r(s2) ? c.indexOf(s2) === p2 : true);
+var I = (t2) => t2 && t2.split(".").length > 1, Y = (t2, s2) => {
+  if (!t2 || !s2) return false;
+  if (typeof t2 != "string" || typeof s2 != "string") return null;
+  let [p2, c] = t2.split(":"), [a2, h] = s2.split(":");
+  return p2 !== a2 ? false : c.startsWith(h);
+}, ie = (t2) => G(t2) && I(t2) ? t2.split(".")[0] : t2;
+var oe = () => {
+  let t2 = /* @__PURE__ */ new Map(), s2 = /* @__PURE__ */ new Map(), p2 = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), a2 = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Set([]), O = (n2, g) => {
+    var _a;
+    c.set(n2, z(...c.get(n2) || [], g)), a2.set(g, z(...a2.get(g) ?? [], n2)), M(n2, ((_a = c.get(n2)) == null ? void 0 : _a.length) || 0);
+  }, q = (n2, g) => {
+    var _a;
+    c.set(g, (c.get(g) || []).filter((k) => k !== n2)), a2.set(n2, (a2.get(n2) ?? []).filter((k) => k !== g)), M(g, ((_a = c.get(g)) == null ? void 0 : _a.length) || 0);
+  }, T = (n2, g = []) => {
+    let k = c.get(n2) || [];
+    g.push(...k);
+    let x = k.map((E) => T(E, g)).flat();
+    return g.push(...x), Array.from(new Set(g).values());
+  }, V = (n2) => {
+    M(n2, 0), B();
+  }, P = (n2) => n2 ? p2.get(n2) : null, R = (n2, g, k) => {
+    var _a;
+    if (typeof n2 == "string") {
+      p2.set(n2, g);
+      let [x] = n2.split(":");
+      I(n2) || (s2.has(x) ? (_a = s2.get(x)) == null ? void 0 : _a.add(n2) : s2.set(x, /* @__PURE__ */ new Set([n2])));
+    }
+    k && n2 && n2 !== k && O(n2, k);
+  }, _ = (n2) => n2 ? p2.has(n2) : false, M = (n2, g) => {
+    if (Array.isArray(n2)) n2.forEach((k, x) => M(k, x));
+    else {
+      let k = h.get(n2);
+      h.set(n2, g), g ? !k && g && l.delete(n2) : l.add(n2);
+    }
+  }, $ = () => Array.from(p2.entries()), j = (n2) => h.get(n2) ?? 0, B = () => {
+    var _a, _b;
+    for (let n2 of l.keys()) {
+      if (j(n2) > 0) continue;
+      let k = p2.get(n2);
+      l.delete(n2), p2.delete(n2), h.delete(n2);
+      let x = c.get(n2) ?? [], E = a2.get(n2) ?? [];
+      x.forEach((A) => {
+        var _a2, _b2;
+        a2.set(A, ((_b2 = (_a2 = a2.get(A)) == null ? void 0 : _a2.filter) == null ? void 0 : _b2.call(_a2, (U) => U !== n2)) ?? []);
+      }), E.forEach((A) => {
+        M(A, j(A) - 1);
+      });
+      let [C] = n2.split(":");
+      I(n2) || ((_a = s2.get(C)) == null ? void 0 : _a.delete(n2), ((_b = s2.get(C)) == null ? void 0 : _b.size) || s2.delete(C)), c.delete(n2), (t2.get("onRemoveLink") ?? []).forEach((A) => A(n2, k ?? null));
+    }
+  };
+  return { readLink: P, writeLink: R, hasLink: _, getLinkEntries: $, parentRefs: c, childrenRefs: a2, addRefs: O, removeRefs: q, getChildren: (n2) => a2.get(n2), getParents: (n2) => c.get(n2), getLinkedRefs: T, invalidate: V, links: p2, types: s2, refCount: h, runGarbageCollector: B, onRemoveLink: (n2) => t2.set("onRemoveLink", [...(t2 == null ? void 0 : t2.get("onRemoveLink")) ?? [], n2]) };
+};
+var J = (...t2) => {
+  var _a;
+  return (_a = t2 == null ? void 0 : t2.filter(Boolean)) == null ? void 0 : _a.join(".");
+};
+var ae = process.env.NODE_ENV !== "production";
+var ce = (t2 = []) => {
+  let s2 = [], p2 = (a2) => {
+    s2.push(a2);
+  }, c = (a2) => s2.reduce((h, l) => l(h) ?? h, a2);
+  return t2.forEach(p2), { use: p2, runPlugins: c };
+};
+var le = (t2) => t2 && S(t2) ? ["_id", "_type", "key", "mutate", "resolve"].every((p2) => p2 in t2) : false;
+var ue = () => {
+  let t2 = /* @__PURE__ */ new Set();
+  return { debug: (c) => {
+    t2.forEach((a2) => {
+      a2({ ...c, timestamp: Date.now() });
+    });
+  }, onDebugEvent: (c) => {
+    t2.add(c);
+  } };
+};
+var pe = () => Math.random().toString(16).slice(2);
+var De = 0, Se = 100, Ge = "State", fe = "$EACH:ROOT$", it = (t2) => {
+  let s$1 = (t2 == null ? void 0 : t2._id) ?? `${De++}`, p2 = (t2 == null ? void 0 : t2._type) ?? Ge, c = (t2 == null ? void 0 : t2.keys) ?? {}, a2 = `${p2}:${s$1}`, h = [le, ...(t2 == null ? void 0 : t2.skip) ?? []], l = oe(), O = ue(), q = ce(t2 == null ? void 0 : t2.plugins), T = /* @__PURE__ */ new Map(), V = 0, P = (e) => h.some((r2) => r2(e)), R = (e, r2) => {
+    let i2 = (r2 == null ? void 0 : r2.deep) ?? false, o = (r2 == null ? void 0 : r2.safe) ?? false, f = (r2 == null ? void 0 : r2.keepLinks) ?? false, { selector: m, ...d } = r2 || {}, y2 = s(e) ? E(e) : null;
+    O.debug({ type: "resolve", entity: e, options: r2 });
+    let u = y2 ? l.readLink(y2) : null;
+    return P(u) ? u : ((S(u) || Array.isArray(u)) && (u = Object.entries(u).reduce((L, [w, v]) => {
+      let K = v;
+      return P(K) || (Array.isArray(v) ? (K = v.map((D) => P(D) ? D : G(D) && !o && !l.hasLink(D) ? null : Y(D, y2) && !f || i2 ? _(D, d) : D), o || (K = K.filter(s))) : G(v) && !o && !l.hasLink(v) ? K = null : (Y(E(v), y2) && !f || i2) && (K = _(v, d))), L[w] = K, L;
+    }, {})), u ? m ? m({ ...u }) : { ...u } : o ? e : null);
+  }, _ = (e, r2) => R(e, r2) ?? e, M = (e) => {
+    let r2 = E(e);
+    r2 && (l.getChildren(r2) || []).forEach((o) => {
+      I(o) || l.removeRefs(r2, o);
+    });
+  }, $ = (e, r2, i$1) => {
+    var _a, _b, _c, _d;
+    if ((!e || i(e)) && !G(e) || P(e)) return e;
+    let o = te(e) ? E(e) : e;
+    if (G(o)) {
+      let y2 = ie(r2) ?? "", u = ((_a = i$1 == null ? void 0 : i$1.internal) == null ? void 0 : _a.visitors.get(y2)) ?? [], L = ((_b = i$1 == null ? void 0 : i$1.internal) == null ? void 0 : _b.visitors.get(o)) ?? [];
+      if (u.includes(o) || o === y2) return null;
+      (_d = (_c = i$1 == null ? void 0 : i$1.internal) == null ? void 0 : _c.visitors) == null ? void 0 : _d.set(o, [...L, y2]);
+    }
+    if (Array.isArray(e)) return e.map((y2) => {
+      let u = r2 ? J(r2, `${pe()}`) : void 0;
+      return $(y2, u, i$1);
+    });
+    let m = (G(e) ? e : ne(e) ? E(e) : null) ?? r2;
+    return ((i$1 == null ? void 0 : i$1.overrideMutateMethod) || j)(m, e, i$1);
+  }, j = (e, ...r2) => {
+    let { graphKey: i2, options: o, data: f } = A(e, ...r2);
+    O.debug({ type: "beforeMutate", entity: i2, data: f, options: o });
+    let m = G(f) ? C(f) : f, d = i2 ?? a2, y2 = I == null ? void 0 : I(d), u = o == null ? void 0 : o.parent, L = R(d ?? ""), w = (o == null ? void 0 : o.internal) || { hasChange: false, visitors: /* @__PURE__ */ new Map([]) }, v = { ...m, ...C(d) }, K = !(o == null ? void 0 : o.parent), D = (o == null ? void 0 : o.replace) ? typeof (o == null ? void 0 : o.replace) == "function" ? o.replace(v) : (o == null ? void 0 : o.replace) === "deep" ? true : K || y2 : false;
+    if (P(m)) return l.writeLink(d, m, u), d;
+    !D && S(L) && S(v) && (v = { ...L, ...v }), D && M(d);
+    let Q = Object.entries(v).reduce((X, [N, de]) => {
+      let Z = J(d, N), b2 = de, F = L == null ? void 0 : L[N], he = S(m) && N in m;
+      P(b2) || (!D && he && Array.isArray(b2) && Array.isArray(F) && (b2 = [...F, ...b2]), (S(b2) || Array.isArray(b2) || G(b2)) && (b2 = $(b2, Z, { ...o, parent: d, internal: w })), Array.isArray(b2) && (o == null ? void 0 : o.dedup) !== false && (b2 = se(...b2)));
+      let me = re(F, Z === b2 ? _(b2) : b2);
+      return w.hasChange = w.hasChange || !me, !D && G(F) && F !== b2 && l.removeRefs(d, F), X[N] = b2, X;
+    }, {});
+    return l.writeLink(d, Q, u), u || l.runGarbageCollector(), (w.hasChange || D) && n2(d, L), O.debug({ type: "afterMutate", entity: i2, data: f, nextData: Q, options: o, hasChange: w.hasChange }), d;
+  }, B = (e) => {
+    let r2 = E(e);
+    if (O.debug({ type: "invalidate", entity: r2 }), r2) {
+      let i2 = l.getParents(r2) || [];
+      l.invalidate(r2), i2.forEach((o) => {
+        let f = l.readLink(o), m = R(o, { safe: false, keepLinks: true });
+        l.writeLink(o, m), n2(o, f);
+      });
+    }
+  }, n2 = (e, r2) => {
+    if (V > Se) throw new Error("Too deep notify.");
+    let i2 = E(e);
+    if (O.debug({ type: "notify", entity: i2 }), i2) {
+      V++;
+      let o = [...T.get(i2) || [], ...T.get(fe) || []], f = l.getChildren(i2) || [], m = R(i2), d = (y2) => {
+        let u = m && (y2 == null ? void 0 : y2(m)), L = r2 && (y2 == null ? void 0 : y2(r2));
+        return { next: u, prev: L, hasChange: !W(u, L) };
+      };
+      o.forEach(({ callback: y2, selector: u }) => {
+        if (u) {
+          let { next: L, prev: w, hasChange: v } = d(u);
+          v && y2(L, w);
+        } else y2(m, r2);
+      }), f.forEach((y2) => n2(y2, r2));
+    }
+    V = 0;
+  }, g = (...e) => {
+    let r2 = typeof e[0] == "function" ? fe : e[0], i2 = typeof e[0] == "function" ? e[0] : e[1], o = typeof e[0] == "function" ? e[1] : e[2], f = E(r2), m = o == null ? void 0 : o.selector;
+    f && (T.has(f) ? T.set(f, [...Array.from(T.get(f) || []), { callback: i2, selector: m }]) : T.set(f, [{ callback: i2, selector: m }]), l.onRemoveLink((y2, u) => {
+      y2 === f && n2(f, u);
+    }));
+    let d = () => {
+      if (f) {
+        let y2 = (T.get(f) || []).findIndex((u) => u.callback === i2);
+        if (y2 !== -1) {
+          let u = T.get(f) || [];
+          u.splice(y2, 1), T.set(f, u);
+        }
+      }
+    };
+    return (o == null ? void 0 : o.signal) && o.signal.addEventListener("abort", d, { once: true }), d;
+  }, k = (e) => [...l.types.get(e) ?? []], x = (e) => {
+    let r2 = (typeof e == "string" ? e : E(e)) || "";
+    return (l.getParents(r2) ?? []).map((o) => R(o));
+  }, E = (e) => {
+    var _a;
+    if (typeof e == "string") return C(e) ? e : null;
+    if (!(e == null ? void 0 : e._type)) return null;
+    let r2 = null;
+    return e._type in c ? r2 = ((_a = c[e._type]) == null ? void 0 : _a.call(c, e)) ?? null : (s(e.id) || s(e._id)) && (r2 = `${e.id ?? e._id}`), r2 && `${e._type}:${r2}`;
+  }, C = (e) => {
+    if (S(e) && (e == null ? void 0 : e._type) && E(e)) return e;
+    if (!e || typeof e != "string") return null;
+    let [r2, ...i2] = e.split(":");
+    return !r2 || i2.length < 1 ? null : { _type: r2, _id: i2.join(":") };
+  }, A = (e, ...r2) => {
+    let i2 = typeof e == "string" ? r2[0] : e;
+    return typeof i2 == "function" ? i2 = i2(R(e)) : G(i2) && (i2 = C(i2)), { graphKey: typeof e == "string" ? e : E(e), options: typeof e == "string" ? r2[1] : r2[0], data: i2 };
+  };
+  function U(e) {
+    q.use(e), e(this);
+  }
+  let ye = (e) => {
+    h.push(e);
+  };
+  (t2 == null ? void 0 : t2.initialState) && j(t2.initialState, { replace: true });
+  let ge = { _type: p2, _id: s$1, key: a2, mutate: j, subscribe: g, resolve: R, safeResolve: _, resolveParents: x, inspectFields: k, invalidate: B, keyOfEntity: E, entityOfKey: C, getArgumentsForMutate: A, types: l.types, cache: l, use: U, addSkip: ye, subscribers: ae ? T : void 0, onDebugEvent: O.onDebugEvent };
+  return l.onRemoveLink((e, r2) => O.debug({ type: "garbageRemove", entity: e, prevValue: r2 })), q.runPlugins(ge);
+};
+const BASE_HEADERS = {
+  "Content-Type": "application/json"
+};
+const createFetcher = (baseUrl, defaultHeaders = {}) => {
+  const cache = /* @__PURE__ */ new Map();
+  const inflightRequests = /* @__PURE__ */ new Map();
+  const getCacheKey = (query2, variables, options) => JSON.stringify({ query: query2, variables, options });
+  const query = async (query2, variables = {}, options = {}) => {
+    const cacheKey = getCacheKey(query2, variables, options);
+    if (cache.has(cacheKey)) {
+      return cache.get(cacheKey);
+    }
+    if (inflightRequests.has(cacheKey)) {
+      return inflightRequests.get(cacheKey);
+    }
+    const request = fetch(baseUrl, {
+      ...options,
+      method: "POST",
+      body: JSON.stringify({ query: query2, variables }),
+      headers: {
+        ...BASE_HEADERS,
+        ...defaultHeaders,
+        ...options.headers
+      }
+    }).then(async (res) => {
+      if (!res.ok) throw new Error(`Fetch error: ${res.status}`);
+      const data = await res.json();
+      if (!query2.includes("mutation")) {
+        cache.set(cacheKey, data);
+      }
+      return data;
+    }).finally(() => {
+      inflightRequests.delete(cacheKey);
+    });
+    inflightRequests.set(cacheKey, request);
+    return request;
+  };
+  const invalidate = (endpoint, options) => {
+    cache.delete(getCacheKey(endpoint, options));
+  };
+  const clearCache = () => cache.clear();
+  return { query, invalidate, clearCache };
+};
+const getFragmentQuery = (isSelf) => isSelf ? `
+query FragmentDocument($fragmentSlug: Int!) {
+    fragment(fragmentIds: [$fragmentSlug]) {
+        id
+        document
+        linkedFragments {
+            id
+            document
+        }
+    }
+}
+` : `
+query FragmentDocument($fragmentSlug: Int!) {
+    clientFragment(fragmentId: $fragmentSlug) {
+        id
+        document
+        linkedFragments {
+            id
+            document
+        }
+    }
+}
+`;
+var isEmptyValue = (value) => !value && (value === null || value === void 0);
+var isValue = (value) => !isEmptyValue(value);
+var createConstants$1 = (...constants) => {
+  return constants.reduce((acc, constant) => {
+    acc[constant] = constant;
+    return acc;
+  }, {});
+};
+var isBrowser_default = typeof window !== "undefined";
+var generateId = () => Math.random().toString(16).slice(2);
+var setKey = (v) => `$${v}`;
+var getKey = (v) => isKey(v) ? v.slice(1) : null;
+var isKey = (v) => typeof v === "string" && v.startsWith("$");
+function hashGenerator(layerKey) {
+  let hash = 0;
+  for (let i2 = 0; i2 < layerKey.length; i2++) {
+    hash = (hash << 5) - hash + layerKey.charCodeAt(i2);
+    hash |= 0;
+  }
+  const raw = Math.abs(hash).toString(36);
+  return /^[0-9]/.test(raw) ? `h${raw}` : raw;
+}
+const getEmptyFragment = (fragmentId) => {
+  const layerId = generateId();
+  return {
+    [`Fragment:${fragmentId}`]: {
+      _type: "Fragment",
+      _id: fragmentId,
+      children: [`Frame:${layerId}`],
+      layoutSizingHorizontal: "Fixed",
+      layoutSizingVertical: "Fixed",
+      horizontalGrow: "auto",
+      verticalGrow: "auto",
+      renderMode: "parent",
+      opacity: 1,
+      visible: true,
+      overflow: "hidden",
+      overrides: [],
+      properties: ["Variable:62218c840bd111"]
+    },
+    [`Frame:${layerId}`]: {
+      _type: "Frame",
+      _id: layerId,
+      opacity: 1,
+      parent: setKey(`Fragment:${fragmentId}`),
+      visible: true,
+      overflow: "visible",
+      children: [],
+      width: 320,
+      height: 200,
+      layoutSizingHorizontal: "Fixed",
+      layoutSizingVertical: "Fixed",
+      fillType: "Solid",
+      positionType: "absolute",
+      solidFill: "rgba(255, 255, 255, 1)",
+      name: "Frame",
+      isPrimary: true,
+      threshold: 320
+    }
+  };
+};
+const fetchBeacon = (baseUrl) => {
+  const sender = isBrowser_default && typeof (navigator == null ? void 0 : navigator.sendBeacon) === "function" ? navigator.sendBeacon : () => null;
+  const sendBeacon = (data) => {
+    try {
+      sender("/graphql", "test");
+    } catch (e) {
+      console.error(e);
+    }
+  };
+  return {
+    sendBeacon
+  };
+};
+const fetchPlugin = (state) => {
+  var _a, _b, _c;
+  const isSelf = ((_a = state == null ? void 0 : state.env) == null ? void 0 : _a.isSelf) ?? false;
+  const url = ((_b = state == null ? void 0 : state.env) == null ? void 0 : _b.url) ?? "http://localhost/graphql";
+  const apiToken = (_c = state == null ? void 0 : state.env) == null ? void 0 : _c.apiToken;
+  const fetcher = createFetcher(url, {
+    Authorization: `Bearer ${apiToken}`
+  });
+  const beaconFetcher = fetchBeacon();
+  const queryFragment = async (fragmentId) => {
+    var _a2, _b2, _c2, _d;
+    if (!apiToken) return null;
+    if (state.$fetch.cacheLinks.get(fragmentId)) {
+      return state.$fetch.cacheLinks.get(fragmentId);
+    }
+    const response = await fetcher.query(getFragmentQuery(isSelf), {
+      fragmentSlug: fragmentId
+    });
+    const fragment = isSelf ? (_b2 = (_a2 = response == null ? void 0 : response.data) == null ? void 0 : _a2.fragment) == null ? void 0 : _b2[0] : (_c2 = response == null ? void 0 : response.data) == null ? void 0 : _c2.clientFragment;
+    let fragmentDocument = fragment == null ? void 0 : fragment.document;
+    if (typeof fragmentDocument === "string") {
+      try {
+        if (Object.keys(JSON.parse(fragmentDocument)).length === 0) {
+          fragmentDocument = getEmptyFragment(fragmentId);
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    if (fragment) {
+      state.$fetch.cacheDocuments.set(fragmentId, fragmentDocument);
+      if (Array.isArray(fragment.linkedFragments)) {
+        fragment.linkedFragments.forEach(
+          (linkedFragment) => state.$fetch.cacheDocuments.set(
+            linkedFragment.id,
+            linkedFragment.document
+          )
+        );
+      }
+      (_d = state.$fetch.cacheLinks) == null ? void 0 : _d.set(fragmentId, {
+        document: state.$fetch.cacheDocuments.get(fragmentId),
+        linkedFragments: fragment.linkedFragments ?? []
+      });
+      return state.$fetch.cacheLinks.get(fragmentId);
+    }
+    return null;
+  };
+  state.$fetch = {
+    cacheDocuments: /* @__PURE__ */ new Map(),
+    cacheLinks: /* @__PURE__ */ new Map(),
+    queryFragment,
+    query: fetcher.query,
+    sendBeacon: beaconFetcher.sendBeacon,
+    readFragment: (fragmentId) => state.$fetch.cacheDocuments.get(fragmentId)
+  };
+};
+const createConstants = (...constants) => {
+  return constants.reduce((acc, constant) => {
+    acc[constant] = constant;
+    return acc;
+  }, {});
+};
+const nodes = createConstants(
+  "Fragment",
+  "FragmentInstance",
+  "Instance",
+  "Breakpoint",
+  "Frame",
+  "Image",
+  "Text",
+  "SolidPaintStyle",
+  "CssLink",
+  "Variable",
+  "ComputedValue",
+  "TransformValue"
+);
+const fragmentGrowingMode = createConstants("auto", "fill");
+const borderType = createConstants("None", "Solid", "Dashed", "Dotted");
+const linkTarget = createConstants("_blank");
+const paintMode = createConstants("None", "Solid", "Image");
+const imagePaintScaleModes = createConstants(
+  "Fill",
+  "Fit",
+  "Crop",
+  "Tile"
+);
+const constrain = createConstants(
+  "Min",
+  "Center",
+  "Max",
+  "Stretch",
+  "Scale"
+);
+const positionType = createConstants("absolute", "relative");
+const sizing = createConstants("Fixed", "Hug", "Fill", "Relative");
+const layerMode = createConstants("none", "flex");
+const layerDirection = createConstants("vertical", "horizontal");
+const layerAlign = createConstants("start", "center", "end");
+const layerDistribute = createConstants(
+  "start",
+  "center",
+  "end",
+  "space-between",
+  "space-around"
+);
+const textTransform = createConstants(
+  "none",
+  "uppercase",
+  "lowercase",
+  "capitalize"
+);
+const textDecorations = createConstants(
+  "none",
+  "underline",
+  "line-through"
+);
+const effectType = createConstants("loop", "appear", "hover", "tap");
+const effectName = createConstants(
+  "fade",
+  "slide",
+  "bounce",
+  "wiggle",
+  "increase"
+);
+const variableType = createConstants(
+  "Event",
+  "String",
+  "Boolean",
+  "Array",
+  "Color",
+  "ComponentInstance",
+  "Date",
+  "Enum",
+  "Number",
+  "Object"
+);
+const whiteSpace = createConstants(
+  "normal",
+  "nowrap",
+  "pre",
+  "pre-wrap",
+  "pre-line",
+  "break-spaces"
+);
+const overflow = createConstants("visible", "hidden", "scroll");
+const variableTransforms = createConstants(
+  "convert",
+  "exists",
+  "equals",
+  "startWith",
+  "endWith",
+  "contains",
+  "dateBefore",
+  "dateAfter",
+  "dateBetween",
+  "feature",
+  "notFeature",
+  "gt",
+  // Greater than
+  "gte",
+  // Greater than or equals
+  "lt",
+  // Less than
+  "lte",
+  // Less than or equals,
+  "convertFromBoolean",
+  "negative"
+);
+const renderTarget = createConstants("canvas", "document");
+const renderMode = createConstants("viewport", "parent", "fixed");
+const interactions = createConstants("click", "mouseover");
+const eventMode = createConstants("goal", "callback");
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  borderType,
+  constrain,
+  createConstants,
+  effectName,
+  effectType,
+  eventMode,
+  fragmentGrowingMode,
+  imagePaintScaleModes,
+  interactions,
+  layerAlign,
+  layerDirection,
+  layerDistribute,
+  layerMode,
+  linkTarget,
+  nodes,
+  overflow,
+  paintMode,
+  positionType,
+  renderMode,
+  renderTarget,
+  sizing,
+  textDecorations,
+  textTransform,
+  variableTransforms,
+  variableType,
+  whiteSpace
+}, Symbol.toStringTag, { value: "Module" }));
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config2) {
+  return {
+    lang: (config2 == null ? void 0 : config2.lang) ?? void 0,
+    message: config2 == null ? void 0 : config2.message,
+    abortEarly: (config2 == null ? void 0 : config2.abortEarly) ?? void 0,
+    abortPipeEarly: (config2 == null ? void 0 : config2.abortPipeEarly) ?? void 0
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return void 0;
+}
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return void 0;
+}
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  var _a;
+  return (_a = void 0) == null ? void 0 : _a.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  var _a, _b;
+  const type = typeof input;
+  if (type === "string") {
+    return `"${input}"`;
+  }
+  if (type === "number" || type === "bigint" || type === "boolean") {
+    return `${input}`;
+  }
+  if (type === "object" || type === "function") {
+    return (input && ((_b = (_a = Object.getPrototypeOf(input)) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name)) ?? "null";
+  }
+  return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = (other == null ? void 0 : other.expected) ?? context.expects ?? null;
+  const received = (other == null ? void 0 : other.received) ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other == null ? void 0 : other.path,
+    issues: other == null ? void 0 : other.issues,
+    lang: config2.lang,
+    abortEarly: config2.abortEarly,
+    abortPipeEarly: config2.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message = (other == null ? void 0 : other.message) ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message !== void 0) {
+    issue.message = typeof message === "function" ? (
+      // @ts-expect-error
+      message(issue)
+    ) : message;
+  }
+  if (isSchema) {
+    dataset.typed = false;
+  }
+  if (dataset.issues) {
+    dataset.issues.push(issue);
+  } else {
+    dataset.issues = [issue];
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function _getStandardProps(context) {
+  return {
+    version: 1,
+    vendor: "valibot",
+    validate(value2) {
+      return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _isValidObjectKey(object2, key) {
+  return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects(values2, separator) {
+  const list = [...new Set(values2)];
+  if (list.length > 1) {
+    return `(${list.join(` ${separator} `)})`;
+  }
+  return list[0] ?? "never";
+}
+// @__NO_SIDE_EFFECTS__
+function check(requirement, message) {
+  return {
+    kind: "validation",
+    type: "check",
+    reference: check,
+    async: false,
+    expects: null,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !this.requirement(dataset.value)) {
+        _addIssue(this, "input", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function maxValue(requirement, message) {
+  return {
+    kind: "validation",
+    type: "max_value",
+    reference: maxValue,
+    async: false,
+    expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !(dataset.value <= this.requirement)) {
+        _addIssue(this, "value", dataset, config2, {
+          received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function metadata(metadata_) {
+  return {
+    kind: "metadata",
+    type: "metadata",
+    reference: metadata,
+    metadata: metadata_
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minValue(requirement, message) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !(dataset.value >= this.requirement)) {
+        _addIssue(this, "value", dataset, config2, {
+          received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function transform(operation) {
+  return {
+    kind: "transformation",
+    type: "transform",
+    reference: transform,
+    async: false,
+    operation,
+    "~run"(dataset) {
+      dataset.value = this.operation(dataset.value);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function getFallback(schema, dataset, config2) {
+  return typeof schema.fallback === "function" ? (
+    // @ts-expect-error
+    schema.fallback(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.fallback
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema, dataset, config2) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function any() {
+  return {
+    kind: "schema",
+    type: "any",
+    reference: any,
+    expects: "any",
+    async: false,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function array(item, message) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      var _a;
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value2 = input[key];
+          const itemDataset = this.item["~run"]({ value: value2 }, config2);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value2
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) {
+                issue.path.unshift(pathItem);
+              } else {
+                issue.path = [pathItem];
+              }
+              (_a = dataset.issues) == null ? void 0 : _a.push(issue);
+            }
+            if (!dataset.issues) {
+              dataset.issues = itemDataset.issues;
+            }
+            if (config2.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) {
+            dataset.typed = false;
+          }
+          dataset.value.push(itemDataset.value);
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean(message) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "boolean") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function enum_(enum__, message) {
+  const options = [];
+  for (const key in enum__) {
+    if (`${+key}` !== key || typeof enum__[key] !== "string" || !Object.is(enum__[enum__[key]], +key)) {
+      options.push(enum__[key]);
+    }
+  }
+  return {
+    kind: "schema",
+    type: "enum",
+    reference: enum_,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    enum: enum__,
+    options,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (this.options.includes(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function literal(literal_, message) {
+  return {
+    kind: "schema",
+    type: "literal",
+    reference: literal,
+    expects: /* @__PURE__ */ _stringify(literal_),
+    async: false,
+    literal: literal_,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === this.literal) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function nullable(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "nullable",
+    reference: nullable,
+    expects: `(${wrapped.expects} | null)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === null) {
+        if (this.default !== void 0) {
+          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+        }
+        if (dataset.value === null) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config2);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number(message) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries, message) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      var _a;
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && // @ts-expect-error
+          valueSchema.default !== void 0) {
+            const value2 = key in input ? (
+              // @ts-expect-error
+              input[key]
+            ) : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value2
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                (_a = dataset.issues) == null ? void 0 : _a.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) {
+              dataset.typed = false;
+            }
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) {
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config2, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [
+                {
+                  type: "object",
+                  origin: "key",
+                  input,
+                  key,
+                  // @ts-expect-error
+                  value: input[key]
+                }
+              ]
+            });
+            if (config2.abortEarly) {
+              break;
+            }
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) {
+          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config2);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function picklist(options, message) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    options,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (this.options.includes(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function record(key, value2, message) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value2,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      var _a, _b;
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input) {
+          if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+            const entryValue = input[entryKey];
+            const keyDataset = this.key["~run"]({ value: entryKey }, config2);
+            if (keyDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "key",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of keyDataset.issues) {
+                issue.path = [pathItem];
+                (_a = dataset.issues) == null ? void 0 : _a.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = keyDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            const valueDataset = this.value["~run"](
+              { value: entryValue },
+              config2
+            );
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                (_b = dataset.issues) == null ? void 0 : _b.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!keyDataset.typed || !valueDataset.typed) {
+              dataset.typed = false;
+            }
+            if (keyDataset.typed) {
+              dataset.value[keyDataset.value] = valueDataset.value;
+            }
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string(message) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) {
+    for (const dataset of datasets) {
+      if (issues) {
+        issues.push(...dataset.issues);
+      } else {
+        issues = dataset.issues;
+      }
+    }
+  }
+  return issues;
+}
+// @__NO_SIDE_EFFECTS__
+function union(options, message) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: /* @__PURE__ */ _joinExpects(
+      options.map((option) => option.expects),
+      "|"
+    ),
+    async: false,
+    options,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema["~run"]({ value: dataset.value }, config2);
+        if (optionDataset.typed) {
+          if (optionDataset.issues) {
+            if (typedDatasets) {
+              typedDatasets.push(optionDataset);
+            } else {
+              typedDatasets = [optionDataset];
+            }
+          } else {
+            validDataset = optionDataset;
+            break;
+          }
+        } else {
+          if (untypedDatasets) {
+            untypedDatasets.push(optionDataset);
+          } else {
+            untypedDatasets = [optionDataset];
+          }
+        }
+      }
+      if (validDataset) {
+        return validDataset;
+      }
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) {
+          return typedDatasets[0];
+        }
+        _addIssue(this, "type", dataset, config2, {
+          issues: /* @__PURE__ */ _subIssues(typedDatasets)
+        });
+        dataset.typed = true;
+      } else if ((untypedDatasets == null ? void 0 : untypedDatasets.length) === 1) {
+        return untypedDatasets[0];
+      } else {
+        _addIssue(this, "type", dataset, config2, {
+          issues: /* @__PURE__ */ _subIssues(untypedDatasets)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function pipe(...pipe2) {
+  return {
+    ...pipe2[0],
+    pipe: pipe2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      for (const item of pipe2) {
+        if (item.kind !== "metadata") {
+          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+            dataset.typed = false;
+            break;
+          }
+          if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
+            dataset = item["~run"](dataset, config2);
+          }
+        }
+      }
+      return dataset;
+    }
+  };
+}
+const linkValidator = /* @__PURE__ */ check(
+  (value) => {
+    var _a, _b;
+    return !!value && ((_b = (_a = value == null ? void 0 : value.split) == null ? void 0 : _a.call(value, ":")) == null ? void 0 : _b.length) === 2;
+  }
+);
+const layerField = (schema, meta) => {
+  const modifiedSchema = (meta == null ? void 0 : meta.variable) ? /* @__PURE__ */ union([schema, /* @__PURE__ */ pipe(/* @__PURE__ */ string(), linkValidator)]) : schema;
+  return /* @__PURE__ */ pipe(
+    /* @__PURE__ */ optional(modifiedSchema),
+    /* @__PURE__ */ transform((meta == null ? void 0 : meta.transform) ?? ((v2) => v2)),
+    /* @__PURE__ */ metadata(meta ?? {})
+  );
+};
+const ChildrenSchema = /* @__PURE__ */ object({
+  children: layerField(/* @__PURE__ */ array(/* @__PURE__ */ string()), {
+    fallback: [],
+    overridable: false
+  })
+});
+const GraphFieldSchema = /* @__PURE__ */ object({
+  _id: /* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ number()]),
+  _type: /* @__PURE__ */ picklist(Object.keys(nodes))
+});
+const OverridesSchema = /* @__PURE__ */ object({
+  overrides: layerField(/* @__PURE__ */ array(/* @__PURE__ */ string()), { overridable: false }),
+  overrideFrom: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ string()), { overridable: false })
+});
+const PositionSchema = /* @__PURE__ */ object({
+  position: layerField(/* @__PURE__ */ enum_(Object.keys(positionType)), {
+    fallback: positionType.absolute
+  }),
+  top: layerField(/* @__PURE__ */ number(), { fallback: 0, transform: Math.ceil }),
+  left: layerField(/* @__PURE__ */ number(), { fallback: 0, transform: Math.ceil })
+});
+const SceneSchema = /* @__PURE__ */ object({
+  opacity: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0), /* @__PURE__ */ maxValue(1)), {
+    fallback: 1,
+    variable: true
+  }),
+  visible: layerField(/* @__PURE__ */ boolean(), { fallback: true, variable: true }),
+  zIndex: layerField(/* @__PURE__ */ number(), { fallback: -1 })
+});
+const FillSchema = /* @__PURE__ */ object({
+  fillType: layerField(/* @__PURE__ */ picklist(Object.keys(paintMode)), {
+    fallback: paintMode.None
+  }),
+  solidFill: layerField(/* @__PURE__ */ string(), { fallback: "#fff" }),
+  imageFill: layerField(/* @__PURE__ */ string()),
+  imageSize: layerField(/* @__PURE__ */ picklist(Object.keys(imagePaintScaleModes)), {
+    fallback: imagePaintScaleModes.Fill
+  })
+});
+const BorderSchema = /* @__PURE__ */ object({
+  borderType: layerField(/* @__PURE__ */ picklist(Object.keys(borderType)), {
+    fallback: borderType.None
+  }),
+  borderWidth: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), { fallback: 0 }),
+  borderColor: layerField(/* @__PURE__ */ string(), { fallback: "#fff" })
+});
+const SizeSchema = /* @__PURE__ */ object({
+  widthType: layerField(/* @__PURE__ */ picklist(Object.keys(sizing)), {
+    fallback: sizing.Fixed
+  }),
+  heightType: layerField(/* @__PURE__ */ picklist(Object.keys(sizing)), {
+    fallback: sizing.Fixed
+  }),
+  width: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), {
+    fallback: 0,
+    transform: Math.ceil
+  }),
+  height: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), {
+    fallback: 0,
+    transform: Math.ceil
+  }),
+  aspectRatio: layerField(/* @__PURE__ */ number(), { fallback: -1 }),
+  minWidth: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(-1))), {
+    fallback: -1,
+    transform: Math.ceil
+  }),
+  minWidthType: layerField(/* @__PURE__ */ picklist(Object.keys(sizing)), {
+    fallback: sizing.Fixed
+  }),
+  maxWidth: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(-1))), {
+    fallback: -1,
+    transform: Math.ceil
+  }),
+  maxWidthType: layerField(/* @__PURE__ */ picklist(Object.keys(sizing)), {
+    fallback: sizing.Fixed
+  }),
+  minHeight: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(-1))), {
+    fallback: -1,
+    transform: Math.ceil
+  }),
+  minHeightType: layerField(/* @__PURE__ */ picklist(Object.keys(sizing)), {
+    fallback: sizing.Fixed
+  }),
+  maxHeight: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(-1))), {
+    fallback: -1,
+    transform: Math.ceil
+  }),
+  maxHeightType: layerField(/* @__PURE__ */ picklist(Object.keys(sizing)), {
+    fallback: sizing.Fixed
+  })
+});
+const LayerSchema = /* @__PURE__ */ object({
+  layerMode: layerField(/* @__PURE__ */ picklist(Object.keys(layerMode)), {
+    fallback: layerMode.none
+  }),
+  layerAlign: layerField(/* @__PURE__ */ picklist(Object.keys(layerAlign)), {
+    fallback: layerAlign.start
+  }),
+  layerDirection: layerField(/* @__PURE__ */ picklist(Object.keys(layerDirection)), {
+    fallback: layerDirection.horizontal
+  }),
+  layerDistribute: layerField(/* @__PURE__ */ picklist(Object.keys(layerDistribute)), {
+    fallback: layerDistribute.start
+  }),
+  layerWrap: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  layerGap: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), { fallback: 0 }),
+  padding: layerField(/* @__PURE__ */ string(), { fallback: "0px" })
+});
+const OverflowSchema = layerField(/* @__PURE__ */ picklist(Object.keys(overflow)), {
+  fallback: overflow.hidden
+});
+const BorderRadiusSchema = layerField(/* @__PURE__ */ string(), { fallback: "0px" });
+const InteractionsSchema = /* @__PURE__ */ object({
+  interactions: layerField(
+    /* @__PURE__ */ array(
+      /* @__PURE__ */ object({
+        on: /* @__PURE__ */ enum_(Object.keys(interactions)),
+        event: /* @__PURE__ */ nullable(linkValidator)
+      })
+    ),
+    { fallback: [] }
+  )
+});
+const CssOverrideSchema = /* @__PURE__ */ object({
+  cssOverride: layerField(/* @__PURE__ */ string(), { fallback: "" })
+});
+/* @__PURE__ */ pipe(
+  /* @__PURE__ */ object({
+    name: layerField(/* @__PURE__ */ string(), { fallback: "Frame", overridable: false }),
+    isBreakpoint: layerField(/* @__PURE__ */ boolean(), {
+      fallback: false,
+      overridable: false
+    }),
+    isPrimary: layerField(/* @__PURE__ */ boolean(), { fallback: false, overridable: false }),
+    parent: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ string()), { overridable: false }),
+    ...ChildrenSchema.entries,
+    ...GraphFieldSchema.entries,
+    ...OverridesSchema.entries,
+    ...PositionSchema.entries,
+    ...SceneSchema.entries,
+    ...FillSchema.entries,
+    ...BorderSchema.entries,
+    ...SizeSchema.entries,
+    ...LayerSchema.entries,
+    ...InteractionsSchema.entries,
+    ...CssOverrideSchema.entries,
+    overflow: OverflowSchema,
+    borderRadius: BorderRadiusSchema
+  })
+);
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), { fallback: "Text", overridable: false }),
+  content: layerField(/* @__PURE__ */ string(), {
+    fallback: ""
+  }),
+  whiteSpace: layerField(/* @__PURE__ */ enum_(Object.keys(whiteSpace)), {
+    fallback: whiteSpace.pre
+  }),
+  variableContent: layerField(/* @__PURE__ */ string(), { fallback: null, variable: true }),
+  parent: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ string()), { overridable: false }),
+  attributes: layerField(
+    /* @__PURE__ */ object({
+      fontSize: layerField(/* @__PURE__ */ string(), { fallback: "14px" }),
+      color: layerField(/* @__PURE__ */ string(), { fallback: "#000" }),
+      lineHeight: layerField(/* @__PURE__ */ string(), { fallback: "14px" }),
+      fontWeight: layerField(/* @__PURE__ */ string(), { fallback: "normal" }),
+      letterSpacing: layerField(/* @__PURE__ */ string(), { fallback: "0px" }),
+      textTransform: layerField(/* @__PURE__ */ string(), { fallback: "none" }),
+      textDecoration: layerField(/* @__PURE__ */ string(), { fallback: "none" }),
+      whiteSpace: layerField(/* @__PURE__ */ string(), { fallback: "pre" }),
+      textAlign: layerField(/* @__PURE__ */ string(), { fallback: "left" })
+    }),
+    { fallback: {} }
+  ),
+  ...GraphFieldSchema.entries,
+  ...OverridesSchema.entries,
+  ...PositionSchema.entries,
+  ...SceneSchema.entries,
+  ...SizeSchema.entries
+});
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), { fallback: "Fragment", overridable: false }),
+  parent: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ string()), { overridable: false }),
+  horizontalGrow: layerField(/* @__PURE__ */ enum_(Object.keys(fragmentGrowingMode)), {
+    fallback: fragmentGrowingMode.auto,
+    overridable: false
+  }),
+  verticalGrow: layerField(/* @__PURE__ */ enum_(Object.keys(fragmentGrowingMode)), {
+    fallback: fragmentGrowingMode.auto,
+    overridable: false
+  }),
+  properties: layerField(/* @__PURE__ */ array(/* @__PURE__ */ string()), {
+    fallback: [],
+    overridable: false
+  }),
+  ...GraphFieldSchema.entries,
+  ...ChildrenSchema.entries
+});
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), { fallback: "Instance", overridable: false }),
+  fragment: layerField(/* @__PURE__ */ number()),
+  parent: layerField(/* @__PURE__ */ nullable(/* @__PURE__ */ string()), { overridable: false }),
+  props: layerField(
+    /* @__PURE__ */ record(
+      /* @__PURE__ */ string(),
+      /* @__PURE__ */ union([
+        /* @__PURE__ */ string(),
+        /* @__PURE__ */ number(),
+        /* @__PURE__ */ boolean(),
+        // For goals
+        /* @__PURE__ */ object({
+          code: /* @__PURE__ */ string(),
+          name: /* @__PURE__ */ string()
+        })
+      ])
+    ),
+    {
+      fallback: {}
+    }
+  ),
+  ...GraphFieldSchema.entries,
+  ...OverridesSchema.entries,
+  ...PositionSchema.entries,
+  ...SizeSchema.entries,
+  ...SceneSchema.entries
+});
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "Number",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.Number), {
+    fallback: variableType.Number
+  }),
+  defaultValue: layerField(/* @__PURE__ */ number(), { fallback: 0 }),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  min: layerField(/* @__PURE__ */ number(), { fallback: 1 }),
+  max: layerField(/* @__PURE__ */ number(), { fallback: 100 }),
+  step: layerField(/* @__PURE__ */ number(), { fallback: 1 }),
+  displayStepper: layerField(/* @__PURE__ */ boolean(), { fallback: true }),
+  ...GraphFieldSchema.entries
+});
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "Boolean",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.Boolean), {
+    fallback: variableType.Boolean
+  }),
+  defaultValue: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  ...GraphFieldSchema.entries
+});
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "String",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.Color), {
+    fallback: variableType.Color
+  }),
+  // TODO Add color validator
+  defaultValue: layerField(/* @__PURE__ */ string(), { fallback: "#000" }),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  ...GraphFieldSchema.entries
+});
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "String",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.String), {
+    fallback: variableType.String
+  }),
+  defaultValue: layerField(/* @__PURE__ */ string(), { fallback: "" }),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  placeholder: layerField(/* @__PURE__ */ string(), { fallback: "" }),
+  isTextarea: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  ...GraphFieldSchema.entries
+});
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "Event",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.Event), {
+    fallback: variableType.Event
+  }),
+  mode: layerField(/* @__PURE__ */ picklist(Object.keys(eventMode)), {
+    fallback: eventMode.callback
+  }),
+  defaultValue: layerField(/* @__PURE__ */ any()),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  ...GraphFieldSchema.entries
+});
+const findGroups = (state) => {
+  var _a;
+  const cache = (_a = state.$styleSheet) == null ? void 0 : _a.cache;
+  const fragments = Array.from(cache.keys()).filter(
+    (key) => key == null ? void 0 : key.includes(index.nodes.Fragment)
+  ) ?? [];
+  const createFragmentSlice = (fragmentLayerKey) => {
+    var _a2;
+    const rootLayer = (_a2 = cache.get(fragmentLayerKey)) == null ? void 0 : _a2.layer;
+    const breakpoints = ((rootLayer == null ? void 0 : rootLayer.children) ?? []).map(
+      (child) => {
+        var _a3;
+        return (_a3 = cache.get(child)) == null ? void 0 : _a3.layer;
+      }
+    );
+    const primaryBreakpoint = breakpoints.find(
+      (breakpoint) => breakpoint == null ? void 0 : breakpoint.isPrimary
+    );
+    const smaller = breakpoints.filter((f) => !!f && (f == null ? void 0 : f.width) < (primaryBreakpoint == null ? void 0 : primaryBreakpoint.width)).sort((a2, b2) => b2.width - a2.width);
+    const larger = breakpoints.filter((f) => !!f && (f == null ? void 0 : f.width) > (primaryBreakpoint == null ? void 0 : primaryBreakpoint.width)).sort((a2, b2) => a2.width - b2.width);
+    return {
+      fragment: rootLayer,
+      primary: primaryBreakpoint,
+      smaller: smaller ?? [],
+      larger: larger ?? []
+    };
+  };
+  return fragments.map(createFragmentSlice).filter((slice) => slice.primary);
+};
+const toCSS = (styles) => Object.entries(styles).filter(([, value]) => isValue(value) && value !== "").map(
+  ([key, value]) => `${key.replace(/([A-Z])/g, "-$1").toLowerCase()}: ${value};`
+).join("\n");
+function compareRules(prev = {}, next = {}) {
+  const diff = {};
+  for (const key of Object.keys(next)) {
+    if (prev[key] !== next[key]) {
+      diff[key] = next[key];
+    }
+  }
+  return diff;
+}
+const makeCss = (state) => (entity) => {
+  var _a, _b, _c, _d, _e;
+  const cache = (_a = state.$styleSheet) == null ? void 0 : _a.cache;
+  const layerKey = state.keyOfEntity(entity);
+  const cacheLayer = cache.get(layerKey);
+  const isPrimary = !((_b = cacheLayer == null ? void 0 : cacheLayer.layer) == null ? void 0 : _b.overrideFrom);
+  const layerHash = hashGenerator(
+    isPrimary ? layerKey : getKey((_c = cacheLayer == null ? void 0 : cacheLayer.layer) == null ? void 0 : _c.overrideFrom)
+  );
+  const layerCss = cacheLayer == null ? void 0 : cacheLayer.styles;
+  const overriderLayerCss = ((_e = cache.get(getKey((_d = cacheLayer == null ? void 0 : cacheLayer.layer) == null ? void 0 : _d.overrideFrom))) == null ? void 0 : _e.styles) ?? {};
+  const resultCssRules = compareRules(overriderLayerCss, layerCss);
+  return {
+    hash: layerHash,
+    css: toCSS(resultCssRules)
+  };
+};
+const getAllChildren = (state, start, acc = []) => {
+  var _a, _b;
+  const cache = (_a = state.$styleSheet) == null ? void 0 : _a.cache;
+  const layerKey = state.keyOfEntity(start);
+  const { layer } = cache.get(layerKey) ?? {};
+  if (acc.length === 0) {
+    acc.push(layerKey);
+  }
+  (_b = layer == null ? void 0 : layer.children) == null ? void 0 : _b.forEach((child) => {
+    acc.push(child);
+    getAllChildren(state, child, acc);
+  });
+  return acc;
+};
+const buildCssBlock = (block) => {
+  if (!block || block.css === "") return "";
+  return `.${block.hash} {${block.css}}`;
+};
+const styleSheetPlugin = (state) => {
+  const extractStyleSheet = () => {
+    const fragments = findGroups(state);
+    const cssMaker = makeCss(state);
+    const fragmentsStyle = fragments.map((group) => {
+      const fragmentCssRules = [];
+      fragmentCssRules.push(buildCssBlock(cssMaker(group.fragment)));
+      const children = getAllChildren(state, group.primary);
+      const primaryCssBlocks = children.map(cssMaker);
+      primaryCssBlocks.forEach((block) => {
+        fragmentCssRules.push(buildCssBlock(block));
+      });
+      group.smaller.forEach((smallerLayer, index2, arr) => {
+        const smallerChildren = getAllChildren(state, smallerLayer);
+        const smallerCssBlocks = smallerChildren.map(cssMaker);
+        const max = index2 === 0 ? group.primary.width - 1 : arr[index2 - 1].width;
+        fragmentCssRules.push(
+          `@container (max-width: ${max}px) {${smallerCssBlocks.map(buildCssBlock).join("")}}`
+        );
+      });
+      group.larger.forEach((largerLayer, index2, arr) => {
+        const largerChildren = getAllChildren(state, largerLayer);
+        const largerCssBlocks = largerChildren.map((l) => cssMaker(l, 123));
+        const min = largerLayer.width;
+        const max = index2 < arr.length - 1 ? arr[index2 + 1].width - 1 : null;
+        const containerQuery = max ? `@container (min-width: ${min}px) and (max-width: ${max}px)` : `@container (min-width: ${min}px)`;
+        fragmentCssRules.push(
+          `${containerQuery} {${largerCssBlocks.map(buildCssBlock).join("")}}`
+        );
+      });
+      fragmentCssRules.push(`[data-key^="Text"] { p {margin: 0;} }`);
+      return {
+        fragment: state.keyOfEntity(group.fragment),
+        styles: fragmentCssRules
+      };
+    });
+    return fragmentsStyle;
+  };
+  state.$styleSheet = {
+    cache: /* @__PURE__ */ new Map(),
+    addStyle: (layerKey, styles, layer) => {
+      var _a, _b;
+      return (_b = (_a = state.$styleSheet) == null ? void 0 : _a.cache) == null ? void 0 : _b.set(layerKey, { styles, layer });
+    },
+    extract: extractStyleSheet
+  };
+};
+const fragmentsPlugin = (state) => {
+  const createFragmentManager = (fragmentId, initialDocument = {}) => {
+    var _a, _b;
+    if (!fragmentId || !initialDocument) return null;
+    const cacheManager = (_b = (_a = state.resolve(state.$fragments.key)) == null ? void 0 : _a.managers) == null ? void 0 : _b[fragmentId];
+    if (cacheManager) {
+      return cacheManager;
+    }
+    const tempGraph = {
+      _type: "Temp",
+      _id: "root"
+    };
+    const springGraph = {
+      _type: "Spring",
+      _id: "root"
+    };
+    const manager = it({
+      _type: "FragmentManager",
+      _id: fragmentId,
+      initialState: initialDocument,
+      plugins: [
+        (state2) => {
+          state2.$fragment = {
+            root: `${index.nodes.Fragment}:${fragmentId}`,
+            temp: "Temp:root"
+          };
+        },
+        // cssPlugin,
+        styleSheetPlugin
+      ],
+      skip: [b, a, isKey]
+    });
+    manager.mutate(tempGraph);
+    manager.mutate(springGraph);
+    state.mutate(state.$fragments.key, {
+      managers: {
+        [fragmentId]: manager
+      }
+    });
+  };
+  const getManager = (fragmentId) => {
+    var _a, _b;
+    return (_b = (_a = state.resolve(state.$fragments.key)) == null ? void 0 : _a.managers) == null ? void 0 : _b[fragmentId];
+  };
+  const getManagers = () => {
+    var _a;
+    return (_a = state.resolve(state.$fragments.key)) == null ? void 0 : _a.managers;
+  };
+  state.$fragments = {
+    key: `FragmentsPlugin:root`,
+    createFragmentManager,
+    getManager,
+    getManagers
+  };
+  state.mutate({
+    _type: "FragmentsPlugin",
+    _id: "root",
+    managers: {}
+  });
+  return state;
+};
+const addClientMetric = `mutation AddClientMetric($type: ClientMetricType!, $value: String) {
+  addClientMetric(metric: {metricType: $type, metricValue: $value})
+}`;
+const types = createConstants$1(
+  "INIT_SESSION",
+  "RELEASE_SESSION",
+  "REACH_PROJECT_GOAL"
+);
+const metricsPlugin = (state) => {
+  const sendMetric = (type, value) => {
+    var _a, _b;
+    (_a = state == null ? void 0 : state.$fetch) == null ? void 0 : _a.sendBeacon;
+    const query = (_b = state == null ? void 0 : state.$fetch) == null ? void 0 : _b.query;
+    query(addClientMetric, { type, value });
+  };
+  const initClient = async () => {
+    console.log("initClient");
+    sendMetric(types.INIT_SESSION);
+  };
+  const releaseClient = async () => {
+    sendMetric(types.RELEASE_SESSION);
+  };
+  const reachGoal = (goal) => {
+    sendMetric(types.REACH_PROJECT_GOAL, goal);
+  };
+  state.$metrics = {
+    initClient,
+    releaseClient,
+    reachGoal
+  };
+};
+const createFragmentsClient = (options) => {
+  return it({
+    _type: "GlobalManager",
+    initialState: {},
+    plugins: [
+      (state) => {
+        state.env = {
+          isSelf: (options == null ? void 0 : options.isSelf) ?? false,
+          url: options == null ? void 0 : options.url,
+          apiToken: options == null ? void 0 : options.apiToken
+        };
+        state.$global = {};
+        state.extractStyles = async () => {
+          const allFragments = state.$fragments.getManagers();
+          const extractors = Object.entries(allFragments).filter(([, value]) => !!(value == null ? void 0 : value.resolve)).map(([, manager]) => manager.$styleSheet.extract());
+          const extractedStyles = await Promise.all(extractors);
+          return Object.values(
+            extractedStyles.reduce((acc, extrected) => {
+              Object.entries(extrected).forEach(([key, styleTag]) => {
+                acc[key] = styleTag;
+              });
+              return acc;
+            }, {})
+          );
+        };
+      },
+      fetchPlugin,
+      fragmentsPlugin,
+      metricsPlugin,
+      (state) => {
+        var _a, _b, _c, _d, _e;
+        if (isBrowser_default) {
+          if (!((_a = state == null ? void 0 : state.env) == null ? void 0 : _a.isSelf)) {
+            (_c = (_b = state == null ? void 0 : state.$metrics) == null ? void 0 : _b.initClient) == null ? void 0 : _c.call(_b);
+            window.addEventListener(
+              "beforeunload",
+              (_e = (_d = state == null ? void 0 : state.$metrics) == null ? void 0 : _d.releaseClient) == null ? void 0 : _e.call(_d)
+            );
+          }
+        }
+      }
+    ]
+  });
+};
+export {
+  createFragmentsClient
+};