@fragmentsx/render-react 0.0.1

package/dist/index.cjs.js

@@ -0,0 +1,4924 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const preact = require("preact");
+const require$$0$1 = require("react");
+require("react/jsx-runtime");
+(function() {
+  try {
+    if (typeof document != "undefined") {
+      var elementStyle = document.createElement("style");
+      elementStyle.appendChild(document.createTextNode("._fragment_wbfy9_1 {\n    width: 100%;\n    height: 100%;\n}\n._text_1liuf_1 {\n    white-space: pre;\n    :where(p) {\n        margin: 0;\n    }\n}"));
+      document.head.appendChild(elementStyle);
+    }
+  } catch (e2) {
+    console.error("vite-plugin-css-injected-by-js", e2);
+  }
+})();
+var f$1 = 0;
+function u$1(e2, t2, n2, o2, i2, u2) {
+  t2 || (t2 = {});
+  var a2, c2, p2 = t2;
+  if ("ref" in p2) for (c2 in p2 = {}, t2) "ref" == c2 ? a2 = t2[c2] : p2[c2] = t2[c2];
+  var l2 = { type: e2, props: p2, key: n2, ref: a2, __k: null, __: null, __b: 0, __e: null, __c: null, constructor: void 0, __v: --f$1, __i: -1, __u: 0, __source: i2, __self: u2 };
+  if ("function" == typeof e2 && (a2 = e2.defaultProps)) for (c2 in a2) void 0 === p2[c2] && (p2[c2] = a2[c2]);
+  return preact.options.vnode && preact.options.vnode(l2), l2;
+}
+var t$1, r$1, u, i$1, o = 0, f = [], c = preact.options, e = c.__b, a$1 = c.__r, v = c.diffed, l = c.__c, m = c.unmount, s$1 = c.__;
+function p$1(n2, t2) {
+  c.__h && c.__h(r$1, n2, o || t2), o = 0;
+  var u2 = r$1.__H || (r$1.__H = { __: [], __h: [] });
+  return n2 >= u2.__.length && u2.__.push({}), u2.__[n2];
+}
+function d(n2) {
+  return o = 1, h(D$2, n2);
+}
+function h(n2, u2, i2) {
+  var o2 = p$1(t$1++, 2);
+  if (o2.t = n2, !o2.__c && (o2.__ = [i2 ? i2(u2) : D$2(void 0, u2), function(n3) {
+    var t2 = o2.__N ? o2.__N[0] : o2.__[0], r2 = o2.t(t2, n3);
+    t2 !== r2 && (o2.__N = [r2, o2.__[1]], o2.__c.setState({}));
+  }], o2.__c = r$1, !r$1.__f)) {
+    var f2 = function(n3, t2, r2) {
+      if (!o2.__c.__H) return true;
+      var u3 = o2.__c.__H.__.filter(function(n4) {
+        return !!n4.__c;
+      });
+      if (u3.every(function(n4) {
+        return !n4.__N;
+      })) return !c2 || c2.call(this, n3, t2, r2);
+      var i3 = o2.__c.props !== n3;
+      return u3.forEach(function(n4) {
+        if (n4.__N) {
+          var t3 = n4.__[0];
+          n4.__ = n4.__N, n4.__N = void 0, t3 !== n4.__[0] && (i3 = true);
+        }
+      }), c2 && c2.call(this, n3, t2, r2) || i3;
+    };
+    r$1.__f = true;
+    var c2 = r$1.shouldComponentUpdate, e2 = r$1.componentWillUpdate;
+    r$1.componentWillUpdate = function(n3, t2, r2) {
+      if (this.__e) {
+        var u3 = c2;
+        c2 = void 0, f2(n3, t2, r2), c2 = u3;
+      }
+      e2 && e2.call(this, n3, t2, r2);
+    }, r$1.shouldComponentUpdate = f2;
+  }
+  return o2.__N || o2.__;
+}
+function y$2(n2, u2) {
+  var i2 = p$1(t$1++, 3);
+  !c.__s && C$1(i2.__H, u2) && (i2.__ = n2, i2.u = u2, r$1.__H.__h.push(i2));
+}
+function _(n2, u2) {
+  var i2 = p$1(t$1++, 4);
+  !c.__s && C$1(i2.__H, u2) && (i2.__ = n2, i2.u = u2, r$1.__h.push(i2));
+}
+function A$1(n2) {
+  return o = 5, T$1(function() {
+    return { current: n2 };
+  }, []);
+}
+function F$1(n2, t2, r2) {
+  o = 6, _(function() {
+    if ("function" == typeof n2) {
+      var r3 = n2(t2());
+      return function() {
+        n2(null), r3 && "function" == typeof r3 && r3();
+      };
+    }
+    if (n2) return n2.current = t2(), function() {
+      return n2.current = null;
+    };
+  }, null == r2 ? r2 : r2.concat(n2));
+}
+function T$1(n2, r2) {
+  var u2 = p$1(t$1++, 7);
+  return C$1(u2.__H, r2) && (u2.__ = n2(), u2.__H = r2, u2.__h = n2), u2.__;
+}
+function q$1(n2, t2) {
+  return o = 8, T$1(function() {
+    return n2;
+  }, t2);
+}
+function x$1(n2) {
+  var u2 = r$1.context[n2.__c], i2 = p$1(t$1++, 9);
+  return i2.c = n2, u2 ? (null == i2.__ && (i2.__ = true, u2.sub(r$1)), u2.props.value) : n2.__;
+}
+function P$1(n2, t2) {
+  c.useDebugValue && c.useDebugValue(t2 ? t2(n2) : n2);
+}
+function b$1(n2) {
+  var u2 = p$1(t$1++, 10), i2 = d();
+  return u2.__ = n2, r$1.componentDidCatch || (r$1.componentDidCatch = function(n3, t2) {
+    u2.__ && u2.__(n3, t2), i2[1](n3);
+  }), [i2[0], function() {
+    i2[1](void 0);
+  }];
+}
+function g$2() {
+  var n2 = p$1(t$1++, 11);
+  if (!n2.__) {
+    for (var u2 = r$1.__v; null !== u2 && !u2.__m && null !== u2.__; ) u2 = u2.__;
+    var i2 = u2.__m || (u2.__m = [0, 0]);
+    n2.__ = "P" + i2[0] + "-" + i2[1]++;
+  }
+  return n2.__;
+}
+function j$2() {
+  for (var n2; n2 = f.shift(); ) if (n2.__P && n2.__H) try {
+    n2.__H.__h.forEach(z$1), n2.__H.__h.forEach(B$1), n2.__H.__h = [];
+  } catch (t2) {
+    n2.__H.__h = [], c.__e(t2, n2.__v);
+  }
+}
+c.__b = function(n2) {
+  r$1 = null, e && e(n2);
+}, c.__ = function(n2, t2) {
+  n2 && t2.__k && t2.__k.__m && (n2.__m = t2.__k.__m), s$1 && s$1(n2, t2);
+}, c.__r = function(n2) {
+  a$1 && a$1(n2), t$1 = 0;
+  var i2 = (r$1 = n2.__c).__H;
+  i2 && (u === r$1 ? (i2.__h = [], r$1.__h = [], i2.__.forEach(function(n3) {
+    n3.__N && (n3.__ = n3.__N), n3.u = n3.__N = void 0;
+  })) : (i2.__h.forEach(z$1), i2.__h.forEach(B$1), i2.__h = [], t$1 = 0)), u = r$1;
+}, c.diffed = function(n2) {
+  v && v(n2);
+  var t2 = n2.__c;
+  t2 && t2.__H && (t2.__H.__h.length && (1 !== f.push(t2) && i$1 === c.requestAnimationFrame || ((i$1 = c.requestAnimationFrame) || w$1)(j$2)), t2.__H.__.forEach(function(n3) {
+    n3.u && (n3.__H = n3.u), n3.u = void 0;
+  })), u = r$1 = null;
+}, c.__c = function(n2, t2) {
+  t2.some(function(n3) {
+    try {
+      n3.__h.forEach(z$1), n3.__h = n3.__h.filter(function(n4) {
+        return !n4.__ || B$1(n4);
+      });
+    } catch (r2) {
+      t2.some(function(n4) {
+        n4.__h && (n4.__h = []);
+      }), t2 = [], c.__e(r2, n3.__v);
+    }
+  }), l && l(n2, t2);
+}, c.unmount = function(n2) {
+  m && m(n2);
+  var t2, r2 = n2.__c;
+  r2 && r2.__H && (r2.__H.__.forEach(function(n3) {
+    try {
+      z$1(n3);
+    } catch (n4) {
+      t2 = n4;
+    }
+  }), r2.__H = void 0, t2 && c.__e(t2, r2.__v));
+};
+var k$2 = "function" == typeof requestAnimationFrame;
+function w$1(n2) {
+  var t2, r2 = function() {
+    clearTimeout(u2), k$2 && cancelAnimationFrame(t2), setTimeout(n2);
+  }, u2 = setTimeout(r2, 100);
+  k$2 && (t2 = requestAnimationFrame(r2));
+}
+function z$1(n2) {
+  var t2 = r$1, u2 = n2.__c;
+  "function" == typeof u2 && (n2.__c = void 0, u2()), r$1 = t2;
+}
+function B$1(n2) {
+  var t2 = r$1;
+  n2.__c = n2.__(), r$1 = t2;
+}
+function C$1(n2, t2) {
+  return !n2 || n2.length !== t2.length || t2.some(function(t3, r2) {
+    return t3 !== n2[r2];
+  });
+}
+function D$2(n2, t2) {
+  return "function" == typeof t2 ? t2(n2) : t2;
+}
+function g$1(n2, t2) {
+  for (var e2 in t2) n2[e2] = t2[e2];
+  return n2;
+}
+function E$1(n2, t2) {
+  for (var e2 in n2) if ("__source" !== e2 && !(e2 in t2)) return true;
+  for (var r2 in t2) if ("__source" !== r2 && n2[r2] !== t2[r2]) return true;
+  return false;
+}
+function C(n2, t2) {
+  var e2 = t2(), r2 = d({ t: { __: e2, u: t2 } }), u2 = r2[0].t, o2 = r2[1];
+  return _(function() {
+    u2.__ = e2, u2.u = t2, x(u2) && o2({ t: u2 });
+  }, [n2, e2, t2]), y$2(function() {
+    return x(u2) && o2({ t: u2 }), n2(function() {
+      x(u2) && o2({ t: u2 });
+    });
+  }, [n2]), e2;
+}
+function x(n2) {
+  var t2, e2, r2 = n2.u, u2 = n2.__;
+  try {
+    var o2 = r2();
+    return !((t2 = u2) === (e2 = o2) && (0 !== t2 || 1 / t2 == 1 / e2) || t2 != t2 && e2 != e2);
+  } catch (n3) {
+    return true;
+  }
+}
+function R(n2) {
+  n2();
+}
+function w(n2) {
+  return n2;
+}
+function k$1() {
+  return [false, R];
+}
+var I = _;
+function N(n2, t2) {
+  this.props = n2, this.context = t2;
+}
+function M(n2, e2) {
+  function r2(n3) {
+    var t2 = this.props.ref, r3 = t2 == n3.ref;
+    return !r3 && t2 && (t2.call ? t2(null) : t2.current = null), e2 ? !e2(this.props, n3) || !r3 : E$1(this.props, n3);
+  }
+  function u2(e3) {
+    return this.shouldComponentUpdate = r2, preact.createElement(n2, e3);
+  }
+  return u2.displayName = "Memo(" + (n2.displayName || n2.name) + ")", u2.prototype.isReactComponent = true, u2.__f = true, u2;
+}
+(N.prototype = new preact.Component()).isPureReactComponent = true, N.prototype.shouldComponentUpdate = function(n2, t2) {
+  return E$1(this.props, n2) || E$1(this.state, t2);
+};
+var T = preact.options.__b;
+preact.options.__b = function(n2) {
+  n2.type && n2.type.__f && n2.ref && (n2.props.ref = n2.ref, n2.ref = null), T && T(n2);
+};
+var A = "undefined" != typeof Symbol && Symbol.for && Symbol.for("react.forward_ref") || 3911;
+function D$1(n2) {
+  function t2(t3) {
+    var e2 = g$1({}, t3);
+    return delete e2.ref, n2(e2, t3.ref || null);
+  }
+  return t2.$$typeof = A, t2.render = t2, t2.prototype.isReactComponent = t2.__f = true, t2.displayName = "ForwardRef(" + (n2.displayName || n2.name) + ")", t2;
+}
+var L = function(n2, t2) {
+  return null == n2 ? null : preact.toChildArray(preact.toChildArray(n2).map(t2));
+}, O = { map: L, forEach: L, count: function(n2) {
+  return n2 ? preact.toChildArray(n2).length : 0;
+}, only: function(n2) {
+  var t2 = preact.toChildArray(n2);
+  if (1 !== t2.length) throw "Children.only";
+  return t2[0];
+}, toArray: preact.toChildArray }, F = preact.options.__e;
+preact.options.__e = function(n2, t2, e2, r2) {
+  if (n2.then) {
+    for (var u2, o2 = t2; o2 = o2.__; ) if ((u2 = o2.__c) && u2.__c) return null == t2.__e && (t2.__e = e2.__e, t2.__k = e2.__k), u2.__c(n2, t2);
+  }
+  F(n2, t2, e2, r2);
+};
+var U = preact.options.unmount;
+function V(n2, t2, e2) {
+  return n2 && (n2.__c && n2.__c.__H && (n2.__c.__H.__.forEach(function(n3) {
+    "function" == typeof n3.__c && n3.__c();
+  }), n2.__c.__H = null), null != (n2 = g$1({}, n2)).__c && (n2.__c.__P === e2 && (n2.__c.__P = t2), n2.__c = null), n2.__k = n2.__k && n2.__k.map(function(n3) {
+    return V(n3, t2, e2);
+  })), n2;
+}
+function W$1(n2, t2, e2) {
+  return n2 && e2 && (n2.__v = null, n2.__k = n2.__k && n2.__k.map(function(n3) {
+    return W$1(n3, t2, e2);
+  }), n2.__c && n2.__c.__P === t2 && (n2.__e && e2.appendChild(n2.__e), n2.__c.__e = true, n2.__c.__P = e2)), n2;
+}
+function P() {
+  this.__u = 0, this.o = null, this.__b = null;
+}
+function j$1(n2) {
+  var t2 = n2.__.__c;
+  return t2 && t2.__a && t2.__a(n2);
+}
+function z(n2) {
+  var e2, r2, u2;
+  function o2(o3) {
+    if (e2 || (e2 = n2()).then(function(n3) {
+      r2 = n3.default || n3;
+    }, function(n3) {
+      u2 = n3;
+    }), u2) throw u2;
+    if (!r2) throw e2;
+    return preact.createElement(r2, o3);
+  }
+  return o2.displayName = "Lazy", o2.__f = true, o2;
+}
+function B() {
+  this.i = null, this.l = null;
+}
+preact.options.unmount = function(n2) {
+  var t2 = n2.__c;
+  t2 && t2.__R && t2.__R(), t2 && 32 & n2.__u && (n2.type = null), U && U(n2);
+}, (P.prototype = new preact.Component()).__c = function(n2, t2) {
+  var e2 = t2.__c, r2 = this;
+  null == r2.o && (r2.o = []), r2.o.push(e2);
+  var u2 = j$1(r2.__v), o2 = false, i2 = function() {
+    o2 || (o2 = true, e2.__R = null, u2 ? u2(c2) : c2());
+  };
+  e2.__R = i2;
+  var c2 = function() {
+    if (!--r2.__u) {
+      if (r2.state.__a) {
+        var n3 = r2.state.__a;
+        r2.__v.__k[0] = W$1(n3, n3.__c.__P, n3.__c.__O);
+      }
+      var t3;
+      for (r2.setState({ __a: r2.__b = null }); t3 = r2.o.pop(); ) t3.forceUpdate();
+    }
+  };
+  r2.__u++ || 32 & t2.__u || r2.setState({ __a: r2.__b = r2.__v.__k[0] }), n2.then(i2, i2);
+}, P.prototype.componentWillUnmount = function() {
+  this.o = [];
+}, P.prototype.render = function(n2, e2) {
+  if (this.__b) {
+    if (this.__v.__k) {
+      var r2 = document.createElement("div"), o2 = this.__v.__k[0].__c;
+      this.__v.__k[0] = V(this.__b, r2, o2.__O = o2.__P);
+    }
+    this.__b = null;
+  }
+  var i2 = e2.__a && preact.createElement(preact.Fragment, null, n2.fallback);
+  return i2 && (i2.__u &= -33), [preact.createElement(preact.Fragment, null, e2.__a ? null : n2.children), i2];
+};
+var H = function(n2, t2, e2) {
+  if (++e2[1] === e2[0] && n2.l.delete(t2), n2.props.revealOrder && ("t" !== n2.props.revealOrder[0] || !n2.l.size)) for (e2 = n2.i; e2; ) {
+    for (; e2.length > 3; ) e2.pop()();
+    if (e2[1] < e2[0]) break;
+    n2.i = e2 = e2[2];
+  }
+};
+function Z(n2) {
+  return this.getChildContext = function() {
+    return n2.context;
+  }, n2.children;
+}
+function Y(n2) {
+  var e2 = this, r2 = n2.h;
+  e2.componentWillUnmount = function() {
+    preact.render(null, e2.v), e2.v = null, e2.h = null;
+  }, e2.h && e2.h !== r2 && e2.componentWillUnmount(), e2.v || (e2.h = r2, e2.v = { nodeType: 1, parentNode: r2, childNodes: [], contains: function() {
+    return true;
+  }, appendChild: function(n3) {
+    this.childNodes.push(n3), e2.h.appendChild(n3);
+  }, insertBefore: function(n3, t2) {
+    this.childNodes.push(n3), e2.h.insertBefore(n3, t2);
+  }, removeChild: function(n3) {
+    this.childNodes.splice(this.childNodes.indexOf(n3) >>> 1, 1), e2.h.removeChild(n3);
+  } }), preact.render(preact.createElement(Z, { context: e2.context }, n2.__v), e2.v);
+}
+function $(n2, e2) {
+  var r2 = preact.createElement(Y, { __v: n2, h: e2 });
+  return r2.containerInfo = e2, r2;
+}
+(B.prototype = new preact.Component()).__a = function(n2) {
+  var t2 = this, e2 = j$1(t2.__v), r2 = t2.l.get(n2);
+  return r2[0]++, function(u2) {
+    var o2 = function() {
+      t2.props.revealOrder ? (r2.push(u2), H(t2, n2, r2)) : u2();
+    };
+    e2 ? e2(o2) : o2();
+  };
+}, B.prototype.render = function(n2) {
+  this.i = null, this.l = /* @__PURE__ */ new Map();
+  var t2 = preact.toChildArray(n2.children);
+  n2.revealOrder && "b" === n2.revealOrder[0] && t2.reverse();
+  for (var e2 = t2.length; e2--; ) this.l.set(t2[e2], this.i = [1, 0, this.i]);
+  return n2.children;
+}, B.prototype.componentDidUpdate = B.prototype.componentDidMount = function() {
+  var n2 = this;
+  this.l.forEach(function(t2, e2) {
+    H(n2, e2, t2);
+  });
+};
+var q = "undefined" != typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103, G = /^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/, J = /^on(Ani|Tra|Tou|BeforeInp|Compo)/, K = /[A-Z0-9]/g, Q = "undefined" != typeof document, X$1 = function(n2) {
+  return ("undefined" != typeof Symbol && "symbol" == typeof Symbol() ? /fil|che|rad/ : /fil|che|ra/).test(n2);
+};
+function nn(n2, t2, e2) {
+  return null == t2.__k && (t2.textContent = ""), preact.render(n2, t2), "function" == typeof e2 && e2(), n2 ? n2.__c : null;
+}
+function tn(n2, t2, e2) {
+  return preact.hydrate(n2, t2), "function" == typeof e2 && e2(), n2 ? n2.__c : null;
+}
+preact.Component.prototype.isReactComponent = {}, ["componentWillMount", "componentWillReceiveProps", "componentWillUpdate"].forEach(function(t2) {
+  Object.defineProperty(preact.Component.prototype, t2, { configurable: true, get: function() {
+    return this["UNSAFE_" + t2];
+  }, set: function(n2) {
+    Object.defineProperty(this, t2, { configurable: true, writable: true, value: n2 });
+  } });
+});
+var en = preact.options.event;
+function rn() {
+}
+function un() {
+  return this.cancelBubble;
+}
+function on() {
+  return this.defaultPrevented;
+}
+preact.options.event = function(n2) {
+  return en && (n2 = en(n2)), n2.persist = rn, n2.isPropagationStopped = un, n2.isDefaultPrevented = on, n2.nativeEvent = n2;
+};
+var cn, ln = { enumerable: false, configurable: true, get: function() {
+  return this.class;
+} }, fn = preact.options.vnode;
+preact.options.vnode = function(n2) {
+  "string" == typeof n2.type && function(n3) {
+    var t2 = n3.props, e2 = n3.type, u2 = {}, o2 = -1 === e2.indexOf("-");
+    for (var i2 in t2) {
+      var c2 = t2[i2];
+      if (!("value" === i2 && "defaultValue" in t2 && null == c2 || Q && "children" === i2 && "noscript" === e2 || "class" === i2 || "className" === i2)) {
+        var l2 = i2.toLowerCase();
+        "defaultValue" === i2 && "value" in t2 && null == t2.value ? i2 = "value" : "download" === i2 && true === c2 ? c2 = "" : "translate" === l2 && "no" === c2 ? c2 = false : "o" === l2[0] && "n" === l2[1] ? "ondoubleclick" === l2 ? i2 = "ondblclick" : "onchange" !== l2 || "input" !== e2 && "textarea" !== e2 || X$1(t2.type) ? "onfocus" === l2 ? i2 = "onfocusin" : "onblur" === l2 ? i2 = "onfocusout" : J.test(i2) && (i2 = l2) : l2 = i2 = "oninput" : o2 && G.test(i2) ? i2 = i2.replace(K, "-$&").toLowerCase() : null === c2 && (c2 = void 0), "oninput" === l2 && u2[i2 = l2] && (i2 = "oninputCapture"), u2[i2] = c2;
+      }
+    }
+    "select" == e2 && u2.multiple && Array.isArray(u2.value) && (u2.value = preact.toChildArray(t2.children).forEach(function(n4) {
+      n4.props.selected = -1 != u2.value.indexOf(n4.props.value);
+    })), "select" == e2 && null != u2.defaultValue && (u2.value = preact.toChildArray(t2.children).forEach(function(n4) {
+      n4.props.selected = u2.multiple ? -1 != u2.defaultValue.indexOf(n4.props.value) : u2.defaultValue == n4.props.value;
+    })), t2.class && !t2.className ? (u2.class = t2.class, Object.defineProperty(u2, "className", ln)) : (t2.className && !t2.class || t2.class && t2.className) && (u2.class = u2.className = t2.className), n3.props = u2;
+  }(n2), n2.$$typeof = q, fn && fn(n2);
+};
+var an = preact.options.__r;
+preact.options.__r = function(n2) {
+  an && an(n2), cn = n2.__c;
+};
+var sn = preact.options.diffed;
+preact.options.diffed = function(n2) {
+  sn && sn(n2);
+  var t2 = n2.props, e2 = n2.__e;
+  null != e2 && "textarea" === n2.type && "value" in t2 && t2.value !== e2.value && (e2.value = null == t2.value ? "" : t2.value), cn = null;
+};
+var hn = { ReactCurrentDispatcher: { current: { readContext: function(n2) {
+  return cn.__n[n2.__c].props.value;
+}, useCallback: q$1, useContext: x$1, useDebugValue: P$1, useDeferredValue: w, useEffect: y$2, useId: g$2, useImperativeHandle: F$1, useInsertionEffect: I, useLayoutEffect: _, useMemo: T$1, useReducer: h, useRef: A$1, useState: d, useSyncExternalStore: C, useTransition: k$1 } } }, vn = "18.3.1";
+function dn(n2) {
+  return preact.createElement.bind(null, n2);
+}
+function pn(n2) {
+  return !!n2 && n2.$$typeof === q;
+}
+function mn(n2) {
+  return pn(n2) && n2.type === preact.Fragment;
+}
+function yn(n2) {
+  return !!n2 && !!n2.displayName && ("string" == typeof n2.displayName || n2.displayName instanceof String) && n2.displayName.startsWith("Memo(");
+}
+function _n(n2) {
+  return pn(n2) ? preact.cloneElement.apply(null, arguments) : n2;
+}
+function bn(n2) {
+  return !!n2.__k && (preact.render(null, n2), true);
+}
+function Sn(n2) {
+  return n2 && (n2.base || 1 === n2.nodeType && n2) || null;
+}
+var gn = function(n2, t2) {
+  return n2(t2);
+}, En = function(n2, t2) {
+  return n2(t2);
+}, Cn = preact.Fragment, xn = pn, Rn = { useState: d, useId: g$2, useReducer: h, useEffect: y$2, useLayoutEffect: _, useInsertionEffect: I, useTransition: k$1, useDeferredValue: w, useSyncExternalStore: C, startTransition: R, useRef: A$1, useImperativeHandle: F$1, useMemo: T$1, useCallback: q$1, useContext: x$1, useDebugValue: P$1, version: "18.3.1", Children: O, render: nn, hydrate: tn, unmountComponentAtNode: bn, createPortal: $, createElement: preact.createElement, createContext: preact.createContext, createFactory: dn, cloneElement: _n, createRef: preact.createRef, Fragment: preact.Fragment, isValidElement: pn, isElement: xn, isFragment: mn, isMemo: yn, findDOMNode: Sn, Component: preact.Component, PureComponent: N, memo: M, forwardRef: D$1, flushSync: En, unstable_batchedUpdates: gn, StrictMode: Cn, Suspense: P, SuspenseList: B, lazy: z, __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: hn };
+const compat_module = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Children: O,
+  Component: preact.Component,
+  Fragment: preact.Fragment,
+  PureComponent: N,
+  StrictMode: Cn,
+  Suspense: P,
+  SuspenseList: B,
+  __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: hn,
+  cloneElement: _n,
+  createContext: preact.createContext,
+  createElement: preact.createElement,
+  createFactory: dn,
+  createPortal: $,
+  createRef: preact.createRef,
+  default: Rn,
+  findDOMNode: Sn,
+  flushSync: En,
+  forwardRef: D$1,
+  hydrate: tn,
+  isElement: xn,
+  isFragment: mn,
+  isMemo: yn,
+  isValidElement: pn,
+  lazy: z,
+  memo: M,
+  render: nn,
+  startTransition: R,
+  unmountComponentAtNode: bn,
+  unstable_batchedUpdates: gn,
+  useCallback: q$1,
+  useContext: x$1,
+  useDebugValue: P$1,
+  useDeferredValue: w,
+  useEffect: y$2,
+  useErrorBoundary: b$1,
+  useId: g$2,
+  useImperativeHandle: F$1,
+  useInsertionEffect: I,
+  useLayoutEffect: _,
+  useMemo: T$1,
+  useReducer: h,
+  useRef: A$1,
+  useState: d,
+  useSyncExternalStore: C,
+  useTransition: k$1,
+  version: vn
+}, Symbol.toStringTag, { value: "Module" }));
+function g(n2, t2) {
+  let o2;
+  return (...i2) => {
+    window.clearTimeout(o2), o2 = window.setTimeout(() => n2(...i2), t2);
+  };
+}
+function j({ debounce: n2, scroll: t2, polyfill: o2, offsetSize: i2 } = { debounce: 0, scroll: false, offsetSize: false }) {
+  const a2 = o2 || (typeof window == "undefined" ? class {
+  } : window.ResizeObserver);
+  if (!a2) throw new Error("This browser does not support ResizeObserver out of the box. See: https://github.com/react-spring/react-use-measure/#resize-observer-polyfills");
+  const [c2, h2] = d({ left: 0, top: 0, width: 0, height: 0, bottom: 0, right: 0, x: 0, y: 0 }), e2 = A$1({ element: null, scrollContainers: null, resizeObserver: null, lastBounds: c2, orientationHandler: null }), d$1 = n2 ? typeof n2 == "number" ? n2 : n2.scroll : null, f2 = n2 ? typeof n2 == "number" ? n2 : n2.resize : null, w2 = A$1(false);
+  y$2(() => (w2.current = true, () => void (w2.current = false)));
+  const [z2, m2, s2] = T$1(() => {
+    const r2 = () => {
+      if (!e2.current.element) return;
+      const { left: y2, top: C2, width: H2, height: O2, bottom: S, right: x2, x: B2, y: R2 } = e2.current.element.getBoundingClientRect(), l2 = { left: y2, top: C2, width: H2, height: O2, bottom: S, right: x2, x: B2, y: R2 };
+      e2.current.element instanceof HTMLElement && i2 && (l2.height = e2.current.element.offsetHeight, l2.width = e2.current.element.offsetWidth), Object.freeze(l2), w2.current && !D(e2.current.lastBounds, l2) && h2(e2.current.lastBounds = l2);
+    };
+    return [r2, f2 ? g(r2, f2) : r2, d$1 ? g(r2, d$1) : r2];
+  }, [h2, i2, d$1, f2]);
+  function v2() {
+    e2.current.scrollContainers && (e2.current.scrollContainers.forEach((r2) => r2.removeEventListener("scroll", s2, true)), e2.current.scrollContainers = null), e2.current.resizeObserver && (e2.current.resizeObserver.disconnect(), e2.current.resizeObserver = null), e2.current.orientationHandler && ("orientation" in screen && "removeEventListener" in screen.orientation ? screen.orientation.removeEventListener("change", e2.current.orientationHandler) : "onorientationchange" in window && window.removeEventListener("orientationchange", e2.current.orientationHandler));
+  }
+  function b2() {
+    e2.current.element && (e2.current.resizeObserver = new a2(s2), e2.current.resizeObserver.observe(e2.current.element), t2 && e2.current.scrollContainers && e2.current.scrollContainers.forEach((r2) => r2.addEventListener("scroll", s2, { capture: true, passive: true })), e2.current.orientationHandler = () => {
+      s2();
+    }, "orientation" in screen && "addEventListener" in screen.orientation ? screen.orientation.addEventListener("change", e2.current.orientationHandler) : "onorientationchange" in window && window.addEventListener("orientationchange", e2.current.orientationHandler));
+  }
+  const L2 = (r2) => {
+    !r2 || r2 === e2.current.element || (v2(), e2.current.element = r2, e2.current.scrollContainers = E(r2), b2());
+  };
+  return X(s2, !!t2), W(m2), y$2(() => {
+    v2(), b2();
+  }, [t2, s2, m2]), y$2(() => v2, []), [L2, c2, z2];
+}
+function W(n2) {
+  y$2(() => {
+    const t2 = n2;
+    return window.addEventListener("resize", t2), () => void window.removeEventListener("resize", t2);
+  }, [n2]);
+}
+function X(n2, t2) {
+  y$2(() => {
+    if (t2) {
+      const o2 = n2;
+      return window.addEventListener("scroll", o2, { capture: true, passive: true }), () => void window.removeEventListener("scroll", o2, true);
+    }
+  }, [n2, t2]);
+}
+function E(n2) {
+  const t2 = [];
+  if (!n2 || n2 === document.body) return t2;
+  const { overflow: o2, overflowX: i2, overflowY: a2 } = window.getComputedStyle(n2);
+  return [o2, i2, a2].some((c2) => c2 === "auto" || c2 === "scroll") && t2.push(n2), [...t2, ...E(n2.parentElement)];
+}
+const k = ["x", "y", "top", "bottom", "left", "right", "width", "height"], D = (n2, t2) => k.every((o2) => n2[o2] === t2[o2]);
+function getAugmentedNamespace(n2) {
+  if (n2.__esModule) return n2;
+  var f2 = n2.default;
+  if (typeof f2 == "function") {
+    var a2 = function a3() {
+      if (this instanceof a3) {
+        return Reflect.construct(f2, arguments, this.constructor);
+      }
+      return f2.apply(this, arguments);
+    };
+    a2.prototype = f2.prototype;
+  } else a2 = {};
+  Object.defineProperty(a2, "__esModule", { value: true });
+  Object.keys(n2).forEach(function(k2) {
+    var d2 = Object.getOwnPropertyDescriptor(n2, k2);
+    Object.defineProperty(a2, k2, d2.get ? d2 : {
+      enumerable: true,
+      get: function() {
+        return n2[k2];
+      }
+    });
+  });
+  return a2;
+}
+var shim$1 = { exports: {} };
+var useSyncExternalStoreShim_production_min$1 = {};
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace(compat_module);
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_production_min$1;
+function requireUseSyncExternalStoreShim_production_min$1() {
+  if (hasRequiredUseSyncExternalStoreShim_production_min$1) return useSyncExternalStoreShim_production_min$1;
+  hasRequiredUseSyncExternalStoreShim_production_min$1 = 1;
+  var e2 = require$$0;
+  function h2(a2, b2) {
+    return a2 === b2 && (0 !== a2 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+  }
+  var k2 = "function" === typeof Object.is ? Object.is : h2, l2 = e2.useState, m2 = e2.useEffect, n2 = e2.useLayoutEffect, p2 = e2.useDebugValue;
+  function q2(a2, b2) {
+    var d2 = b2(), f2 = l2({ inst: { value: d2, getSnapshot: b2 } }), c2 = f2[0].inst, g2 = f2[1];
+    n2(function() {
+      c2.value = d2;
+      c2.getSnapshot = b2;
+      r2(c2) && g2({ inst: c2 });
+    }, [a2, d2, b2]);
+    m2(function() {
+      r2(c2) && g2({ inst: c2 });
+      return a2(function() {
+        r2(c2) && g2({ inst: c2 });
+      });
+    }, [a2]);
+    p2(d2);
+    return d2;
+  }
+  function r2(a2) {
+    var b2 = a2.getSnapshot;
+    a2 = a2.value;
+    try {
+      var d2 = b2();
+      return !k2(a2, d2);
+    } catch (f2) {
+      return true;
+    }
+  }
+  function t2(a2, b2) {
+    return b2();
+  }
+  var u2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t2 : q2;
+  useSyncExternalStoreShim_production_min$1.useSyncExternalStore = void 0 !== e2.useSyncExternalStore ? e2.useSyncExternalStore : u2;
+  return useSyncExternalStoreShim_production_min$1;
+}
+var useSyncExternalStoreShim_development$1 = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_development$1;
+function requireUseSyncExternalStoreShim_development$1() {
+  if (hasRequiredUseSyncExternalStoreShim_development$1) return useSyncExternalStoreShim_development$1;
+  hasRequiredUseSyncExternalStoreShim_development$1 = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React = require$$0;
+      var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+      function error(format) {
+        {
+          {
+            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+            printWarning("error", format, args);
+          }
+        }
+      }
+      function printWarning(level, format, args) {
+        {
+          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+          var stack = ReactDebugCurrentFrame.getStackAddendum();
+          if (stack !== "") {
+            format += "%s";
+            args = args.concat([stack]);
+          }
+          var argsWithFormat = args.map(function(item) {
+            return String(item);
+          });
+          argsWithFormat.unshift("Warning: " + format);
+          Function.prototype.apply.call(console[level], console, argsWithFormat);
+        }
+      }
+      function is(x2, y2) {
+        return x2 === y2 && (x2 !== 0 || 1 / x2 === 1 / y2) || x2 !== x2 && y2 !== y2;
+      }
+      var objectIs = typeof Object.is === "function" ? Object.is : is;
+      var useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue;
+      var didWarnOld18Alpha = false;
+      var didWarnUncachedGetSnapshot = false;
+      function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+        {
+          if (!didWarnOld18Alpha) {
+            if (React.startTransition !== void 0) {
+              didWarnOld18Alpha = true;
+              error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.");
+            }
+          }
+        }
+        var value = getSnapshot();
+        {
+          if (!didWarnUncachedGetSnapshot) {
+            var cachedValue = getSnapshot();
+            if (!objectIs(value, cachedValue)) {
+              error("The result of getSnapshot should be cached to avoid an infinite loop");
+              didWarnUncachedGetSnapshot = true;
+            }
+          }
+        }
+        var _useState = useState({
+          inst: {
+            value,
+            getSnapshot
+          }
+        }), inst = _useState[0].inst, forceUpdate = _useState[1];
+        useLayoutEffect(function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+        }, [subscribe, value, getSnapshot]);
+        useEffect(function() {
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+          var handleStoreChange = function() {
+            if (checkIfSnapshotChanged(inst)) {
+              forceUpdate({
+                inst
+              });
+            }
+          };
+          return subscribe(handleStoreChange);
+        }, [subscribe]);
+        useDebugValue(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        var prevValue = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(prevValue, nextValue);
+        } catch (error2) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+        return getSnapshot();
+      }
+      var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+      var isServerEnvironment = !canUseDOM;
+      var shim2 = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+      var useSyncExternalStore$2 = React.useSyncExternalStore !== void 0 ? React.useSyncExternalStore : shim2;
+      useSyncExternalStoreShim_development$1.useSyncExternalStore = useSyncExternalStore$2;
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
+  }
+  return useSyncExternalStoreShim_development$1;
+}
+var hasRequiredShim$1;
+function requireShim$1() {
+  if (hasRequiredShim$1) return shim$1.exports;
+  hasRequiredShim$1 = 1;
+  if (process.env.NODE_ENV === "production") {
+    shim$1.exports = requireUseSyncExternalStoreShim_production_min$1();
+  } else {
+    shim$1.exports = requireUseSyncExternalStoreShim_development$1();
+  }
+  return shim$1.exports;
+}
+var shimExports$1 = requireShim$1();
+var withSelector$1 = { exports: {} };
+var withSelector_production_min$1 = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredWithSelector_production_min$1;
+function requireWithSelector_production_min$1() {
+  if (hasRequiredWithSelector_production_min$1) return withSelector_production_min$1;
+  hasRequiredWithSelector_production_min$1 = 1;
+  var h2 = require$$0, n2 = requireShim$1();
+  function p2(a2, b2) {
+    return a2 === b2 && (0 !== a2 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+  }
+  var q2 = "function" === typeof Object.is ? Object.is : p2, r2 = n2.useSyncExternalStore, t2 = h2.useRef, u2 = h2.useEffect, v2 = h2.useMemo, w2 = h2.useDebugValue;
+  withSelector_production_min$1.useSyncExternalStoreWithSelector = function(a2, b2, e2, l2, g2) {
+    var c2 = t2(null);
+    if (null === c2.current) {
+      var f2 = { hasValue: false, value: null };
+      c2.current = f2;
+    } else f2 = c2.current;
+    c2 = v2(function() {
+      function a3(a4) {
+        if (!c3) {
+          c3 = true;
+          d3 = a4;
+          a4 = l2(a4);
+          if (void 0 !== g2 && f2.hasValue) {
+            var b3 = f2.value;
+            if (g2(b3, a4)) return k2 = b3;
+          }
+          return k2 = a4;
+        }
+        b3 = k2;
+        if (q2(d3, a4)) return b3;
+        var e3 = l2(a4);
+        if (void 0 !== g2 && g2(b3, e3)) return b3;
+        d3 = a4;
+        return k2 = e3;
+      }
+      var c3 = false, d3, k2, m2 = void 0 === e2 ? null : e2;
+      return [function() {
+        return a3(b2());
+      }, null === m2 ? void 0 : function() {
+        return a3(m2());
+      }];
+    }, [b2, e2, l2, g2]);
+    var d2 = r2(a2, c2[0], c2[1]);
+    u2(function() {
+      f2.hasValue = true;
+      f2.value = d2;
+    }, [d2]);
+    w2(d2);
+    return d2;
+  };
+  return withSelector_production_min$1;
+}
+var withSelector_development$1 = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredWithSelector_development$1;
+function requireWithSelector_development$1() {
+  if (hasRequiredWithSelector_development$1) return withSelector_development$1;
+  hasRequiredWithSelector_development$1 = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React = require$$0;
+      var shim2 = requireShim$1();
+      function is(x2, y2) {
+        return x2 === y2 && (x2 !== 0 || 1 / x2 === 1 / y2) || x2 !== x2 && y2 !== y2;
+      }
+      var objectIs = typeof Object.is === "function" ? Object.is : is;
+      var useSyncExternalStore = shim2.useSyncExternalStore;
+      var useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+      function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+        var instRef = useRef(null);
+        var inst;
+        if (instRef.current === null) {
+          inst = {
+            hasValue: false,
+            value: null
+          };
+          instRef.current = inst;
+        } else {
+          inst = instRef.current;
+        }
+        var _useMemo = useMemo(function() {
+          var hasMemo = false;
+          var memoizedSnapshot;
+          var memoizedSelection;
+          var memoizedSelector = function(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = true;
+              memoizedSnapshot = nextSnapshot;
+              var _nextSelection = selector(nextSnapshot);
+              if (isEqual !== void 0) {
+                if (inst.hasValue) {
+                  var currentSelection = inst.value;
+                  if (isEqual(currentSelection, _nextSelection)) {
+                    memoizedSelection = currentSelection;
+                    return currentSelection;
+                  }
+                }
+              }
+              memoizedSelection = _nextSelection;
+              return _nextSelection;
+            }
+            var prevSnapshot = memoizedSnapshot;
+            var prevSelection = memoizedSelection;
+            if (objectIs(prevSnapshot, nextSnapshot)) {
+              return prevSelection;
+            }
+            var nextSelection = selector(nextSnapshot);
+            if (isEqual !== void 0 && isEqual(prevSelection, nextSelection)) {
+              return prevSelection;
+            }
+            memoizedSnapshot = nextSnapshot;
+            memoizedSelection = nextSelection;
+            return nextSelection;
+          };
+          var maybeGetServerSnapshot = getServerSnapshot === void 0 ? null : getServerSnapshot;
+          var getSnapshotWithSelector = function() {
+            return memoizedSelector(getSnapshot());
+          };
+          var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? void 0 : function() {
+            return memoizedSelector(maybeGetServerSnapshot());
+          };
+          return [getSnapshotWithSelector, getServerSnapshotWithSelector];
+        }, [getSnapshot, getServerSnapshot, selector, isEqual]), getSelection = _useMemo[0], getServerSelection = _useMemo[1];
+        var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
+        useEffect(function() {
+          inst.hasValue = true;
+          inst.value = value;
+        }, [value]);
+        useDebugValue(value);
+        return value;
+      }
+      withSelector_development$1.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
+  }
+  return withSelector_development$1;
+}
+var hasRequiredWithSelector$1;
+function requireWithSelector$1() {
+  if (hasRequiredWithSelector$1) return withSelector$1.exports;
+  hasRequiredWithSelector$1 = 1;
+  if (process.env.NODE_ENV === "production") {
+    withSelector$1.exports = requireWithSelector_production_min$1();
+  } else {
+    withSelector$1.exports = requireWithSelector_development$1();
+  }
+  return withSelector$1.exports;
+}
+requireWithSelector$1();
+var y$1 = (t2, e2, n2) => {
+  var _a, _b;
+  let r2 = A$1((_a = t2 == null ? void 0 : t2.resolve) == null ? void 0 : _a.call(t2, e2, n2)), s2 = ((_b = t2 == null ? void 0 : t2.keyOfEntity) == null ? void 0 : _b.call(t2, e2)) ?? e2, u2 = q$1((o2) => {
+    var _a2, _b2;
+    return s2 ? (r2.current = (_a2 = t2 == null ? void 0 : t2.resolve) == null ? void 0 : _a2.call(t2, s2, n2), o2(), (_b2 = t2 == null ? void 0 : t2.subscribe) == null ? void 0 : _b2.call(t2, s2, () => {
+      var _a3;
+      return r2.current = (_a3 = t2 == null ? void 0 : t2.resolve) == null ? void 0 : _a3.call(t2, s2, n2), o2();
+    }, n2)) : () => {
+    };
+  }, [t2, s2]), i2 = q$1((o2) => {
+    let p2 = typeof e2 == "string" ? e2 : t2.keyOfEntity(e2);
+    e2 && p2 && t2.mutate(p2, o2);
+  }, [t2, e2]), a2 = () => r2.current;
+  return [shimExports$1.useSyncExternalStore(u2, a2, a2), i2];
+};
+const FragmentContext = preact.createContext({
+  manager: null
+});
+const FragmentProvider = ({ children, manager }) => {
+  return /* @__PURE__ */ u$1(FragmentContext.Provider, { value: { manager }, children });
+};
+const useLayerChildren = (layerKey, customManager) => {
+  const { manager: fragmentManager } = x$1(FragmentContext);
+  const [layerData] = y$1(customManager ?? fragmentManager, layerKey);
+  return (layerData == null ? void 0 : layerData.children) ?? [];
+};
+var toPx = (val) => typeof val === "string" || typeof val === "number" ? `${val}px` : "0px";
+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 toKebabCase = (value) => value.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($2, ofs) => (ofs ? "-" : "") + $2.toLowerCase());
+var pick = (obj, ...props) => {
+  return props.reduce((result, prop) => {
+    result[prop] = obj[prop];
+    return result;
+  }, {});
+};
+var generateId = () => Math.random().toString(16).slice(2);
+const nodes$1 = createConstants$1(
+  "Fragment",
+  "FragmentInstance",
+  "Instance",
+  "Breakpoint",
+  "Frame",
+  "Image",
+  "Text",
+  "SolidPaintStyle",
+  "CssLink",
+  "Variable",
+  "ComputedValue",
+  "TransformValue"
+);
+const fragmentGrowingMode$1 = createConstants$1("auto", "fill");
+const borderType$1 = createConstants$1("None", "Solid", "Dashed", "Dotted");
+createConstants$1("_blank");
+const paintMode$1 = createConstants$1("None", "Solid", "Image");
+createConstants$1(
+  "Fill",
+  "Fit",
+  "Crop",
+  "Tile"
+);
+createConstants$1(
+  "Min",
+  "Center",
+  "Max",
+  "Stretch",
+  "Scale"
+);
+const positionType$1 = createConstants$1("absolute", "relative");
+const sizing$1 = createConstants$1("Fixed", "Hug", "Fill", "Relative");
+const layerMode$1 = createConstants$1("none", "flex");
+const layerDirection$1 = createConstants$1("vertical", "horizontal");
+createConstants$1("start", "center", "end");
+createConstants$1(
+  "start",
+  "center",
+  "end",
+  "space-between",
+  "space-around"
+);
+createConstants$1(
+  "none",
+  "uppercase",
+  "lowercase",
+  "capitalize"
+);
+createConstants$1(
+  "none",
+  "underline",
+  "line-through"
+);
+createConstants$1("loop", "appear", "hover", "tap");
+createConstants$1(
+  "fade",
+  "slide",
+  "bounce",
+  "wiggle",
+  "increase"
+);
+createConstants$1(
+  "String",
+  "Boolean",
+  "Array",
+  "Color",
+  "ComponentInstance",
+  "Date",
+  "Enum",
+  "Number",
+  "Object"
+);
+createConstants$1(
+  "normal",
+  "nowrap",
+  "pre",
+  "pre-wrap",
+  "pre-line",
+  "break-spaces"
+);
+createConstants$1("visible", "hidden", "scroll");
+createConstants$1(
+  "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$1 = createConstants$1("canvas", "document");
+createConstants$1("viewport", "parent", "fixed");
+var t = (e2) => !e2 && e2 == null, s = (e2) => !t(e2), y$3 = (e2) => typeof e2 == "object" && !Array.isArray(e2) && s(e2), a = (e2) => typeof Node == "object" ? e2 instanceof Node : e2 && typeof e2 == "object" && typeof e2.nodeType == "number" && typeof e2.nodeName == "string", p = (e2) => typeof e2 == "string" || n(e2), n = (e2) => typeof e2 == "object" && typeof e2._type == "string", r = (e2) => typeof e2 == "string" && e2.split(":").length >= 2, i = (e2) => typeof e2 != "object" && typeof e2 != "function" || e2 === null, b = (e2) => typeof e2 == "string" ? /<\/?[a-z][\s\S]*>/i.test(e2) : false;
+var isLinkKey = (input) => r(input);
+var isGraphOrKey = (input) => p(input);
+var isGraph = (input) => n(input);
+var isObject = (input) => y$3(input);
+var shallowEqual = (a2, b2) => {
+  if (a2 === b2)
+    return true;
+  if (Array.isArray(a2) && Array.isArray(b2)) {
+    return a2.length === b2.length && a2.every((val, index2) => b2[index2] === val);
+  }
+  if (!isObject(a2) || !isObject(b2))
+    return false;
+  const keysA = Object.keys(a2);
+  const keysB = Object.keys(b2);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key))
+      return false;
+  }
+  return true;
+};
+var unique = (...values) => Array.from(new Set(values));
+var uniqueLinks = (...values) => values.filter((item, index2, arr) => r(item) ? arr.indexOf(item) === index2 : true);
+var isPartialKey = (key) => key && key.split(".").length > 1;
+var isPartOfGraph = (entityKey, graphKey) => {
+  if (!entityKey || !graphKey)
+    return false;
+  if (typeof entityKey !== "string" || typeof graphKey !== "string")
+    return null;
+  const [entityType, entityId] = entityKey.split(":");
+  const [graphType, graphId] = graphKey.split(":");
+  if (entityType !== graphType)
+    return false;
+  return entityId.startsWith(graphId);
+};
+var getGraphLink = (input) => {
+  if (isLinkKey(input)) {
+    if (isPartialKey(input)) {
+      return input.split(".")[0];
+    }
+  }
+  return input;
+};
+var createCache = () => {
+  const listeners = /* @__PURE__ */ new Map();
+  const types = /* @__PURE__ */ new Map();
+  const links = /* @__PURE__ */ new Map();
+  const parentRefs = /* @__PURE__ */ new Map();
+  const childrenRefs = /* @__PURE__ */ new Map();
+  const refCount = /* @__PURE__ */ new Map();
+  const gbLinks = /* @__PURE__ */ new Set([]);
+  const addRefs = (targetKey, depKey) => {
+    var _a;
+    parentRefs.set(targetKey, unique(...parentRefs.get(targetKey) || [], depKey));
+    childrenRefs.set(depKey, unique(...childrenRefs.get(depKey) ?? [], targetKey));
+    updateRefCountForLink(targetKey, ((_a = parentRefs.get(targetKey)) == null ? void 0 : _a.length) || 0);
+  };
+  const removeRefs = (targetKey, depKey) => {
+    var _a;
+    parentRefs.set(
+      depKey,
+      (parentRefs.get(depKey) || []).filter((key) => key !== targetKey)
+    );
+    childrenRefs.set(
+      targetKey,
+      (childrenRefs.get(targetKey) ?? []).filter((key) => key !== depKey)
+    );
+    updateRefCountForLink(depKey, ((_a = parentRefs.get(depKey)) == null ? void 0 : _a.length) || 0);
+  };
+  const getLinkedRefs = (key, stack = []) => {
+    const deps = parentRefs.get(key) || [];
+    stack.push(...deps);
+    const deepDeps = deps.map((ref) => getLinkedRefs(ref, stack)).flat();
+    stack.push(...deepDeps);
+    return Array.from(new Set(stack).values());
+  };
+  const invalidate = (key) => {
+    updateRefCountForLink(key, 0);
+    runGarbageCollector();
+  };
+  const readLink = (key) => {
+    if (key) {
+      return links.get(key);
+    }
+    return null;
+  };
+  const writeLink = (key, value, depKey) => {
+    var _a;
+    if (typeof key === "string") {
+      links.set(key, value);
+      const [type] = key.split(":");
+      if (!isPartialKey(key)) {
+        if (!types.has(type)) {
+          types.set(type, /* @__PURE__ */ new Set([key]));
+        } else {
+          (_a = types.get(type)) == null ? void 0 : _a.add(key);
+        }
+      }
+    }
+    if (depKey && key && key !== depKey) {
+      addRefs(key, depKey);
+    }
+  };
+  const hasLink = (key) => {
+    if (key) {
+      return links.has(key);
+    }
+    return false;
+  };
+  const updateRefCountForLink = (link, count) => {
+    if (Array.isArray(link)) {
+      link.forEach((link2, index2) => updateRefCountForLink(link2, index2));
+    } else {
+      const prevCount = refCount.get(link);
+      refCount.set(link, count);
+      if (!count) {
+        gbLinks.add(link);
+      } else if (!prevCount && count) {
+        gbLinks.delete(link);
+      }
+    }
+  };
+  const getLinkEntries = () => Array.from(links.entries());
+  const getRefCount = (link) => refCount.get(link) ?? 0;
+  const runGarbageCollector = () => {
+    var _a, _b;
+    for (const link of gbLinks.keys()) {
+      const count = getRefCount(link);
+      if (count > 0)
+        continue;
+      const currentValue = links.get(link);
+      gbLinks.delete(link);
+      links.delete(link);
+      refCount.delete(link);
+      const parents = parentRefs.get(link) ?? [];
+      const children = childrenRefs.get(link) ?? [];
+      parents.forEach((parentKey) => {
+        var _a2, _b2;
+        childrenRefs.set(parentKey, ((_b2 = (_a2 = childrenRefs.get(parentKey)) == null ? void 0 : _a2.filter) == null ? void 0 : _b2.call(_a2, (childLink) => childLink !== link)) ?? []);
+      });
+      children.forEach((childKey) => {
+        updateRefCountForLink(childKey, getRefCount(childKey) - 1);
+      });
+      const [type] = link.split(":");
+      if (!isPartialKey(link)) {
+        (_a = types.get(type)) == null ? void 0 : _a.delete(link);
+        if (!((_b = types.get(type)) == null ? void 0 : _b.size)) {
+          types.delete(type);
+        }
+      }
+      parentRefs.delete(link);
+      (listeners.get("onRemoveLink") ?? []).forEach((listener) => listener(link, currentValue ?? null));
+    }
+  };
+  return {
+    readLink,
+    writeLink,
+    hasLink,
+    getLinkEntries,
+    parentRefs,
+    childrenRefs,
+    addRefs,
+    removeRefs,
+    getChildren: (key) => childrenRefs.get(key),
+    getParents: (key) => parentRefs.get(key),
+    getLinkedRefs,
+    invalidate,
+    links,
+    types,
+    refCount,
+    runGarbageCollector,
+    onRemoveLink: (callback) => listeners.set("onRemoveLink", [...(listeners == null ? void 0 : listeners.get("onRemoveLink")) ?? [], callback])
+  };
+};
+var joinKeys = (...keys) => {
+  var _a;
+  return (_a = keys == null ? void 0 : keys.filter(Boolean)) == null ? void 0 : _a.join(".");
+};
+var isDev = process.env.NODE_ENV !== "production";
+var createPluginsState = (initialPlugins = []) => {
+  const plugins = [];
+  const use = (plugin) => {
+    plugins.push(plugin);
+  };
+  const runPlugins = (state) => {
+    return plugins.reduce((graphState, plugin) => plugin(graphState) ?? graphState, state);
+  };
+  initialPlugins.forEach(use);
+  return {
+    use,
+    runPlugins
+  };
+};
+var isGraphState = (input) => {
+  if (!input)
+    return false;
+  if (isObject(input)) {
+    const fields = ["_id", "_type", "key", "mutate", "resolve"];
+    return fields.every((field) => field in input);
+  }
+  return false;
+};
+var createDebugState = () => {
+  const listeners = /* @__PURE__ */ new Set();
+  const onDebugEvent = (callback) => {
+    listeners.add(callback);
+  };
+  const debug = (event) => {
+    listeners.forEach((callback) => {
+      callback({ ...event, timestamp: Date.now() });
+    });
+  };
+  return {
+    debug,
+    onDebugEvent
+  };
+};
+var ID = 0;
+var DEEP_LIMIT = 100;
+var STATE_TYPE = "State";
+var EACH_UPDATED = "$EACH:ROOT$";
+var createState = (options2) => {
+  const id = (options2 == null ? void 0 : options2._id) ?? `${ID++}`;
+  const type = (options2 == null ? void 0 : options2._type) ?? STATE_TYPE;
+  const keys = (options2 == null ? void 0 : options2.keys) ?? {};
+  const stateKey = `${type}:${id}`;
+  const skipPredictors = [isGraphState, ...(options2 == null ? void 0 : options2.skip) ?? []];
+  const cache = createCache();
+  const debugState = createDebugState();
+  const pluginsStore = createPluginsState(options2 == null ? void 0 : options2.plugins);
+  const subscribers = /* @__PURE__ */ new Map();
+  let deepIndex = 0;
+  const isSkipped = (entity) => {
+    return skipPredictors.some((predictor) => predictor(entity));
+  };
+  const resolve = (input, options22) => {
+    const isDeep = (options22 == null ? void 0 : options22.deep) ?? false;
+    const isSafe = (options22 == null ? void 0 : options22.safe) ?? false;
+    const { selector, ...coreOptions } = options22 || {};
+    const inputKey = s(input) ? keyOfEntity(input) : null;
+    debugState.debug({ type: "resolve", entity: input, options: options22 });
+    let value = inputKey ? cache.readLink(inputKey) : null;
+    if (isSkipped(value))
+      return value;
+    if (isObject(value) || Array.isArray(value)) {
+      value = Object.entries(value).reduce((acc, [key, value2]) => {
+        let resultValue = value2;
+        if (!isSkipped(resultValue)) {
+          if (Array.isArray(value2)) {
+            resultValue = value2.map((v2) => {
+              if (isSkipped(v2))
+                return v2;
+              if (isLinkKey(v2) && !isSafe && !cache.hasLink(v2)) {
+                return null;
+              }
+              return isPartOfGraph(v2, inputKey) || isDeep ? safeResolve(v2, coreOptions) : v2;
+            });
+            if (!isSafe) {
+              resultValue = resultValue.filter(s);
+            }
+          } else {
+            if (isLinkKey(value2) && !isSafe && !cache.hasLink(value2)) {
+              resultValue = null;
+            } else if (isPartOfGraph(keyOfEntity(value2), inputKey) || isDeep) {
+              resultValue = safeResolve(value2, coreOptions);
+            }
+          }
+        }
+        acc[key] = resultValue;
+        return acc;
+      }, {});
+    }
+    return value ? selector ? selector({ ...value }) : { ...value } : isSafe ? input : null;
+  };
+  const safeResolve = (input, options22) => resolve(input, options22) ?? input;
+  const unlinkGraph = (entity) => {
+    const graphKey = keyOfEntity(entity);
+    if (graphKey) {
+      const deps = cache.getChildren(graphKey) || [];
+      deps.forEach((depLink) => {
+        if (!isPartialKey(depLink)) {
+          cache.removeRefs(graphKey, depLink);
+        }
+      });
+    }
+  };
+  const mutateField = (input, parentFieldKey, options22) => {
+    var _a, _b, _c, _d;
+    if ((!input || i(input)) && !isLinkKey(input) || isSkipped(input)) {
+      return input;
+    }
+    const inputLinkKey = isGraphOrKey(input) ? keyOfEntity(input) : input;
+    if (isLinkKey(inputLinkKey)) {
+      const parentGraph = getGraphLink(parentFieldKey) ?? "";
+      const parentPaths = ((_a = options22 == null ? void 0 : options22.internal) == null ? void 0 : _a.visitors.get(parentGraph)) ?? [];
+      const visitorsPaths = ((_b = options22 == null ? void 0 : options22.internal) == null ? void 0 : _b.visitors.get(inputLinkKey)) ?? [];
+      if (parentPaths.includes(inputLinkKey) || inputLinkKey === parentGraph) {
+        return null;
+      }
+      (_d = (_c = options22 == null ? void 0 : options22.internal) == null ? void 0 : _c.visitors) == null ? void 0 : _d.set(inputLinkKey, [...visitorsPaths, parentGraph]);
+    }
+    if (Array.isArray(input)) {
+      return input.map((item, index2) => {
+        const indexKey = parentFieldKey ? joinKeys(parentFieldKey, `${index2}`) : void 0;
+        return mutateField(item, indexKey, options22);
+      });
+    }
+    const entityKey = isLinkKey(input) ? input : isGraph(input) ? keyOfEntity(input) : null;
+    const childKey = entityKey ?? parentFieldKey;
+    const mutateMethod = (options22 == null ? void 0 : options22.overrideMutateMethod) || mutate;
+    return mutateMethod(childKey, input, options22);
+  };
+  const mutate = (entity, ...args) => {
+    const { graphKey: entityGraphKey, options: options22, data: rawData } = getArgumentsForMutate(entity, ...args);
+    debugState.debug({ type: "beforeMutate", entity: entityGraphKey, data: rawData, options: options22 });
+    const data = isLinkKey(rawData) ? entityOfKey(rawData) : rawData;
+    const graphKey = entityGraphKey ?? stateKey;
+    const partialKey = isPartialKey == null ? void 0 : isPartialKey(graphKey);
+    const parentKey = options22 == null ? void 0 : options22.parent;
+    const prevGraph = resolve(graphKey ?? "");
+    const internal = (options22 == null ? void 0 : options22.internal) || { hasChange: false, visitors: /* @__PURE__ */ new Map([]), updatedFields: [] };
+    let graphData = {
+      ...data,
+      ...entityOfKey(graphKey)
+    };
+    const isTopLevelGraph = !(options22 == null ? void 0 : options22.parent);
+    const isReplace = (options22 == null ? void 0 : options22.replace) ? typeof (options22 == null ? void 0 : options22.replace) === "function" ? options22.replace(graphData) : (options22 == null ? void 0 : options22.replace) === "deep" ? true : isTopLevelGraph || partialKey : false;
+    if (isSkipped(data)) {
+      cache.writeLink(graphKey, data, parentKey);
+      return graphKey;
+    }
+    if (!isReplace && isObject(prevGraph) && isObject(graphData)) {
+      graphData = {
+        ...prevGraph,
+        ...graphData
+      };
+    }
+    if (isReplace) {
+      unlinkGraph(graphKey);
+    }
+    const nextGraph = Object.entries(graphData).reduce((acc, [key, value]) => {
+      const fieldKey = joinKeys(graphKey, key);
+      let fieldValue = value;
+      const prevValue = prevGraph == null ? void 0 : prevGraph[key];
+      if (!isSkipped(fieldValue)) {
+        if (isObject(fieldValue) || Array.isArray(fieldValue) || isLinkKey(fieldValue)) {
+          fieldValue = mutateField(fieldValue, fieldKey, {
+            ...options22,
+            parent: graphKey,
+            internal
+          });
+        }
+        if (!isReplace && Array.isArray(fieldValue) && Array.isArray(prevValue)) {
+          fieldValue = [...prevValue, ...fieldValue];
+        }
+        if (Array.isArray(fieldValue) && (options22 == null ? void 0 : options22.dedup) !== false) {
+          fieldValue = uniqueLinks(...fieldValue);
+        }
+      }
+      const isEqual = shallowEqual(prevValue, fieldKey === fieldValue ? safeResolve(fieldValue) : fieldValue);
+      internal.hasChange = internal.hasChange || !isEqual;
+      if ((!parentKey || partialKey) && !isEqual) {
+        internal.updatedFields.push(partialKey ? graphKey : key);
+      }
+      if (!isReplace && isLinkKey(prevValue) && prevValue !== fieldValue) {
+        cache.removeRefs(graphKey, prevValue);
+      }
+      acc[key] = fieldValue;
+      return acc;
+    }, {});
+    cache.writeLink(graphKey, nextGraph, parentKey);
+    if (!parentKey) {
+      cache.runGarbageCollector();
+    }
+    if (internal.hasChange) {
+      notify(graphKey, prevGraph, internal.updatedFields);
+    }
+    debugState.debug({
+      type: "afterMutate",
+      entity: entityGraphKey,
+      data: rawData,
+      nextData: nextGraph,
+      options: options22,
+      hasChange: internal.hasChange
+    });
+    return graphKey;
+  };
+  const invalidate = (entity) => {
+    const key = keyOfEntity(entity);
+    debugState.debug({ type: "invalidate", entity: key });
+    if (key) {
+      const parents = cache.getParents(key) || [];
+      cache.invalidate(key);
+      parents.forEach((parentKey) => {
+        const prevParent = cache.readLink(parentKey);
+        const freshParent = resolve(parentKey, { safe: false });
+        cache.writeLink(parentKey, freshParent);
+        notify(parentKey, prevParent);
+      });
+    }
+  };
+  const notify = (entity, prevState, updatedFields = []) => {
+    var _a;
+    if (deepIndex > DEEP_LIMIT) {
+      throw new Error("Too deep notify.");
+    }
+    const key = keyOfEntity(entity);
+    debugState.debug({ type: "notify", entity: key });
+    if (key) {
+      deepIndex++;
+      const subs = subscribers.get(key) || [];
+      const deps = cache.getChildren(key) || [];
+      const nextResult = resolve(key);
+      const getSelectedValues = (selector) => {
+        const next = nextResult && (selector == null ? void 0 : selector(nextResult));
+        const prev = prevState && (selector == null ? void 0 : selector(prevState));
+        const hasChange = !!next !== !!prev || updatedFields.some((key2) => key2 in next);
+        return { next, prev, hasChange };
+      };
+      (_a = subscribers.get(EACH_UPDATED)) == null ? void 0 : _a.forEach(({ callback, selector }) => {
+        if (selector) {
+          const { next, prev, hasChange } = getSelectedValues(selector);
+          if (hasChange)
+            callback(next, prev);
+        } else {
+          callback(nextResult, prevState);
+        }
+      });
+      subs.forEach(({ callback, selector }) => {
+        if (selector) {
+          const { next, prev, hasChange } = getSelectedValues(selector);
+          if (hasChange)
+            callback(next, prev);
+        } else {
+          callback(nextResult, prevState);
+        }
+      });
+      deps.forEach((dep) => notify(dep, prevState));
+    }
+    deepIndex = 0;
+  };
+  const subscribe = (...args) => {
+    const input = typeof args[0] === "function" ? EACH_UPDATED : args[0];
+    const callback = typeof args[0] === "function" ? args[0] : args[1];
+    const options22 = typeof args[0] === "function" ? args[1] : args[2];
+    const key = keyOfEntity(input);
+    const selector = options22 == null ? void 0 : options22.selector;
+    if (key) {
+      if (subscribers.has(key)) {
+        subscribers.set(key, [...Array.from(subscribers.get(key) || []), { callback, selector }]);
+      } else {
+        subscribers.set(key, [{ callback, selector }]);
+      }
+      cache.onRemoveLink((link, prevValue) => {
+        if (link === key) {
+          notify(key, prevValue);
+        }
+      });
+    }
+    const unsubscribe = () => {
+      if (key) {
+        const subIndex = (subscribers.get(key) || []).findIndex((sub) => sub.callback === callback);
+        if (subIndex !== -1) {
+          const nextSubscribers = subscribers.get(key) || [];
+          nextSubscribers.splice(subIndex, 1);
+          subscribers.set(key, nextSubscribers);
+        }
+      }
+    };
+    if (options22 == null ? void 0 : options22.signal) {
+      options22.signal.addEventListener("abort", unsubscribe, { once: true });
+    }
+    return unsubscribe;
+  };
+  const inspectFields = (graphType) => [...cache.types.get(graphType) ?? []];
+  const resolveParents = (field) => {
+    const key = (typeof field === "string" ? field : keyOfEntity(field)) || "";
+    const refs = cache.getParents(key) ?? [];
+    return refs.map((ref) => resolve(ref));
+  };
+  const keyOfEntity = (entity) => {
+    var _a;
+    if (typeof entity === "string") {
+      return entityOfKey(entity) ? entity : null;
+    }
+    if (!(entity == null ? void 0 : entity._type)) {
+      return null;
+    }
+    let entityId = null;
+    if (entity._type in keys) {
+      entityId = ((_a = keys[entity._type]) == null ? void 0 : _a.call(keys, entity)) ?? null;
+    } else if (s(entity.id) || s(entity._id)) {
+      entityId = `${entity.id ?? entity._id}`;
+    }
+    return !entityId ? entityId : `${entity._type}:${entityId}`;
+  };
+  const entityOfKey = (entity) => {
+    if (isObject(entity) && (entity == null ? void 0 : entity._type) && keyOfEntity(entity)) {
+      return entity;
+    }
+    if (!entity || typeof entity !== "string")
+      return null;
+    const [typeName, ...restTypes] = entity.split(":");
+    if (!typeName || restTypes.length < 1)
+      return null;
+    return {
+      _type: typeName,
+      _id: restTypes.join(":")
+    };
+  };
+  const getArgumentsForMutate = (entity, ...args) => {
+    let data = typeof entity === "string" ? args[0] : entity;
+    if (typeof data === "function") {
+      data = data(resolve(entity));
+    } else if (isLinkKey(data)) {
+      data = entityOfKey(data);
+    }
+    return {
+      graphKey: typeof entity === "string" ? entity : keyOfEntity(entity),
+      options: typeof entity === "string" ? args[1] : args[0],
+      data
+    };
+  };
+  if (options2 == null ? void 0 : options2.initialState) {
+    mutate(options2.initialState, { replace: true });
+  }
+  const graphState = {
+    _type: type,
+    _id: id,
+    key: stateKey,
+    mutate,
+    subscribe,
+    resolve,
+    safeResolve,
+    resolveParents,
+    inspectFields,
+    invalidate,
+    keyOfEntity,
+    entityOfKey,
+    getArgumentsForMutate,
+    types: cache.types,
+    cache,
+    subscribers: isDev ? subscribers : void 0,
+    onDebugEvent: debugState.onDebugEvent
+  };
+  cache.onRemoveLink((link, prevValue) => debugState.debug({ type: "garbageRemove", entity: link, prevValue }));
+  return pluginsStore.runPlugins(graphState);
+};
+const createManager = (fragmentKey, initialDocument = {}) => {
+  const tempGraph = {
+    _type: "Temp",
+    _id: "root"
+  };
+  const springGraph = {
+    _type: "Spring",
+    _id: "root"
+  };
+  const manager = createState({
+    _type: "FragmentManager",
+    initialState: initialDocument,
+    plugins: [
+      (state) => {
+        state.$fragment = {
+          root: fragmentKey,
+          temp: "Temp:root"
+        };
+      }
+    ],
+    skip: [b, a]
+  });
+  manager.mutate(tempGraph);
+  manager.mutate(springGraph);
+  return manager;
+};
+const getFragmentQuery = (isSelf) => `
+query FragmentDocument($fragmentSlug: Int!) {
+    ${isSelf ? "fragment" : "fragmentClient"}(fragmentIds: [$fragmentSlug]) {
+        id
+        document
+        linkedFragments {
+            id
+            document
+        }
+    }
+}
+`;
+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,
+      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 BASE_HEADERS = {
+  "Content-Type": "application/json"
+};
+const createFetcher = (baseUrl, defaultHeaders = {}) => {
+  const cache = /* @__PURE__ */ new Map();
+  const inflightRequests = /* @__PURE__ */ new Map();
+  const getCacheKey = (query2, variables, options2) => JSON.stringify({ query: query2, variables, options: options2 });
+  const query = async (query2, variables = {}, options2 = {}) => {
+    const cacheKey = getCacheKey(query2, variables, options2);
+    if (cache.has(cacheKey)) {
+      return cache.get(cacheKey);
+    }
+    if (inflightRequests.has(cacheKey)) {
+      return inflightRequests.get(cacheKey);
+    }
+    const request = fetch(baseUrl, {
+      ...options2,
+      method: "POST",
+      body: JSON.stringify({ query: query2, variables }),
+      headers: {
+        ...BASE_HEADERS,
+        ...defaultHeaders,
+        ...options2.headers
+      }
+    }).then(async (res) => {
+      if (!res.ok) throw new Error(`Fetch error: ${res.status}`);
+      const data = await res.json();
+      cache.set(cacheKey, data);
+      return data;
+    }).finally(() => {
+      inflightRequests.delete(cacheKey);
+    });
+    inflightRequests.set(cacheKey, request);
+    return request;
+  };
+  const invalidate = (endpoint, options2) => {
+    cache.delete(getCacheKey(endpoint, options2));
+  };
+  const clearCache = () => cache.clear();
+  return { query, invalidate, clearCache };
+};
+const createFetchManager = (apiToken, isSelf) => {
+  const fetcher = createFetcher("http://localhost/graphql", {
+    Authorization: `Bearer ${apiToken}`
+  });
+  return createState({
+    initialState: {},
+    plugins: [
+      (state) => {
+        state.cacheDocuments = /* @__PURE__ */ new Map();
+        state.queryFragment = async (fragmentId) => {
+          var _a, _b;
+          if (state.cacheDocuments.has(fragmentId)) {
+            return state.cacheDocuments.get(fragmentId);
+          }
+          const response = await fetcher.query(getFragmentQuery(isSelf), {
+            fragmentSlug: fragmentId
+          });
+          const fragment2 = (_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.fragment) == null ? void 0 : _b[0];
+          let fragmentDocument = fragment2 == null ? void 0 : fragment2.document;
+          if (typeof fragmentDocument === "string") {
+            try {
+              if (Object.keys(JSON.parse(fragmentDocument)).length === 0) {
+                fragmentDocument = getEmptyFragment(fragmentId);
+              }
+            } catch (e2) {
+              console.error(e2);
+            }
+          }
+          if (fragment2) {
+            state.cacheDocuments.set(fragmentId, fragmentDocument);
+            if (Array.isArray(fragment2.linkedFragments)) {
+              fragment2.linkedFragments.forEach(
+                (linkedFragment) => state.cacheDocuments.set(
+                  linkedFragment.id,
+                  linkedFragment.document
+                )
+              );
+            }
+            return state.cacheDocuments.get(fragmentId);
+          }
+          return null;
+        };
+      }
+    ]
+  });
+};
+const createGlobalManager = ({ apiToken, isSelf } = {}) => createState({
+  _type: "GlobalManager",
+  initialState: {
+    fetchManager: createFetchManager(apiToken, isSelf),
+    fragmentsManagers: {},
+    renderTarget: renderTarget$1.canvas
+  },
+  plugins: [
+    (state) => {
+      state.createFragmentManager = (fragmentId, document2) => {
+        var _a, _b;
+        const currentManager = (_b = (_a = state.resolve(state.key)) == null ? void 0 : _a.fragmentsManagers) == null ? void 0 : _b[fragmentId];
+        if (currentManager) {
+          return currentManager;
+        }
+        const manager = createManager(
+          `${nodes$1.Fragment}:${fragmentId}`,
+          document2
+        );
+        state.mutate(state.key, {
+          fragmentsManagers: {
+            [fragmentId]: manager
+          }
+        });
+        return manager;
+      };
+      state.setRenderTarget = (value) => {
+        state.mutate(state.key, {
+          renderTarget: value
+        });
+      };
+    }
+  ]
+});
+let GLOBAL_MANAGER = createGlobalManager();
+const getGlobalManager = () => GLOBAL_MANAGER;
+const GlobalManager$1 = preact.createContext(getGlobalManager());
+const useGlobalManager$1 = (globalManager) => {
+  const currentGlobalManager = x$1(GlobalManager$1);
+  const resultManager = globalManager ?? currentGlobalManager;
+  const [globalManagerGraph] = y$1(resultManager, resultManager == null ? void 0 : resultManager.key);
+  const getFragmentManager = async (id) => {
+    const fragmentDocument = await globalManagerGraph.fetchManager.queryFragment(id);
+    return resultManager.createFragmentManager(id, fragmentDocument);
+  };
+  const setRenderTarget = (value) => {
+    resultManager == null ? void 0 : resultManager.setRenderTarget(value);
+  };
+  return {
+    globalManagerGraph,
+    manager: resultManager,
+    getFragmentManager,
+    setRenderTarget
+  };
+};
+const useRenderTarget$1 = (globalManager) => {
+  const { globalManagerGraph, setRenderTarget } = useGlobalManager$1(globalManager);
+  const renderTargetValue = (globalManagerGraph == null ? void 0 : globalManagerGraph.renderTarget) ?? renderTarget$1.canvas;
+  return {
+    renderTarget: renderTargetValue,
+    isCanvas: renderTargetValue === renderTarget$1.canvas,
+    isDocument: renderTargetValue === renderTarget$1.document,
+    setRenderTarget: (target) => {
+      setRenderTarget(target);
+    }
+  };
+};
+const findBreakpoint = (breakpoints = [], width) => {
+  if (!(breakpoints == null ? void 0 : breakpoints.length)) return null;
+  const sortBreakpoints = breakpoints.toSorted(
+    (a2, b2) => a2.threshold - b2.threshold
+  );
+  return sortBreakpoints.reduce(
+    (prev, curr) => width >= curr.threshold ? curr : prev
+  );
+};
+const useFragmentManager$1 = (fragmentId, globalContext) => {
+  const { globalManagerGraph, manager } = useGlobalManager$1(globalContext);
+  if (!globalManagerGraph) {
+    throw new Error("Need declare global context");
+  }
+  const [loading, setLoading] = d(false);
+  const getFragmentManager = (id) => {
+    var _a;
+    return (_a = globalManagerGraph == null ? void 0 : globalManagerGraph.fragmentsManagers) == null ? void 0 : _a[id];
+  };
+  const loadFragmentManager = async (id) => {
+    setLoading(true);
+    const fragmentDocument = await globalManagerGraph.fetchManager.queryFragment(id);
+    const res = manager == null ? void 0 : manager.createFragmentManager(id, fragmentDocument);
+    setLoading(false);
+    return res;
+  };
+  y$2(() => {
+    loadFragmentManager(fragmentId);
+  }, [fragmentId]);
+  return {
+    loading,
+    manager: getFragmentManager(fragmentId)
+  };
+};
+const useFragment = (fragmentId, globalManager) => {
+  const { manager } = useFragmentManager$1(fragmentId, globalManager);
+  const layerKey = `${nodes$1.Fragment}:${fragmentId}`;
+  const [ref, fragmentRect] = j();
+  const children = useLayerChildren(layerKey, manager);
+  const { isDocument } = useRenderTarget$1(globalManager);
+  const resultChildren = T$1(() => {
+    if (isDocument && manager) {
+      const breakpoints = children == null ? void 0 : children.map(manager.resolve);
+      const activeBreakpoint = findBreakpoint(breakpoints, fragmentRect.width);
+      return activeBreakpoint ? [manager.keyOfEntity(activeBreakpoint)] : [];
+    }
+    return children;
+  }, [children, manager, fragmentRect.width]);
+  return {
+    manager,
+    ref,
+    children: resultChildren
+  };
+};
+const fragment = "_fragment_wbfy9_1";
+const styles = {
+  fragment
+};
+const isVariableLink = (value) => {
+  var _a;
+  return isLink(value) && ((_a = value == null ? void 0 : value.split(":")) == null ? void 0 : _a.at(0)) === nodes$1.Variable;
+};
+const isLink = (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 useFragmentProperties$1 = (fragmentId) => {
+  var _a;
+  const { manager } = useFragmentManager$1(fragmentId);
+  const [instanceFragment] = y$1(manager, (_a = manager == null ? void 0 : manager.$fragment) == null ? void 0 : _a.root);
+  return {
+    properties: (instanceFragment == null ? void 0 : instanceFragment.properties) ?? [],
+    manager
+  };
+};
+const useInstance = (instanceProps) => {
+  const { manager: parentManager } = x$1(FragmentContext);
+  const [instanceLayer] = y$1(parentManager, instanceProps.layerKey);
+  const instanceLayerProps = (instanceLayer == null ? void 0 : instanceLayer.props) ?? {};
+  const styles2 = useLayerStyles(instanceProps.layerKey);
+  const { manager: resultGlobalManager } = useGlobalManager$1(
+    instanceProps == null ? void 0 : instanceProps.globalManager
+  );
+  const resultProps = { ...instanceLayerProps, ...instanceProps.props ?? {} };
+  const resultFragmentId = (instanceProps == null ? void 0 : instanceProps.fragmentId) ?? (instanceLayer == null ? void 0 : instanceLayer.fragment);
+  const { properties: definitions2, manager: innerFragmentManager } = useFragmentProperties$1(resultFragmentId);
+  return {
+    styles: styles2,
+    definitions: definitions2,
+    props: resultProps,
+    parentManager,
+    innerManager: innerFragmentManager,
+    fragmentId: resultFragmentId,
+    globalManager: resultGlobalManager
+  };
+};
+const InstanceContext = preact.createContext({
+  layerKey: null,
+  parentManager: null,
+  innerManager: null,
+  props: {},
+  definitions: []
+});
+const Instance$1 = (instanceProps) => {
+  const {
+    styles: styles2,
+    fragmentId,
+    parentManager,
+    props,
+    innerManager,
+    definitions: definitions2,
+    globalManager
+  } = useInstance(instanceProps);
+  return /* @__PURE__ */ u$1(
+    InstanceContext,
+    {
+      value: {
+        layerKey: instanceProps.layerKey,
+        definitions: definitions2,
+        innerManager,
+        parentManager,
+        props
+      },
+      children: parentManager ? /* @__PURE__ */ u$1("div", { "data-key": instanceProps.layerKey, style: styles2, children: /* @__PURE__ */ u$1(Fragment$1, { fragmentId, globalManager }) }) : /* @__PURE__ */ u$1(Fragment$1, { fragmentId, globalManager })
+    }
+  );
+};
+const useReadVariable = (variableKey) => {
+  const isVariable = isVariableLink(variableKey);
+  const { manager: fragmentManager } = x$1(FragmentContext);
+  const { props, innerManager, layerKey } = x$1(InstanceContext);
+  const resultManager = fragmentManager;
+  const { _id: propertyId } = (resultManager == null ? void 0 : resultManager.entityOfKey(variableKey)) ?? {};
+  const [variableLayer] = y$1(
+    isVariable ? fragmentManager : null,
+    variableKey,
+    {
+      selector: (graph) => graph ? pick(graph, "defaultValue", "required") : graph
+    }
+  );
+  const currentValue = (props == null ? void 0 : props[propertyId]) ?? null;
+  const required = (variableLayer == null ? void 0 : variableLayer.required) ?? false;
+  const defaultValue = (variableLayer == null ? void 0 : variableLayer.defaultValue) ?? null;
+  const resultValue = required ? currentValue : currentValue ?? defaultValue;
+  return {
+    value: resultValue,
+    layer: variableLayer
+  };
+};
+const getParent = (manager, layerKey) => {
+  var _a;
+  const parents = ((_a = manager == null ? void 0 : manager.resolveParents) == null ? void 0 : _a.call(manager, layerKey)) ?? [];
+  return parents == null ? void 0 : parents.find((parent) => {
+    var _a2;
+    return (_a2 = parent == null ? void 0 : parent.children) == null ? void 0 : _a2.includes(layerKey);
+  });
+};
+const isTopLevel = (manager, layerKey) => {
+  var _a;
+  return ((_a = getParent(manager, layerKey)) == null ? void 0 : _a._type) === nodes$1.Fragment;
+};
+const getAllParents = (manager, layerKey, stack = []) => {
+  const parent = getParent(manager, layerKey);
+  if (parent) {
+    stack.push(parent);
+    getAllParents(manager, manager.keyOfEntity(parent), stack);
+  }
+  return stack;
+};
+const isPartOfPrimary = (manager, layerKey) => {
+  var _a;
+  const allParents = getAllParents(manager, manager.keyOfEntity(layerKey));
+  const layer = manager.resolve(layerKey);
+  return (layer == null ? void 0 : layer.isPrimary) ?? !!((_a = allParents == null ? void 0 : allParents.find) == null ? void 0 : _a.call(allParents, (parent) => !!(parent == null ? void 0 : parent.isPrimary)));
+};
+const getOverrider = (manager, layer) => {
+  const layerKey = manager.keyOfEntity(layer);
+  const layerParents = manager.resolveParents(layerKey);
+  const isPartialPrimary = isPartOfPrimary(manager, layerKey);
+  return isPartialPrimary ? manager.resolve(layerKey) : layerParents == null ? void 0 : layerParents.find((parent) => {
+    var _a;
+    return (_a = parent == null ? void 0 : parent.overrides) == null ? void 0 : _a.includes(layerKey);
+  });
+};
+const createConstants$2 = (...constants) => {
+  return constants.reduce((acc, constant) => {
+    acc[constant] = constant;
+    return acc;
+  }, {});
+};
+const nodes$2 = createConstants$2(
+  "Fragment",
+  "FragmentInstance",
+  "Instance",
+  "Breakpoint",
+  "Frame",
+  "Image",
+  "Text",
+  "SolidPaintStyle",
+  "CssLink",
+  "Variable",
+  "ComputedValue",
+  "TransformValue"
+);
+const fragmentGrowingMode$2 = createConstants$2("auto", "fill");
+const borderType$2 = createConstants$2("None", "Solid", "Dashed", "Dotted");
+createConstants$2("_blank");
+const paintMode$2 = createConstants$2("None", "Solid", "Image");
+createConstants$2(
+  "Fill",
+  "Fit",
+  "Crop",
+  "Tile"
+);
+createConstants$2(
+  "Min",
+  "Center",
+  "Max",
+  "Stretch",
+  "Scale"
+);
+const positionType$2 = createConstants$2("absolute", "relative");
+const sizing$2 = createConstants$2("Fixed", "Hug", "Fill", "Relative");
+const layerMode$2 = createConstants$2("none", "flex");
+const layerDirection$2 = createConstants$2("vertical", "horizontal");
+const layerAlign$1 = createConstants$2("start", "center", "end");
+const layerDistribute$1 = createConstants$2(
+  "start",
+  "center",
+  "end",
+  "space-between",
+  "space-around"
+);
+createConstants$2(
+  "none",
+  "uppercase",
+  "lowercase",
+  "capitalize"
+);
+createConstants$2(
+  "none",
+  "underline",
+  "line-through"
+);
+createConstants$2("loop", "appear", "hover", "tap");
+createConstants$2(
+  "fade",
+  "slide",
+  "bounce",
+  "wiggle",
+  "increase"
+);
+const variableType$1 = createConstants$2(
+  "String",
+  "Boolean",
+  "Array",
+  "Color",
+  "ComponentInstance",
+  "Date",
+  "Enum",
+  "Number",
+  "Object"
+);
+createConstants$2(
+  "normal",
+  "nowrap",
+  "pre",
+  "pre-wrap",
+  "pre-line",
+  "break-spaces"
+);
+const overflow$1 = createConstants$2("visible", "hidden", "scroll");
+createConstants$2(
+  "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"
+);
+createConstants$2("canvas", "document");
+createConstants$2("viewport", "parent", "fixed");
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig$1(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$1(lang) {
+  return void 0;
+}
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage$1(lang) {
+  return void 0;
+}
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage$1(reference, lang) {
+  var _a;
+  return (_a = void 0) == null ? void 0 : _a.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify$1(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$1(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$1(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$1(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage$1(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage$1(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$1(context) {
+  return {
+    version: 1,
+    vendor: "valibot",
+    validate(value2) {
+      return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig$1());
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _isValidObjectKey$1(object2, key) {
+  return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects$1(values2, separator) {
+  const list = [...new Set(values2)];
+  if (list.length > 1) {
+    return `(${list.join(` ${separator} `)})`;
+  }
+  return list[0] ?? "never";
+}
+// @__NO_SIDE_EFFECTS__
+function isOfKind(kind, object2) {
+  return object2.kind === kind;
+}
+var ValiError = class extends Error {
+  /**
+   * Creates a Valibot error with useful information.
+   *
+   * @param issues The error issues.
+   */
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function check$1(requirement, message) {
+  return {
+    kind: "validation",
+    type: "check",
+    reference: check$1,
+    async: false,
+    expects: null,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !this.requirement(dataset.value)) {
+        _addIssue$1(this, "input", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function maxValue$1(requirement, message) {
+  return {
+    kind: "validation",
+    type: "max_value",
+    reference: maxValue$1,
+    async: false,
+    expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify$1(requirement)}`,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !(dataset.value <= this.requirement)) {
+        _addIssue$1(this, "value", dataset, config2, {
+          received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify$1(dataset.value)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function metadata$1(metadata_) {
+  return {
+    kind: "metadata",
+    type: "metadata",
+    reference: metadata$1,
+    metadata: metadata_
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minValue$1(requirement, message) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue$1,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify$1(requirement)}`,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !(dataset.value >= this.requirement)) {
+        _addIssue$1(this, "value", dataset, config2, {
+          received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify$1(dataset.value)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function getFallback$1(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$1(schema, dataset, config2) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function array$1(item, message) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array$1,
+    expects: "Array",
+    async: false,
+    item,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(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$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean$1(message) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean$1,
+    expects: "boolean",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "boolean") {
+        dataset.typed = true;
+      } else {
+        _addIssue$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function enum_$1(enum__, message) {
+  const options2 = [];
+  for (const key in enum__) {
+    if (`${+key}` !== key || typeof enum__[key] !== "string" || !Object.is(enum__[enum__[key]], +key)) {
+      options2.push(enum__[key]);
+    }
+  }
+  return {
+    kind: "schema",
+    type: "enum",
+    reference: enum_$1,
+    expects: /* @__PURE__ */ _joinExpects$1(options2.map(_stringify$1), "|"),
+    async: false,
+    enum: enum__,
+    options: options2,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(this);
+    },
+    "~run"(dataset, config2) {
+      if (this.options.includes(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function literal$1(literal_, message) {
+  return {
+    kind: "schema",
+    type: "literal",
+    reference: literal$1,
+    expects: /* @__PURE__ */ _stringify$1(literal_),
+    async: false,
+    literal: literal_,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === this.literal) {
+        dataset.typed = true;
+      } else {
+        _addIssue$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number$1(message) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number$1,
+    expects: "number",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object$1(entries, message) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object$1,
+    expects: "Object",
+    async: false,
+    entries,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(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$1(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$1(valueSchema);
+          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue$1(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$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function optional$1(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional$1,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) {
+          dataset.value = /* @__PURE__ */ getDefault$1(this, dataset, config2);
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config2);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function picklist$1(options2, message) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist$1,
+    expects: /* @__PURE__ */ _joinExpects$1(options2.map(_stringify$1), "|"),
+    async: false,
+    options: options2,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(this);
+    },
+    "~run"(dataset, config2) {
+      if (this.options.includes(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function record$1(key, value2, message) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record$1,
+    expects: "Object",
+    async: false,
+    key,
+    value: value2,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(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$1(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$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string$1(message) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string$1,
+    expects: "string",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue$1(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _subIssues$1(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$1(options2, message) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union$1,
+    expects: /* @__PURE__ */ _joinExpects$1(
+      options2.map((option) => option.expects),
+      "|"
+    ),
+    async: false,
+    options: options2,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(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$1(this, "type", dataset, config2, {
+          issues: /* @__PURE__ */ _subIssues$1(typedDatasets)
+        });
+        dataset.typed = true;
+      } else if ((untypedDatasets == null ? void 0 : untypedDatasets.length) === 1) {
+        return untypedDatasets[0];
+      } else {
+        _addIssue$1(this, "type", dataset, config2, {
+          issues: /* @__PURE__ */ _subIssues$1(untypedDatasets)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+function parse(schema, input, config2) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig$1(config2));
+  if (dataset.issues) {
+    throw new ValiError(dataset.issues);
+  }
+  return dataset.value;
+}
+// @__NO_SIDE_EFFECTS__
+function pipe$1(...pipe2) {
+  return {
+    ...pipe2[0],
+    pipe: pipe2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps$1(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$1 = /* @__PURE__ */ check$1(
+  (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 getMetadata = (schema) => {
+  var _a;
+  const pipelines = (schema == null ? void 0 : schema.pipe) ?? [];
+  return ((_a = pipelines == null ? void 0 : pipelines.find((pipe2) => /* @__PURE__ */ isOfKind("metadata", pipe2))) == null ? void 0 : _a.metadata) ?? null;
+};
+const layerField$1 = (schema, meta) => {
+  const modifiedSchema = (meta == null ? void 0 : meta.variable) ? /* @__PURE__ */ union$1([schema, /* @__PURE__ */ pipe$1(/* @__PURE__ */ string$1(), linkValidator$1)]) : schema;
+  return /* @__PURE__ */ pipe$1(/* @__PURE__ */ optional$1(modifiedSchema), /* @__PURE__ */ metadata$1(meta ?? {}));
+};
+const ChildrenSchema$1 = /* @__PURE__ */ object$1({
+  children: layerField$1(/* @__PURE__ */ array$1(/* @__PURE__ */ string$1()), {
+    fallback: [],
+    overridable: false
+  })
+});
+const GraphFieldSchema$1 = /* @__PURE__ */ object$1({
+  _id: /* @__PURE__ */ union$1([/* @__PURE__ */ string$1(), /* @__PURE__ */ number$1()]),
+  _type: /* @__PURE__ */ picklist$1(Object.keys(nodes$2))
+});
+const OverridesSchema$1 = /* @__PURE__ */ object$1({
+  overrides: layerField$1(/* @__PURE__ */ array$1(/* @__PURE__ */ string$1()), { overridable: false })
+});
+const PositionSchema$1 = /* @__PURE__ */ object$1({
+  position: layerField$1(/* @__PURE__ */ enum_$1(Object.keys(positionType$2)), {
+    fallback: positionType$2.absolute
+  }),
+  top: layerField$1(/* @__PURE__ */ number$1(), { fallback: 0 }),
+  left: layerField$1(/* @__PURE__ */ number$1(), { fallback: 0 })
+});
+const SceneSchema$1 = /* @__PURE__ */ object$1({
+  opacity: layerField$1(/* @__PURE__ */ pipe$1(/* @__PURE__ */ number$1(), /* @__PURE__ */ minValue$1(0), /* @__PURE__ */ maxValue$1(1)), {
+    fallback: 1,
+    variable: true
+  }),
+  visible: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: true, variable: true }),
+  zIndex: layerField$1(/* @__PURE__ */ number$1(), { fallback: -1 }),
+  borderRadius: layerField$1(/* @__PURE__ */ string$1(), { fallback: "0px" }),
+  overflow: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(overflow$1)), {
+    fallback: overflow$1.hidden
+  })
+});
+const FillSchema$1 = /* @__PURE__ */ object$1({
+  fillType: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(paintMode$2)), {
+    fallback: paintMode$2.None
+  }),
+  solidFill: layerField$1(/* @__PURE__ */ string$1(), { fallback: "#fff" })
+});
+const BorderSchema$1 = /* @__PURE__ */ object$1({
+  borderType: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(borderType$2)), {
+    fallback: borderType$2.None
+  }),
+  borderWidth: layerField$1(/* @__PURE__ */ pipe$1(/* @__PURE__ */ number$1(), /* @__PURE__ */ minValue$1(0)), { fallback: 0 }),
+  borderColor: layerField$1(/* @__PURE__ */ string$1(), { fallback: "#fff" })
+});
+const SizeSchema$1 = /* @__PURE__ */ object$1({
+  widthType: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(sizing$2)), {
+    fallback: sizing$2.Fixed
+  }),
+  heightType: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(sizing$2)), {
+    fallback: sizing$2.Fixed
+  }),
+  width: layerField$1(/* @__PURE__ */ pipe$1(/* @__PURE__ */ number$1(), /* @__PURE__ */ minValue$1(0)), { fallback: 0 }),
+  height: layerField$1(/* @__PURE__ */ pipe$1(/* @__PURE__ */ number$1(), /* @__PURE__ */ minValue$1(0)), { fallback: 0 }),
+  aspectRatio: layerField$1(/* @__PURE__ */ number$1(), { fallback: -1 })
+});
+const LayerSchema$1 = /* @__PURE__ */ object$1({
+  layerMode: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(layerMode$2)), {
+    fallback: layerMode$2.none
+  }),
+  layerAlign: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(layerAlign$1)), {
+    fallback: layerAlign$1.start
+  }),
+  layerDirection: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(layerDirection$2)), {
+    fallback: layerDirection$2.horizontal
+  }),
+  layerDistribute: layerField$1(/* @__PURE__ */ picklist$1(Object.keys(layerDistribute$1)), {
+    fallback: layerDistribute$1.start
+  }),
+  layerWrap: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: false }),
+  layerGap: layerField$1(/* @__PURE__ */ pipe$1(/* @__PURE__ */ number$1(), /* @__PURE__ */ minValue$1(0)), { fallback: 0 }),
+  padding: layerField$1(/* @__PURE__ */ string$1(), { fallback: "0px" })
+});
+const FrameSchema = /* @__PURE__ */ pipe$1(
+  /* @__PURE__ */ object$1({
+    name: layerField$1(/* @__PURE__ */ string$1(), { fallback: "Frame", overridable: false }),
+    isBreakpoint: layerField$1(/* @__PURE__ */ boolean$1(), {
+      fallback: false,
+      overridable: false
+    }),
+    isPrimary: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: false, overridable: false }),
+    threshold: layerField$1(/* @__PURE__ */ pipe$1(/* @__PURE__ */ number$1(), /* @__PURE__ */ minValue$1(0)), {
+      fallback: 320,
+      overridable: false
+    }),
+    ...ChildrenSchema$1.entries,
+    ...GraphFieldSchema$1.entries,
+    ...OverridesSchema$1.entries,
+    ...PositionSchema$1.entries,
+    ...SceneSchema$1.entries,
+    ...FillSchema$1.entries,
+    ...BorderSchema$1.entries,
+    ...SizeSchema$1.entries,
+    ...LayerSchema$1.entries
+  })
+);
+const TextSchema = /* @__PURE__ */ object$1({
+  name: layerField$1(/* @__PURE__ */ string$1(), { fallback: "Text", overridable: false }),
+  content: layerField$1(/* @__PURE__ */ string$1(), {
+    fallback: ""
+  }),
+  variableContent: layerField$1(/* @__PURE__ */ string$1(), { fallback: null, variable: true }),
+  attributes: layerField$1(
+    /* @__PURE__ */ object$1({
+      fontSize: layerField$1(/* @__PURE__ */ string$1(), { fallback: "14px" }),
+      color: layerField$1(/* @__PURE__ */ string$1(), { fallback: "#000" }),
+      lineHeight: layerField$1(/* @__PURE__ */ string$1(), { fallback: "14px" })
+    }),
+    { fallback: {} }
+  ),
+  ...GraphFieldSchema$1.entries,
+  ...OverridesSchema$1.entries,
+  ...PositionSchema$1.entries,
+  ...SceneSchema$1.entries,
+  ...SizeSchema$1.entries
+});
+const FragmentSchema = /* @__PURE__ */ object$1({
+  name: layerField$1(/* @__PURE__ */ string$1(), { fallback: "Fragment", overridable: false }),
+  horizontalGrow: layerField$1(/* @__PURE__ */ enum_$1(Object.keys(fragmentGrowingMode$2)), {
+    fallback: fragmentGrowingMode$2.auto,
+    overridable: false
+  }),
+  verticalGrow: layerField$1(/* @__PURE__ */ enum_$1(Object.keys(fragmentGrowingMode$2)), {
+    fallback: fragmentGrowingMode$2.auto,
+    overridable: false
+  }),
+  properties: layerField$1(/* @__PURE__ */ array$1(/* @__PURE__ */ string$1()), {
+    fallback: [],
+    overridable: false
+  }),
+  ...GraphFieldSchema$1.entries,
+  ...ChildrenSchema$1.entries
+});
+const InstanceSchema = /* @__PURE__ */ object$1({
+  name: layerField$1(/* @__PURE__ */ string$1(), { fallback: "Instance", overridable: false }),
+  fragment: layerField$1(/* @__PURE__ */ string$1()),
+  props: layerField$1(
+    /* @__PURE__ */ record$1(/* @__PURE__ */ string$1(), /* @__PURE__ */ union$1([/* @__PURE__ */ string$1(), /* @__PURE__ */ number$1(), /* @__PURE__ */ boolean$1()])),
+    {
+      fallback: {}
+    }
+  ),
+  ...GraphFieldSchema$1.entries,
+  ...OverridesSchema$1.entries,
+  ...PositionSchema$1.entries,
+  ...SizeSchema$1.entries,
+  ...SceneSchema$1.entries
+});
+const NumberVariableSchema = /* @__PURE__ */ object$1({
+  name: layerField$1(/* @__PURE__ */ string$1(), {
+    fallback: "Number",
+    overridable: false
+  }),
+  type: layerField$1(/* @__PURE__ */ literal$1(variableType$1.Number), {
+    fallback: variableType$1.Number
+  }),
+  defaultValue: layerField$1(/* @__PURE__ */ number$1(), { fallback: 0 }),
+  required: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: false }),
+  min: layerField$1(/* @__PURE__ */ number$1(), { fallback: 1 }),
+  max: layerField$1(/* @__PURE__ */ number$1(), { fallback: 100 }),
+  step: layerField$1(/* @__PURE__ */ number$1(), { fallback: 1 }),
+  displayStepper: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: true }),
+  ...GraphFieldSchema$1.entries
+});
+const BooleanVariableSchema = /* @__PURE__ */ object$1({
+  name: layerField$1(/* @__PURE__ */ string$1(), {
+    fallback: "Boolean",
+    overridable: false
+  }),
+  type: layerField$1(/* @__PURE__ */ literal$1(variableType$1.Boolean), {
+    fallback: variableType$1.Boolean
+  }),
+  defaultValue: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: false }),
+  required: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: false }),
+  ...GraphFieldSchema$1.entries
+});
+const ColorVariableSchema = /* @__PURE__ */ object$1({
+  name: layerField$1(/* @__PURE__ */ string$1(), {
+    fallback: "String",
+    overridable: false
+  }),
+  type: layerField$1(/* @__PURE__ */ literal$1(variableType$1.Color), {
+    fallback: variableType$1.Color
+  }),
+  // TODO Add color validator
+  defaultValue: layerField$1(/* @__PURE__ */ string$1(), { fallback: "#000" }),
+  required: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: false }),
+  ...GraphFieldSchema$1.entries
+});
+const StringVariableSchema = /* @__PURE__ */ object$1({
+  name: layerField$1(/* @__PURE__ */ string$1(), {
+    fallback: "String",
+    overridable: false
+  }),
+  type: layerField$1(/* @__PURE__ */ literal$1(variableType$1.String), {
+    fallback: variableType$1.String
+  }),
+  defaultValue: layerField$1(/* @__PURE__ */ string$1(), { fallback: "" }),
+  required: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: false }),
+  placeholder: layerField$1(/* @__PURE__ */ string$1(), { fallback: "" }),
+  isTextarea: layerField$1(/* @__PURE__ */ boolean$1(), { fallback: false }),
+  ...GraphFieldSchema$1.entries
+});
+const getLayerSchema = (layer) => {
+  if (!(layer == null ? void 0 : layer._type)) return null;
+  if ((layer == null ? void 0 : layer._type) === nodes$2.Frame) return FrameSchema;
+  if ((layer == null ? void 0 : layer._type) === nodes$2.Text) return TextSchema;
+  if ((layer == null ? void 0 : layer._type) === nodes$2.Fragment) return FragmentSchema;
+  if ((layer == null ? void 0 : layer._type) === nodes$2.Instance) return InstanceSchema;
+  if (layer._type === nodes$2.Variable) {
+    const types = {
+      [variableType$1.Number]: NumberVariableSchema,
+      [variableType$1.Boolean]: BooleanVariableSchema,
+      [variableType$1.String]: StringVariableSchema,
+      [variableType$1.Color]: ColorVariableSchema
+    };
+    if (layer.type in types) {
+      return types[layer.type];
+    }
+  }
+};
+const normalizeLayer = (schema, rawLayer, options2) => {
+  try {
+    if (!rawLayer) return null;
+    const withFallback = (options2 == null ? void 0 : options2.withFallback) ?? true;
+    const overrideTarget = options2 == null ? void 0 : options2.overrideTarget;
+    const parsedLayer = parse(schema, rawLayer);
+    return Object.fromEntries(
+      Object.entries(schema.entries).map(([key, schemaEntity]) => {
+        const schemaMeta = getMetadata(schemaEntity);
+        const fallback = withFallback ? schemaMeta == null ? void 0 : schemaMeta.fallback : null;
+        const overrideValue = (schemaMeta == null ? void 0 : schemaMeta.overridable) !== false && overrideTarget ? overrideTarget == null ? void 0 : overrideTarget[key] : null;
+        return [key, parsedLayer[key] ?? overrideValue ?? fallback];
+      })
+    );
+  } catch (e2) {
+    console.error(e2);
+    return null;
+  }
+};
+const getNormalizeLayer = (layer, overrider) => {
+  if (!layer) return null;
+  const schema = getLayerSchema(layer);
+  if (!schema) return null;
+  return normalizeLayer(schema, layer, {
+    overrideTarget: overrider
+  });
+};
+const useNormalizeLayer = (layerKey) => {
+  const { manager: fragmentManager } = x$1(FragmentContext);
+  const layerData = fragmentManager.resolve(layerKey);
+  const overrider = getOverrider(fragmentManager, layerKey);
+  const parsedLayer = getNormalizeLayer(layerData, overrider);
+  return {
+    rawLayer: layerData,
+    layer: parsedLayer
+  };
+};
+const useLayerValue = (layerKey, fieldKey) => {
+  const { manager: fragmentManager } = x$1(FragmentContext);
+  const resultManager = fragmentManager;
+  const { layer: normalizeLayer2 } = useNormalizeLayer(layerKey);
+  const [layerData, updateLayerData] = y$1(resultManager, layerKey, {
+    selector: (data) => data ? pick(data, fieldKey) : data
+  });
+  let currentValue = normalizeLayer2 == null ? void 0 : normalizeLayer2[fieldKey];
+  const rawValue = layerData == null ? void 0 : layerData[fieldKey];
+  const { value: variableValue } = useReadVariable(rawValue);
+  const updateValue = q$1(
+    (value) => {
+      updateLayerData({ [fieldKey]: value });
+    },
+    [updateLayerData, fieldKey, currentValue]
+  );
+  currentValue = variableValue ?? currentValue;
+  return [
+    currentValue,
+    updateValue,
+    {
+      isVariable: false
+    }
+  ];
+};
+const autoSizes = [sizing$1.Hug];
+const useLayerSize = (layerKey) => {
+  const { manager: fragmentManager } = x$1(FragmentContext);
+  const { layerKey: instanceLayerKey, parentManager: instanceManager } = x$1(InstanceContext);
+  const { isDocument } = useRenderTarget$1(fragmentManager);
+  const isTop = isTopLevel(fragmentManager, layerKey);
+  //!!instanceLayerKey;
+  const layerParent = getParent(fragmentManager, layerKey);
+  useLayerValue(instanceLayerKey, "widthType");
+  useLayerValue(instanceLayerKey, "heightType");
+  const [width] = useLayerValue(layerKey, "width");
+  const [height] = useLayerValue(layerKey, "height");
+  const [widthType] = useLayerValue(layerKey, "widthType");
+  const [heightType] = useLayerValue(layerKey, "heightType");
+  const toValue = (type, value, instanceType) => {
+    if (autoSizes.includes(type)) {
+      return "min-content";
+    }
+    if (type === sizing$1.Relative) {
+      return `${value}%`;
+    }
+    if (type === sizing$1.Fill) {
+      return `100%`;
+    }
+    return value;
+  };
+  return T$1(
+    () => ({
+      width: isTop && isDocument && (layerParent == null ? void 0 : layerParent.horizontalGrow) === fragmentGrowingMode$1.fill ? "100%" : toValue(widthType, width),
+      height: isTop && isDocument && (layerParent == null ? void 0 : layerParent.horizontalGrow) === fragmentGrowingMode$1.fill ? "100%" : toValue(heightType, height)
+    }),
+    [isTop, isDocument, width, height, heightType, heightType]
+  );
+};
+const useLayerPosition = (layerKey) => {
+  const { layerKey: instanceLayerKey } = x$1(InstanceContext);
+  const { manager: fragmentManager } = x$1(FragmentContext);
+  const { isDocument } = useRenderTarget$1();
+  const isTop = isTopLevel(fragmentManager, layerKey);
+  const skipPosition = isTop && isDocument || !!instanceLayerKey && isTop;
+  const [position] = useLayerValue(layerKey, "position");
+  const [top] = useLayerValue(layerKey, "top");
+  const [left] = useLayerValue(layerKey, "left");
+  return T$1(
+    () => ({
+      position: skipPosition ? positionType$1.relative : position,
+      top: position === positionType$1.absolute && !skipPosition ? top : null,
+      left: position === positionType$1.absolute && !skipPosition ? left : null
+    }),
+    [skipPosition, position, top]
+  );
+};
+const useLayerBackground = (layerKey) => {
+  const [fillType] = useLayerValue(layerKey, "fillType");
+  const [solidFill] = useLayerValue(layerKey, "solidFill");
+  return T$1(
+    () => ({
+      background: fillType === paintMode$1.Solid ? solidFill : "transparent"
+    }),
+    [fillType, solidFill]
+  );
+};
+const useLayerDisplay = (layerKey) => {
+  const [layerModeValue] = useLayerValue(layerKey, "layerMode");
+  const [visible] = useLayerValue(layerKey, "visible");
+  return T$1(() => {
+    if (!visible) {
+      return "none";
+    }
+    return layerModeValue === layerMode$1.flex ? "flex" : null;
+  }, [layerModeValue, visible]);
+};
+const useLayerBorder = (layerKey) => {
+  const [borderTypeValue] = useLayerValue(layerKey, "borderType");
+  const [borderWidth] = useLayerValue(layerKey, "borderWidth");
+  const [borderColor] = useLayerValue(layerKey, "borderColor");
+  return T$1(() => {
+    let value = "";
+    if (typeof borderTypeValue === "string" && borderTypeValue !== borderType$1.None) {
+      value = `${toPx(
+        borderWidth
+      )} ${borderTypeValue.toLowerCase()} ${borderColor}`;
+    }
+    return {
+      border: value
+    };
+  }, [borderTypeValue, borderWidth, borderColor]);
+};
+const useLayerLayout = (layerKey) => {
+  const [layerModeValue] = useLayerValue(layerKey, "layerMode");
+  const [layerGap] = useLayerValue(layerKey, "layerGap");
+  const [layerWrap] = useLayerValue(layerKey, "layerWrap");
+  const [layerDistribute2] = useLayerValue(layerKey, "layerDistribute");
+  const [layerDirectionValue] = useLayerValue(layerKey, "layerDirection");
+  const [layerAlign2] = useLayerValue(layerKey, "layerAlign");
+  const [padding] = useLayerValue(layerKey, "padding");
+  const isFlex = layerModeValue === layerMode$1.flex;
+  return {
+    gap: isFlex ? layerGap : null,
+    flexWrap: isFlex ? layerWrap : null,
+    justifyContent: isFlex ? layerDistribute2 : null,
+    flexDirection: isFlex ? layerDirectionValue === layerDirection$1.vertical ? "column" : "row" : null,
+    alignItems: isFlex ? layerAlign2 : null,
+    padding: isFlex ? padding : null
+  };
+};
+const useLayerStyles = (layerKey) => {
+  try {
+    if (!layerKey) {
+      throw new Error("Empty layer key");
+    }
+    const [opacity] = useLayerValue(layerKey, "opacity");
+    const { width, height } = useLayerSize(layerKey);
+    const { position, top, left } = useLayerPosition(layerKey);
+    const display = useLayerDisplay(layerKey);
+    const { background } = useLayerBackground(layerKey);
+    const { border } = useLayerBorder(layerKey);
+    const layout = useLayerLayout(layerKey);
+    const [zIndex] = useLayerValue(layerKey, "zIndex");
+    const [borderRadius] = useLayerValue(layerKey, "borderRadius");
+    return {
+      display,
+      border,
+      background,
+      position,
+      top,
+      left,
+      width,
+      height,
+      opacity,
+      borderRadius,
+      zIndex: zIndex !== -1 ? zIndex : null,
+      ...layout,
+      userSelect: "none"
+    };
+  } catch (e2) {
+    return {};
+  }
+};
+const useFrame = (layerKey) => {
+  const { manager: fragmentManager } = x$1(FragmentContext);
+  const layer = fragmentManager.entityOfKey(layerKey);
+  const styles2 = useLayerStyles(layerKey);
+  const children = useLayerChildren(layerKey);
+  return {
+    type: layer._type,
+    styles: styles2,
+    children
+  };
+};
+const text = "_text_1liuf_1";
+const cssStyles = {
+  text
+};
+const allowAttributes = [
+  "fontSize",
+  "fontWeight",
+  "color",
+  "lineHeight",
+  "letterSpacing",
+  "textTransform",
+  "textDecoration",
+  "textAlign"
+];
+const wrapTextInParagraphWithAttributes = (text2, attributes) => {
+  if (text2.startsWith("<p")) return text2;
+  const style = Object.entries(attributes).filter(
+    ([key, value]) => isValue(value) && allowAttributes.includes(key) && typeof value === "string" && !!value.length
+  ).map(([key, value]) => `${toKebabCase(key)}: ${value}`).join("; ");
+  return `<p style="${style}">${text2}</p>`;
+};
+const useTextContent = (layerKey, manager) => {
+  const [content, _2, contentInfo] = useLayerValue(layerKey, "content");
+  const [attributes] = useLayerValue(layerKey, "attributes");
+  return T$1(() => {
+    if (contentInfo.isVariable && isValue(attributes)) {
+      return wrapTextInParagraphWithAttributes(content, attributes);
+    }
+    return content;
+  }, [contentInfo, content, attributes]);
+};
+const useTextAttributes = (layerKey) => {
+  const styles2 = useLayerStyles(layerKey);
+  const content = useTextContent(layerKey);
+  return {
+    styles: styles2,
+    content
+  };
+};
+const Text = ({ layerKey }) => {
+  const { styles: styles2, content } = useTextAttributes(layerKey);
+  return /* @__PURE__ */ u$1("div", { style: styles2, "data-key": layerKey, children: /* @__PURE__ */ u$1(
+    "div",
+    {
+      className: cssStyles.text,
+      dangerouslySetInnerHTML: { __html: content }
+    }
+  ) });
+};
+const Frame = ({ layerKey }) => {
+  const { styles: styles2, children, type } = useFrame(layerKey);
+  if (type === nodes$1.Text) {
+    return /* @__PURE__ */ u$1(Text, { layerKey });
+  }
+  if (type === nodes$1.Instance) {
+    return /* @__PURE__ */ u$1(Instance$1, { layerKey });
+  }
+  return /* @__PURE__ */ u$1("div", { style: styles2, "data-key": layerKey, children: children.map((childLink) => /* @__PURE__ */ u$1(Frame, { layerKey: childLink }, childLink)) });
+};
+const Fragment$1 = ({ fragmentId, globalManager }) => {
+  const { manager: resultGlobalManager } = useGlobalManager$1(globalManager);
+  const { ref, children, manager } = useFragment(fragmentId, globalManager);
+  return /* @__PURE__ */ u$1(GlobalManager$1, { value: resultGlobalManager, children: /* @__PURE__ */ u$1(FragmentProvider, { manager, children: /* @__PURE__ */ u$1(
+    "div",
+    {
+      ref,
+      "data-key": `${nodes$1.Fragment}:${fragmentId}`,
+      className: styles.fragment,
+      children: children.map((childLink) => /* @__PURE__ */ u$1(Frame, { layerKey: childLink }, childLink))
+    }
+  ) }) });
+};
+const GlobalManager = require$$0$1.createContext(null);
+function createReactComponent(PreactComponent) {
+  return function ReactWrapper(props) {
+    const globalManager = require$$0$1.useContext(GlobalManager);
+    const containerRef = require$$0$1.useRef(null);
+    require$$0$1.useEffect(() => {
+      if (containerRef.current) {
+        preact.render(
+          preact.createElement(PreactComponent, {
+            ...props,
+            globalManager: (props == null ? void 0 : props.globalManager) ?? globalManager
+          }),
+          containerRef.current
+        );
+      }
+      return () => {
+        if (containerRef.current) {
+          preact.render(null, containerRef.current);
+        }
+      };
+    }, [props, globalManager]);
+    return require$$0$1.createElement("div", { ref: containerRef });
+  };
+}
+const useGlobalManager = () => require$$0$1.useContext(GlobalManager);
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production_min = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_production_min;
+function requireUseSyncExternalStoreShim_production_min() {
+  if (hasRequiredUseSyncExternalStoreShim_production_min) return useSyncExternalStoreShim_production_min;
+  hasRequiredUseSyncExternalStoreShim_production_min = 1;
+  var e2 = require$$0$1;
+  function h2(a2, b2) {
+    return a2 === b2 && (0 !== a2 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+  }
+  var k2 = "function" === typeof Object.is ? Object.is : h2, l2 = e2.useState, m2 = e2.useEffect, n2 = e2.useLayoutEffect, p2 = e2.useDebugValue;
+  function q2(a2, b2) {
+    var d2 = b2(), f2 = l2({ inst: { value: d2, getSnapshot: b2 } }), c2 = f2[0].inst, g2 = f2[1];
+    n2(function() {
+      c2.value = d2;
+      c2.getSnapshot = b2;
+      r2(c2) && g2({ inst: c2 });
+    }, [a2, d2, b2]);
+    m2(function() {
+      r2(c2) && g2({ inst: c2 });
+      return a2(function() {
+        r2(c2) && g2({ inst: c2 });
+      });
+    }, [a2]);
+    p2(d2);
+    return d2;
+  }
+  function r2(a2) {
+    var b2 = a2.getSnapshot;
+    a2 = a2.value;
+    try {
+      var d2 = b2();
+      return !k2(a2, d2);
+    } catch (f2) {
+      return true;
+    }
+  }
+  function t2(a2, b2) {
+    return b2();
+  }
+  var u2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t2 : q2;
+  useSyncExternalStoreShim_production_min.useSyncExternalStore = void 0 !== e2.useSyncExternalStore ? e2.useSyncExternalStore : u2;
+  return useSyncExternalStoreShim_production_min;
+}
+var useSyncExternalStoreShim_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_development;
+function requireUseSyncExternalStoreShim_development() {
+  if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+  hasRequiredUseSyncExternalStoreShim_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React = require$$0$1;
+      var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+      function error(format) {
+        {
+          {
+            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+            printWarning("error", format, args);
+          }
+        }
+      }
+      function printWarning(level, format, args) {
+        {
+          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+          var stack = ReactDebugCurrentFrame.getStackAddendum();
+          if (stack !== "") {
+            format += "%s";
+            args = args.concat([stack]);
+          }
+          var argsWithFormat = args.map(function(item) {
+            return String(item);
+          });
+          argsWithFormat.unshift("Warning: " + format);
+          Function.prototype.apply.call(console[level], console, argsWithFormat);
+        }
+      }
+      function is(x2, y2) {
+        return x2 === y2 && (x2 !== 0 || 1 / x2 === 1 / y2) || x2 !== x2 && y2 !== y2;
+      }
+      var objectIs = typeof Object.is === "function" ? Object.is : is;
+      var useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue;
+      var didWarnOld18Alpha = false;
+      var didWarnUncachedGetSnapshot = false;
+      function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+        {
+          if (!didWarnOld18Alpha) {
+            if (React.startTransition !== void 0) {
+              didWarnOld18Alpha = true;
+              error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.");
+            }
+          }
+        }
+        var value = getSnapshot();
+        {
+          if (!didWarnUncachedGetSnapshot) {
+            var cachedValue = getSnapshot();
+            if (!objectIs(value, cachedValue)) {
+              error("The result of getSnapshot should be cached to avoid an infinite loop");
+              didWarnUncachedGetSnapshot = true;
+            }
+          }
+        }
+        var _useState = useState({
+          inst: {
+            value,
+            getSnapshot
+          }
+        }), inst = _useState[0].inst, forceUpdate = _useState[1];
+        useLayoutEffect(function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+        }, [subscribe, value, getSnapshot]);
+        useEffect(function() {
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+          var handleStoreChange = function() {
+            if (checkIfSnapshotChanged(inst)) {
+              forceUpdate({
+                inst
+              });
+            }
+          };
+          return subscribe(handleStoreChange);
+        }, [subscribe]);
+        useDebugValue(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        var prevValue = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(prevValue, nextValue);
+        } catch (error2) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+        return getSnapshot();
+      }
+      var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+      var isServerEnvironment = !canUseDOM;
+      var shim2 = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+      var useSyncExternalStore$2 = React.useSyncExternalStore !== void 0 ? React.useSyncExternalStore : shim2;
+      useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
+  }
+  return useSyncExternalStoreShim_development;
+}
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim.exports;
+  hasRequiredShim = 1;
+  if (process.env.NODE_ENV === "production") {
+    shim.exports = requireUseSyncExternalStoreShim_production_min();
+  } else {
+    shim.exports = requireUseSyncExternalStoreShim_development();
+  }
+  return shim.exports;
+}
+var shimExports = requireShim();
+var withSelector = { exports: {} };
+var withSelector_production_min = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredWithSelector_production_min;
+function requireWithSelector_production_min() {
+  if (hasRequiredWithSelector_production_min) return withSelector_production_min;
+  hasRequiredWithSelector_production_min = 1;
+  var h2 = require$$0$1, n2 = requireShim();
+  function p2(a2, b2) {
+    return a2 === b2 && (0 !== a2 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+  }
+  var q2 = "function" === typeof Object.is ? Object.is : p2, r2 = n2.useSyncExternalStore, t2 = h2.useRef, u2 = h2.useEffect, v2 = h2.useMemo, w2 = h2.useDebugValue;
+  withSelector_production_min.useSyncExternalStoreWithSelector = function(a2, b2, e2, l2, g2) {
+    var c2 = t2(null);
+    if (null === c2.current) {
+      var f2 = { hasValue: false, value: null };
+      c2.current = f2;
+    } else f2 = c2.current;
+    c2 = v2(function() {
+      function a3(a4) {
+        if (!c3) {
+          c3 = true;
+          d3 = a4;
+          a4 = l2(a4);
+          if (void 0 !== g2 && f2.hasValue) {
+            var b3 = f2.value;
+            if (g2(b3, a4)) return k2 = b3;
+          }
+          return k2 = a4;
+        }
+        b3 = k2;
+        if (q2(d3, a4)) return b3;
+        var e3 = l2(a4);
+        if (void 0 !== g2 && g2(b3, e3)) return b3;
+        d3 = a4;
+        return k2 = e3;
+      }
+      var c3 = false, d3, k2, m2 = void 0 === e2 ? null : e2;
+      return [function() {
+        return a3(b2());
+      }, null === m2 ? void 0 : function() {
+        return a3(m2());
+      }];
+    }, [b2, e2, l2, g2]);
+    var d2 = r2(a2, c2[0], c2[1]);
+    u2(function() {
+      f2.hasValue = true;
+      f2.value = d2;
+    }, [d2]);
+    w2(d2);
+    return d2;
+  };
+  return withSelector_production_min;
+}
+var withSelector_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredWithSelector_development;
+function requireWithSelector_development() {
+  if (hasRequiredWithSelector_development) return withSelector_development;
+  hasRequiredWithSelector_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React = require$$0$1;
+      var shim2 = requireShim();
+      function is(x2, y2) {
+        return x2 === y2 && (x2 !== 0 || 1 / x2 === 1 / y2) || x2 !== x2 && y2 !== y2;
+      }
+      var objectIs = typeof Object.is === "function" ? Object.is : is;
+      var useSyncExternalStore = shim2.useSyncExternalStore;
+      var useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+      function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+        var instRef = useRef(null);
+        var inst;
+        if (instRef.current === null) {
+          inst = {
+            hasValue: false,
+            value: null
+          };
+          instRef.current = inst;
+        } else {
+          inst = instRef.current;
+        }
+        var _useMemo = useMemo(function() {
+          var hasMemo = false;
+          var memoizedSnapshot;
+          var memoizedSelection;
+          var memoizedSelector = function(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = true;
+              memoizedSnapshot = nextSnapshot;
+              var _nextSelection = selector(nextSnapshot);
+              if (isEqual !== void 0) {
+                if (inst.hasValue) {
+                  var currentSelection = inst.value;
+                  if (isEqual(currentSelection, _nextSelection)) {
+                    memoizedSelection = currentSelection;
+                    return currentSelection;
+                  }
+                }
+              }
+              memoizedSelection = _nextSelection;
+              return _nextSelection;
+            }
+            var prevSnapshot = memoizedSnapshot;
+            var prevSelection = memoizedSelection;
+            if (objectIs(prevSnapshot, nextSnapshot)) {
+              return prevSelection;
+            }
+            var nextSelection = selector(nextSnapshot);
+            if (isEqual !== void 0 && isEqual(prevSelection, nextSelection)) {
+              return prevSelection;
+            }
+            memoizedSnapshot = nextSnapshot;
+            memoizedSelection = nextSelection;
+            return nextSelection;
+          };
+          var maybeGetServerSnapshot = getServerSnapshot === void 0 ? null : getServerSnapshot;
+          var getSnapshotWithSelector = function() {
+            return memoizedSelector(getSnapshot());
+          };
+          var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? void 0 : function() {
+            return memoizedSelector(maybeGetServerSnapshot());
+          };
+          return [getSnapshotWithSelector, getServerSnapshotWithSelector];
+        }, [getSnapshot, getServerSnapshot, selector, isEqual]), getSelection = _useMemo[0], getServerSelection = _useMemo[1];
+        var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
+        useEffect(function() {
+          inst.hasValue = true;
+          inst.value = value;
+        }, [value]);
+        useDebugValue(value);
+        return value;
+      }
+      withSelector_development.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
+  }
+  return withSelector_development;
+}
+var hasRequiredWithSelector;
+function requireWithSelector() {
+  if (hasRequiredWithSelector) return withSelector.exports;
+  hasRequiredWithSelector = 1;
+  if (process.env.NODE_ENV === "production") {
+    withSelector.exports = requireWithSelector_production_min();
+  } else {
+    withSelector.exports = requireWithSelector_development();
+  }
+  return withSelector.exports;
+}
+requireWithSelector();
+var y = (t2, e2, n2) => {
+  var _a, _b;
+  let r2 = require$$0$1.useRef((_a = t2 == null ? void 0 : t2.resolve) == null ? void 0 : _a.call(t2, e2, n2)), s2 = ((_b = t2 == null ? void 0 : t2.keyOfEntity) == null ? void 0 : _b.call(t2, e2)) ?? e2, u2 = require$$0$1.useCallback((o2) => {
+    var _a2, _b2;
+    return s2 ? (r2.current = (_a2 = t2 == null ? void 0 : t2.resolve) == null ? void 0 : _a2.call(t2, s2, n2), o2(), (_b2 = t2 == null ? void 0 : t2.subscribe) == null ? void 0 : _b2.call(t2, s2, () => {
+      var _a3;
+      return r2.current = (_a3 = t2 == null ? void 0 : t2.resolve) == null ? void 0 : _a3.call(t2, s2, n2), o2();
+    }, n2)) : () => {
+    };
+  }, [t2, s2]), i2 = require$$0$1.useCallback((o2) => {
+    let p2 = typeof e2 == "string" ? e2 : t2.keyOfEntity(e2);
+    e2 && p2 && t2.mutate(p2, o2);
+  }, [t2, e2]), a2 = () => r2.current;
+  return [shimExports.useSyncExternalStore(u2, a2, a2), i2];
+};
+const useFragmentManager = (fragmentId) => {
+  const globalManager = useGlobalManager();
+  const [globalGraph] = y(globalManager, globalManager == null ? void 0 : globalManager.key);
+  const [loading, setLoading] = require$$0$1.useState(false);
+  const getFragmentManager = (id) => {
+    var _a;
+    return (_a = globalGraph == null ? void 0 : globalGraph.fragmentsManagers) == null ? void 0 : _a[id];
+  };
+  const loadFragmentManager = async (id) => {
+    setLoading(true);
+    const fragmentDocument = await globalGraph.fetchManager.queryFragment(id);
+    const res = globalManager == null ? void 0 : globalManager.createFragmentManager(id, fragmentDocument);
+    setLoading(false);
+    return res;
+  };
+  require$$0$1.useEffect(() => {
+    loadFragmentManager(fragmentId);
+  }, [fragmentId]);
+  return {
+    loading,
+    manager: getFragmentManager(fragmentId)
+  };
+};
+const useFragmentProperties = (fragmentId) => {
+  var _a;
+  const { manager } = useFragmentManager(fragmentId);
+  const [instanceFragment] = y(manager, (_a = manager == null ? void 0 : manager.$fragment) == null ? void 0 : _a.root);
+  return (instanceFragment == null ? void 0 : instanceFragment.properties) ?? [];
+};
+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(
+  "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 index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  borderType,
+  constrain,
+  createConstants,
+  effectName,
+  effectType,
+  fragmentGrowingMode,
+  imagePaintScaleModes,
+  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 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 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 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__ */ 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 })
+});
+const PositionSchema = /* @__PURE__ */ object({
+  position: layerField(/* @__PURE__ */ enum_(Object.keys(positionType)), {
+    fallback: positionType.absolute
+  }),
+  top: layerField(/* @__PURE__ */ number(), { fallback: 0 }),
+  left: layerField(/* @__PURE__ */ number(), { fallback: 0 })
+});
+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 }),
+  borderRadius: layerField(/* @__PURE__ */ string(), { fallback: "0px" }),
+  overflow: layerField(/* @__PURE__ */ picklist(Object.keys(overflow)), {
+    fallback: overflow.hidden
+  })
+});
+const FillSchema = /* @__PURE__ */ object({
+  fillType: layerField(/* @__PURE__ */ picklist(Object.keys(paintMode)), {
+    fallback: paintMode.None
+  }),
+  solidFill: layerField(/* @__PURE__ */ string(), { fallback: "#fff" })
+});
+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 }),
+  height: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), { fallback: 0 }),
+  aspectRatio: layerField(/* @__PURE__ */ number(), { fallback: -1 })
+});
+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" })
+});
+/* @__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 }),
+    threshold: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), {
+      fallback: 320,
+      overridable: false
+    }),
+    ...ChildrenSchema.entries,
+    ...GraphFieldSchema.entries,
+    ...OverridesSchema.entries,
+    ...PositionSchema.entries,
+    ...SceneSchema.entries,
+    ...FillSchema.entries,
+    ...BorderSchema.entries,
+    ...SizeSchema.entries,
+    ...LayerSchema.entries
+  })
+);
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), { fallback: "Text", overridable: false }),
+  content: layerField(/* @__PURE__ */ string(), {
+    fallback: ""
+  }),
+  variableContent: layerField(/* @__PURE__ */ string(), { fallback: null, variable: true }),
+  attributes: layerField(
+    /* @__PURE__ */ object({
+      fontSize: layerField(/* @__PURE__ */ string(), { fallback: "14px" }),
+      color: layerField(/* @__PURE__ */ string(), { fallback: "#000" }),
+      lineHeight: layerField(/* @__PURE__ */ string(), { fallback: "14px" })
+    }),
+    { fallback: {} }
+  ),
+  ...GraphFieldSchema.entries,
+  ...OverridesSchema.entries,
+  ...PositionSchema.entries,
+  ...SceneSchema.entries,
+  ...SizeSchema.entries
+});
+/* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), { fallback: "Fragment", 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__ */ string()),
+  props: layerField(
+    /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ number(), /* @__PURE__ */ boolean()])),
+    {
+      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
+});
+const useRenderTarget = () => {
+  const globalManager = useGlobalManager();
+  const [globalManagerGraph] = y(globalManager, globalManager == null ? void 0 : globalManager.key);
+  const renderTargetValue = (globalManagerGraph == null ? void 0 : globalManagerGraph.renderTarget) ?? index.renderTarget.canvas;
+  return {
+    renderTarget: renderTargetValue,
+    isCanvas: renderTargetValue === index.renderTarget.canvas,
+    isDocument: renderTargetValue === index.renderTarget.document,
+    setRenderTarget: (target) => {
+      globalManager == null ? void 0 : globalManager.setRenderTarget(target);
+    }
+  };
+};
+const Fragment = createReactComponent(Fragment$1);
+const Instance = createReactComponent(Instance$1);
+exports.Fragment = Fragment;
+exports.GlobalManager = GlobalManager;
+exports.Instance = Instance;
+exports.useFragmentManager = useFragmentManager;
+exports.useFragmentProperties = useFragmentProperties;
+exports.useGlobalManager = useGlobalManager;
+exports.useRenderTarget = useRenderTarget;